HDU 3338：Kakuro Extension（脑洞大开的网络流）

http://acm.hdu.edu.cn/showproblem.php?pid=3338

题意：在一个n*m的地图里面，有黑方块和白方块，黑方块可能是“XXXXXXX”或者“YYY/YYY”，这里的YYY代表可能为数字，如果是在“/”左边出现数字，代表在它下面的该列的白方块的和加起来要等于这个数字，如果是在“/”右边出现数字，代表它右边的该行的白方块的和加起来要等于这个数字。我们要做的就是求出这些白方块上的数字，并按照要求输出。

思路：看完题意一脸懵逼，想了一个下午还是不知道怎么写。无奈只能看下别人的做法。

因为所有的有行数字的黑方块加起来的和等于所有的有列数字的黑方块加起来的和，所以可以把列看作是源点，把行看作是汇点，然后把有关系的白块和他们连接起来，添加一个超级源点S和列的黑方块相连，添加一个超级汇点T和行的黑方块相连，这样就可以建出图了。至于边的容量，因为是带上下限的网络流（下限是1，上限是9），为了变成没有下限的网络流，所以看作容量上下限为（0-8），这样，所以我选择对白块拆点，两点之间的容量是8，然后列的黑方块和第一个点相连，第二个点和行的黑方块相连，容量都设为INF。超级源点S与列的黑方块的容量和行的黑方块与超级汇点T的容量分别为其方块上的值减去它们对应的白方块数（因为白方块的容量-1了）。最后得到的白方块的拆点的边的容量，答案再+1就转化回来了。还有记得数组要开大点。。一开始忘了开大点T了1次。

网络流真是神奇啊！

 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <queue>
 using namespace std;
 #define N 200005
 #define M 1000005
 #define INF 0x3f3f3f3f
 struct Edge {
     int u, v, nxt, cap;
     Edge () {}
     Edge (int u, int v, int nxt, int cap) : u(u), v(v), nxt(nxt), cap(cap) {}
 } edge[M];
 struct node {
     int id, cid, rid, cval, rval, type;
 } mp[][];
 int head[N], tot, cur[N], pre[N], gap[N], dis[N], S, T, cnt[N];

 void Add(int u, int v, int cap) {
     edge[tot] = Edge(u, v, head[u], cap); head[u] = tot++;
     edge[tot] = Edge(v, u, head[v], ); head[v] = tot++;
 }

 void BFS() {
     queue<int> que;
     memset(dis, INF, sizeof(dis));
     memset(gap, , sizeof(gap));
     dis[T] = ; que.push(T);
     while(!que.empty()) {
         int u = que.front(); que.pop();
         for(int i = head[u]; ~i; i = edge[i].nxt) {
             int v = edge[i].v;
             if(dis[v] == INF) {
                 dis[v] = dis[u] + ;
                 gap[dis[v]]++;
                 que.push(v);
             }
         }
     }
 }

 int ISAP(int n) {
     BFS();
     memcpy(cur, head, sizeof(cur));
     int u = pre[S] = S, ans = , i, flow, index;
     while(dis[S] < n) {
         if(u == T) {
             flow = INF;
             for(i = S; i != T; i = edge[cur[i]].v)
                 if(flow > edge[cur[i]].cap) flow = edge[cur[i]].cap, index = i;
             for(i = S; i != T; i = edge[cur[i]].v)
                 edge[cur[i]].cap -= flow, edge[cur[i]^].cap += flow;
             u = index; ans += flow;
         }
         for(i = cur[u]; ~i; i = edge[i].nxt) if(dis[edge[i].v] == dis[u] -  && edge[i].cap > ) break;
         if(~i) {
             pre[edge[i].v] = u; cur[u] = i; u = edge[i].v;
         } else {
             int md = n + ;
             if(--gap[dis[u]] == ) break;
             for(i = head[u]; ~i; i = edge[i].nxt)
                 if(dis[edge[i].v] < md && edge[i].cap > ) md = dis[edge[i].v], cur[u] = i;
             gap[dis[u] = md + ]++;
             u = pre[u];
         }
     }
     return ans;
 }

 int main() {
     int n, m;
     while(~scanf("%d%d", &n, &m)) {
         char s[]; tot = ; int rowcnt = , colcnt = , white = ;
         memset(head, -, sizeof(head));
         memset(cnt, , sizeof(cnt));
         memset(mp, , sizeof(mp));
         for(int i = ; i <= n; i++) {
             for(int j = ; j <= m; j++) {
                 scanf("%s", s); int flag = , num = ;
                 if(strcmp(s, "XXXXXXX") == ) continue;
                 if(strcmp(s, ".......") == ) { mp[i][j].type = ; white++; mp[i][j].id = white; continue; }
                 for(int k = ; k < ; k++)
                     if(s[k] == 'X') { flag = ; break; }
                     else num = num *  + s[k] - '';
                 if(!flag) { mp[i][j].cval = num; colcnt++; mp[i][j].cid = colcnt;}
                 flag = , num = ;
                 for(int k = ; k < ; k++)
                     if(s[k] == 'X') { flag = ; break; }
                     else num = num *  + s[k] - '';
                 if(!flag) { mp[i][j].rval = num; rowcnt++; mp[i][j].rid = rowcnt;}
                 mp[i][j].type = ;
             }
         }
         S = ; T = white *  + rowcnt + colcnt + ;
         for(int i = ; i <= n; i++) {
             for(int j = ; j <= m; j++) {
                 if(mp[i][j].type == ) {
                     if(mp[i][j].cval > ) { // 如果黑块上列有数字
                         int now = mp[i][j].cid;
                         for(int k = i + ; k <= n; k++) { // 搜这一列上白块
                             if(mp[k][j].type == ) {
                                 Add(now + white * , mp[k][j].id, INF);
                                 mp[i][j].cval--; // 对应的列有白块,这个列容量-1
                             } else break; // 不是白块就退出
                         }
                         Add(S, now + white * , mp[i][j].cval);
                     }
                     if(mp[i][j].rval > ) { // 如果黑块上行有数字
                         int now = mp[i][j].rid;
                         for(int k = j + ; k <= m; k++) { // 搜这一行的白块
                             if(mp[i][k].type == ) {
                                 Add(mp[i][k].id + white, now + colcnt + white * , INF);
                                 mp[i][j].rval--; // 对应的行容量-1
                             } else break;
                         }
                         Add(now + colcnt + white * , T, mp[i][j].rval);
                     }
                 } else if(mp[i][j].type == ) Add(mp[i][j].id, mp[i][j].id + white, ); // 白块拆点
             }
         }
         int ans = ISAP(T + );
         for(int u = ; u <= white; u++) {
             for(int i = head[u]; ~i; i = edge[i].nxt) { // 暴力搜拆点的边
                 if(edge[i].v == u + white) {
                     cnt[u] =  - edge[i].cap; // 这条边的流量为 初始cap - 当前cap
                 }
             }
         }
         for(int i = ; i <= n; i++) {
             for(int j = ; j <= m; j++) {
                 if(mp[i][j].type == ) printf("%d", cnt[mp[i][j].id] + );
                 else putchar('_');
                 if(j != m) putchar(' ');
                 else putchar('\n');
             }
         }
     }
     return ;
 }