ZOJ 3781 Paint the Grid Reloaded（DFS连通块缩点+BFS求最短路）

题目链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=5268

题目大意：字符一样并且相邻的即为连通。每次可翻转一个连通块X(O)的颜色，问至少改变几次使得图上所有字符都相等。

解题思路：

1) dfs( 建图 ) ,因为翻转的时候每翻转连通块中一个整个连通块都翻转，
这样你可以将其看成一个有边相连的无向图，每个边的两个顶点颜色都不一样。

2) bfs( 寻找最优解 ) , 建完图后就需要翻转计算最优解，可以枚举从每一点开始翻转所得到的最小步数，那怎样寻找最小步数 ？
假如从 v 这个顶点出发，那么与 v 相邻的顶点颜色必定都与 v 相反，so~> 你只需要把 v的颜色翻转，
v与它相邻的所有顶点都是同一个颜色，这时可以把这些顶点看成一个连通块（顶点），再向四周扩展，
再次扩展时，周围的颜色必定与此连通块颜色相反，再将它变成与周围顶点相同的颜色，
这样又合并成为一个连通块……这样一直进行下去取最大步数。最后从最大步数中取出最小的步数即为最优解。

代码:

#include<cstdio>
#include<cmath>
#include<cctype>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<set>
#include<map>
#include<stack>
#include<string>
#define lc(a) (a<<1)
#define rc(a) (a<<1|1)
#define MID(a,b) ((a+b)>>1)
#define fin(name)  freopen(name,"r",stdin)
#define fout(name) freopen(name,"w",stdout)
#define clr(arr,val) memset(arr,val,sizeof(arr))
#define _for(i,start,end) for(int i=start;i<=end;i++)  
#define FAST_IO ios::sync_with_stdio(false);cin.tie(0);
using namespace std;
typedef long long LL;
const int N=50+5;
const int INF=0x3f3f3f3f;
const double eps=1e-10;

int n,m,cnt;
int path[N*N],vis[N][N];
int d[4][2]={0,1,1,0,0,-1,-1,0};
char mp[N][N];
vector<int>v[N*N];

bool judge(int x,int y){
    if(x>=1&&y>=1&&x<=n&&y<=m&&!vis[x][y])
        return true;
    return false;
}

void dfs(int x,int y){
    vis[x][y]=cnt;
    for(int i=0;i<4;i++){
        int xx=x+d[i][0];
        int yy=y+d[i][1];
        if(judge(xx,yy)&&mp[x][y]==mp[xx][yy]){
            dfs(xx,yy);
        }            
    }
}

int bfs(int st){
    memset(path,-1,sizeof(path));
    queue<int>q;
    q.push(st);
    path[st]=0;
    while(!q.empty()){
        int k=q.front();
        q.pop();
        for(int i=0;i<v[k].size();i++){
            int t=v[k][i];
            if(path[t]==-1){
                path[t]=path[k]+1;
                q.push(t);
            }
        }
    }
}

int main(){
    FAST_IO;
    int t;
    cin>>t;
    while(t--){
        memset(vis,0,sizeof(vis));
        cin>>n>>m;
        for(int i=1;i<=n*m;i++) v[i].clear();
        for(int i=1;i<=n;i++){
            cin>>mp[i]+1;
        }
        cnt=0;
        //找连通块,缩点 
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                if(!vis[i][j]){
                    ++cnt;
                    dfs(i,j);
                }
            }
        }
        //连通块间建边 
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                for(int k=0;k<4;k++){
                    int xx=i+d[k][0];
                    int yy=j+d[k][1];
                    if(vis[xx][yy]!=vis[i][j]){
                        int t1=vis[i][j],t2=vis[xx][yy];
                        v[t1].push_back(t2);
                    }
                }
            }
        }
        //枚举每个连通块为起点,每次找出最大路径,找出这些最大路径中的最小值 
        int ans=INF;
        for(int i=1;i<=cnt;i++){
            bfs(i);
            int mmax=-INF;
            for(int j=1;j<=cnt;j++){
                mmax=max(mmax,path[j]);
            }
            ans=min(ans,mmax);
        }
        cout<<ans<<endl;
    }
    return 0;
}