hdu Farm Irrigation

这题第一感觉是用搜索做，暴力就可以解决，这里将水管转换成一个个3*3的矩阵，然后搜素就可以了。写完之后确实一遍过掉了，31ms。附上代码：

#include"iostream"
#include"stdio.h"
#include"algorithm"
#include"cmath"
#include"queue"
#include"stack"
#include"vector"
#include"string"
#include"string.h"
using namespace std;
const int mx=;
int A[][]={{,,},{,,},{,,}};
int B[][]={{,,},{,,},{,,}};
int C[][]={{,,},{,,},{,,}};
int D[][]={{,,},{,,},{,,}};
int E[][]={{,,},{,,},{,,}};
int F[][]={{,,},{,,},{,,}};
int G[][]={{,,},{,,},{,,}};
int H[][]={{,,},{,,},{,,}};
int I[][]={{,,},{,,},{,,}};
int J[][]={{,,},{,,},{,,}};
int K[][]={{,,},{,,},{,,}};
int dir[][]={{,},{,},{,-},{-,}};
int maze[mx][mx];
bool visited[mx][mx];
int m,n,wellspring;
bool judge(int x,int y)
{
    if(x>=&&x<*m&&y>=&&y<*n&&maze[x][y]==&&!visited[x][y])
        return true;
    return false;
}
void dfs(int x,int y)
{
    int dx,dy;
    for(int i=;i<;i++)
    {
        dx=x+dir[i][];
        dy=y+dir[i][];
        if(judge(dx,dy))
        {
            visited[dx][dy]=true;
             dfs(dx,dy);
        }
    }
}
void creat_maze(int a[][],int i,int j)
{
    int p,q;
    for(p=i*;p<i*+;p++)
    {
        for(q=j*;q<j*+;q++)
        {
            maze[p][q]=a[p-i*][q-j*];
        }
    }
}
void wellspring_count()
{
    int i,j;
    for(i=;i<*m;i++)
    {
        for(j=;j<*n;j++)
        {
            if(maze[i][j]==&&!visited[i][j])
            {
                wellspring++;
                visited[i][j]=true;
                dfs(i,j);
            }
        }
    }
    printf("%d\n",wellspring);
}
void input()
{
    int i,j;
    while(scanf("%d%d",&m,&n),m!=-||n!=-)
    {
        memset(visited,false,sizeof(visited));
        wellspring=;
        char pipe;
        for(i=;i<m;i++)
       {
           getchar();
        for(j=;j<n;j++)
        {
            scanf("%c",&pipe);
            switch(pipe)
            {
                case 'A': creat_maze(A,i,j);break;
                case 'B': creat_maze(B,i,j);break;
                case 'C': creat_maze(C,i,j);break;
                case 'D': creat_maze(D,i,j);break;
                case 'E': creat_maze(E,i,j);break;
                case 'F': creat_maze(F,i,j);break;
                case 'G': creat_maze(G,i,j);break;
                case 'H': creat_maze(H,i,j);break;
                case 'I': creat_maze(I,i,j);break;
                case 'J': creat_maze(J,i,j);break;
                case 'K': creat_maze(K,i,j);break;
            }
        }
       }
        wellspring_count();
    }
}

int main()
{
 //   freopen("E:\\in.txt","r",stdin);
    input();
    return ;
}

但是这是一个并查集专题里的题，所以应该还会有更高效的方法，毕竟我的代码里没有用到并查集。

所以又想了一下，瞬变看了一下别人的并查集思路，又写了一个代码。然而，这次用并查集却死活过不了。。。找bug找了接近两个小时了，自己找的案例都过掉了。。。

先附上wa掉的代码：

#include"iostream"
#include"stdio.h"
#include"string"
#include"string.h"
#include"cmath"
#include"algorithm"
#include"ctype.h"
#include"queue"
#include"stack"
#include"vector"
using namespace std;
const int mx=;
int maze[mx][mx];
int fa[mx*mx];
int m,n,wellspring;
int dir[][]={{,-},{-,},{,},{,}};//左上右下
//左上右下有水管接口的用1表示
int farm[][]=
{
    {,,,},
    {,,,},
    {,,,},
    {,,,},
    {,,,},
    {,,,},
    {,,,},
    {,,,},
    {,,,},
    {,,,},
    {,,,}
};
void Set()
{
    int i;
    for(i=;i<m*n;i++)
        fa[i]=i;
}

int Find(int x)
{
    int t1,t2=x;
    while(t2!=fa[t2]) t2=fa[t2];
    return t2;
}

void Union(int x,int y)
{
    int fx=Find(x);
    int fy=Find(y);
    if(fx!=fy)
    {
        fa[fx]=fy;
        wellspring--;
    }
}

bool judge(int k,int x,int y)
{
    switch(k)
    {
    case :
        if(farm[x][]&&farm[y][])
            return true;
        break;
    case :
        if(farm[x][]&&farm[y][])
            return true;
        break;
    case :
        if(farm[x][]&&farm[y][])
            return true;
        break;
    case :
        if(farm[x][]&&farm[y][])
            return true;
        break;
    }
    return false;
}

void Count()
{
    int i,j,k,dx,dy;
    for(i=;i<m;i++)
    {
        for(j=;j<n;j++)
        {
            for(k=;k<;k++)
            {
                dx=i+dir[k][];
                dy=j+dir[k][];
                if(dx>=&&dx<m&&dy>=&&dy<n)//判定越界条件
                if(judge(k,maze[i][j],maze[dx][dy]))
                    Union(i*m+j,dx*m+dy);
            }
        }
    }
}

void Input()
{
    int i,j;
    while(scanf("%d%d",&m,&n),m>=&&n>=)
    {
        Set();
        wellspring=m*n;
        char pipe;
        for(i=;i<m;i++)
        {
            getchar();
            for(j=;j<n;j++)
            {
                scanf("%c",&pipe);
                maze[i][j]=pipe-'A';
            }
        }
        Count();
        printf("%d\n",wellspring);
    }
}

int main()
{
  //  freopen("E:\\in.txt","r",stdin);
    Input();
    return ;
}