HDU-3338 Kakuro Extension

題目鏈接：Kakuro Extension

題目大意：黑色方塊中左下角的數字代表這個方塊以下的的白色方塊的和必須達到的值，黑色方塊中右上角的數字代表這個方塊以右的白色方塊的和必須達到的值。

解題思路：由於行和列的限制，很容易想到網絡流。將源點和所有右上角有值的方塊相連，將匯點和所有左下角有值的方塊相連，權值爲當前值減去右（下）方白色方塊的個數；將數字所作用範圍的白色方塊與黑色方塊相連，權值爲8。由於每個白色方塊都必須要有值，所以在最後的輸出全部加1即可。

代碼如下：

#include <map>
#include <set>
#include <cmath>
#include <queue>
#include <stack>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int inf  = 0x3f3f3f3f;
const int maxn = 3e4 + 15;
const int maxm = 1e6 + 15;

struct Edge {
    int to, cap, next;
};

int ecnt, st, ed, m, n;
Edge es[maxm];
int cur[maxn], dep[maxn], head[maxn]; 

class Dinic {
public:
    void init(){
        memset(head, -1, sizeof head);
        ecnt = 0;
    }

    void add_edge(int u, int v, int cap) {
        es[ecnt].to = v;
        es[ecnt].next = head[u];
        es[ecnt].cap = cap;
        head[u] = ecnt++;
    }

    void add_double(int u, int v, int w1, int w2 = 0) {
        add_edge(u, v, w1);
        add_edge(v, u, w2);
    }

    bool BFS() {
        queue<int> q; q.push(st);
        memset(dep, 0x3f, sizeof dep); dep[st] = 0;
        while(q.size() && dep[ed] == inf) {
            int u = q.front(); q.pop();
            for(int i = head[u]; ~i; i = es[i].next) {
                Edge& e = es[i];
                if(e.cap > 0 && dep[e.to] == inf) {
                    dep[e.to] = dep[u] + 1;
                    q.push(e.to);
                }
            }
        }
        return dep[ed] < inf;
    }

    int DFS(int u, int maxflow) {
        if(u == ed) return maxflow;
        int res = 0;
        for(int i = cur[u]; ~i; i = es[i].next) {
            Edge& e = es[i];
            if(dep[e.to] == dep[u] + 1 && e.cap > 0) {
                int flow = DFS(e.to, min(maxflow, e.cap));  
                cur[u] = i; 
                res += flow; maxflow -= flow;
                es[i].cap -= flow; 
                es[i ^ 1].cap += flow;
                if(!maxflow) return res;
            }
        }       
        dep[u] = inf;
        return res;
    }

    int MaxFlow(){
        int ans = 0;    
        while(BFS()) {   
            for(int i = st; i <= ed; i++) cur[i] = head[i];
            ans += DFS(st, inf);
        }
        return ans;
    }
};

inline int read() {
    char c = getchar();
    while(!isdigit(c)) c = getchar();
    int x = 0;
    while(isdigit(c)) {
        x = x * 10 + c - '0';
        c = getchar();
    }
    return x;
}

int Map[105][105], row[105][105], col[105][105], ans[105][105];

int main(){
#ifdef NEKO
    freopen("Nya.txt", "r", stdin);
#endif
    ios::sync_with_stdio(false);  cin.tie(0);
    Dinic dic;
    while(cin >> n >> m) {
        string s; dic.init();
        memset(Map, -1, sizeof Map);
        for(int i = 1; i <= n; i++) {
            for(int j = 1; j <= m; j++) {
                cin >> s; 
                if(s[0] == '.') {
                    Map[i][j] = 1;
                    continue;   
                }
                else if(s[0] != 'X' && s[4] == 'X') {
                    Map[i][j] = 2;
                    int w = (s[0] - '0') * 100 + (s[1] - '0') * 10 + (s[2] - '0');  
                    col[i][j] = w;
                }
                else if(s[4] != 'X' && s[0] == 'X') {
                    Map[i][j] = 3;
                    int w = (s[4] - '0') * 100 + (s[5] - '0') * 10 + (s[6] - '0');
                    row[i][j] = w;  
                }
                else if(s[0] != 'X' && s[4] != 'X') {
                    Map[i][j] = 4;  
                    int w = (s[0] - '0') * 100 + (s[1] - '0') * 10 + (s[2] - '0');  
                    col[i][j] = w;
                    w = (s[4] - '0') * 100 + (s[5] - '0') * 10 + (s[6] - '0');
                    row[i][j] = w;
                }
            }
        }
        st = 0, ed = 2 * n * m + 1;
        for(int i = 1; i <= n; i++) {
            for(int j = 1; j <= m; j++) {
                int index = (i - 1) * m + j;
                if(Map[i][j] == 3 || Map[i][j] == 4) {
                    int cnt = 1;
                    while(1) {
                        if(Map[i][j + cnt] != 1) { cnt--; break; }
                        cnt++;
                    }
                    dic.add_double(st, index, row[i][j] - cnt);
                    for(int k = 1; k <= cnt; k++) {
                        dic.add_double(index, index + k, 8);                        
                    }
                    j += cnt;   
                }
            }
        }

        for(int j = 1; j <= m; j++) {
            for(int i = 1; i <= n; i++) {
                int index = (i - 1) * m + j;
                if(Map[i][j] == 2 || Map[i][j] == 4) {
                    int cnt = 1;
                    while(1) {
                        if(Map[i + cnt][j] != 1) { cnt--; break; }
                        cnt++;
                    }
                    dic.add_double(index + n * m, ed, col[i][j] - cnt);
                    for(int k = 1; k <= cnt; k++)
                        dic.add_double((i - 1 + k) * m + j, index + n * m, 8);
                    i += cnt;   
                }
            }
        }       
        dic.MaxFlow();
        for(int i = head[st]; ~i; i = es[i].next) {
            int u = es[i].to, v, l, r, res;
            for(int j = head[u]; ~j; j = es[j].next) {
                l = es[j ^ 1].cap, v = es[j].to;    
                if(v == st || v == ed) continue;
                res = l;
                int y = v % m; 
                int x = (v - y) / m + 1;
                if(!y) {
                    y = m;
                    x--;    
                }
                ans[x][y] = res + 1;
            }
        }

        for(int i = 1; i <= n; i++) {
            for(int j = 1; j <= m; j++) {
                if(Map[i][j] != 1) cout << (j == m ? "_\n" : "_ ");
                else cout << ans[i][j] << (j == m ? '\n' : ' ');
            }
        }
    }
    return 0;
}