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=+;
 const int INF=0x3f3f3f3f;
 const double eps=1e-;

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

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

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

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

 int main(){
     FAST_IO;
     int t;
     cin>>t;
     while(t--){
         memset(vis,,sizeof(vis));
         cin>>n>>m;
         for(int i=;i<=n*m;i++) v[i].clear();
         for(int i=;i<=n;i++){
             cin>>mp[i]+;
         }
         cnt=;
         //找连通块,缩点
         for(int i=;i<=n;i++){
             for(int j=;j<=m;j++){
                 if(!vis[i][j]){
                     ++cnt;
                     dfs(i,j);
                 }
             }
         }
         //连通块间建边
         for(int i=;i<=n;i++){
             for(int j=;j<=m;j++){
                 for(int k=;k<;k++){
                     int xx=i+d[k][];
                     int yy=j+d[k][];
                     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=;i<=cnt;i++){
             bfs(i);
             int mmax=-INF;
             for(int j=;j<=cnt;j++){
                 mmax=max(mmax,path[j]);
             }
             ans=min(ans,mmax);
         }
         cout<<ans<<endl;
     }
     return ;
 }