Gym - 100203I I WIN 网络流

Gym - 100203I  I WIN

题意：一个n*m的矩阵包含W,I,N三种字符，问相邻的字符最多能组成不重叠的WIN。

思路：比赛的时候没有发现是网络流，，居然一度以为是二分图匹配，，写了一下没过就没改了，，知道了是网络流就好办了。设一个起点一个终点，起点和每个W之间连一条边，N和终点间连一条边，W和I之间连一条边，I和N之间连一条边，不过这里为了避免重复使用同一个I，应改成W到I连一条边，I连一条边到I'，再从I'连一条边到N就可以保证最优解了。求一遍最大流即可。

 #include <iostream>
 #include <cstdio>
 #include <fstream>
 #include <algorithm>
 #include <cmath>
 #include <deque>
 #include <vector>
 #include <queue>
 #include <string>
 #include <cstring>
 #include <map>
 #include <stack>
 #include <set>
 #define LL long long
 #define eps 1e-8
 #define INF 0x3f3f3f3f
 #define MAXN 1005
 using namespace std;

 struct Edge{
     int from, to, cap, flow;
     //Edge(int u, int v, int c, int f) :from(u), to(v), cap(c), flow(f){};
 };
 struct Dinic{
     int n, m, i, s, t;
     Edge e;
     vector<Edge> edges;
     vector<int> G[MAXN];
     int d[MAXN], cur[MAXN];
     bool vis[MAXN];
     void init(int n){
         this->n = n;
         for (i = ; i <= n; i++){
             G[i].clear();
         }
         edges.clear();
     }
     void AddEdge(int from, int to, int cap){
         edges.push_back(Edge{ from, to, cap,  });
         edges.push_back(Edge{ to, from, ,  });
         m = edges.size();
         G[from].push_back(m - );
         G[to].push_back(m - );
     }
     bool BFS(){
         memset(vis, , sizeof(vis));
         queue<int> Q;
         Q.push(s);
         d[s] = ;
         vis[s] = ;
         while (!Q.empty()){
             int x = Q.front();
             Q.pop();
             for (i = ; i < G[x].size(); i++){
                 Edge& e = edges[G[x][i]];
                 if (!vis[e.to] && e.cap > e.flow){
                     vis[e.to] = true;
                     d[e.to] = d[x] + ;
                     Q.push(e.to);
                 }
             }
         }
         return vis[t];
     }
     int DFS(int x, int a){
         if (x == t || a == ) return a;
         int flow = , f;
         for (int& i = cur[x]; i < G[x].size(); i++){
             Edge& e = edges[G[x][i]];
             if (d[x] +  == d[e.to] && (f = DFS(e.to, min(a, e.cap - e.flow))) > ){
                 e.flow += f;
                 edges[G[x][i] ^ ].flow -= f;
                 flow += f;
                 a -= f;
                 if (a == ) break;
             }
         }
         return flow;
     }
     int MaxFlow(int s, int t, int need){
         int flow = ;
         this->s = s;
         this->t = t;
         while (BFS()){
             memset(cur, , sizeof(cur));
             flow += DFS(s, INF);
             if (flow > need) return flow;
         }
         return flow;
     }
 };
 char a[][];
 Dinic p;
 const int step[][] = { , , , , -, , , - };
 bool vis[][];
 int main()
 {
 #ifndef ONLINE_JUDGE
     freopen("in.txt", "r", stdin);
     //freopen("out.txt", "w", stdout);
 #endif // OPEN_FILE
     int n, m;
     scanf("%d%d", &n, &m);
     for (int i = ; i <= n; i++){
         scanf("%s", a[i] + );
     }
     int s = , t =  * n * m + ;
     p.init(t);
     memset(vis, , sizeof(vis));
     for (int i = ; i <= n; i++){
         for (int j = ; j <= m; j++){
             int u = (i - ) * m + j;
             if(a[i][j] == 'W'){
                 p.AddEdge(s, u, );
                 for (int k = ; k < ; k++){
                     int x = i + step[k][];
                     int y = j + step[k][];
                     if (x <  || y <  || x > n || y > m) continue;
                     if (a[x][y] == 'I'){
                         p.AddEdge(u, (x - ) * m + y, );
                     }
                 }
             }
             else if (a[i][j] == 'I'){
                 int v = u + n * m;
                 p.AddEdge(u, v, );
                 for (int k = ; k < ; k++){
                     int x = i + step[k][];
                     int y = j + step[k][];
                     if (x <  || y <  || x > n || y > m) continue;
                     if (a[x][y] == 'N'){
                         p.AddEdge(v, (x - ) * m + y, );
                         if (vis[x][y]) continue;
                         p.AddEdge((x - ) * m + y, t, );
                         vis[x][y] = true;
                     }
                 }
             }
         }
     }
     int ans = p.MaxFlow(s, t, INF);
     printf("%d\n", ans);
 }