HDU 3338 Kakuro Extension (最大流)

题意：网格图，有黑色格子和白色格子，白色格子用来填空，填的值的范围是1-9，每个黑色格子可能存在两个量，a\b，a表示向下连续白色格子的和，b表示向右连续白色格子的和，题目要求就一组任意解并且输出。

题解：最大流
我们发现，所有行和等于所有列和，那么可以从行流入，从列流出，构造最大流。

我们可以将行看作一个点，这行有多少个白格子，表示有多少条流出的边，列同理，表示流入。由此将行、列顺序编号，进行建边。

由于流量有上下限限制，可以给每个数都减掉1，则填出来的数字范围为0-8, 就可以用网络流搞定了。所以行、列之间的容量为8。

接下来考虑源点，源点只要跟所有行编号相连即可，容量为行中元素之和，由于数字范围是0-8，那么容量就得减去行中元素个数*1，在进行行编号的时候记录一下即可；列同理。

具体见代码注释。

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<algorithm>
#include<queue>
#include<stack>
#include<cmath>
#include<vector>
#include<fstream>
#include<set>
#include<map>
#include<sstream>
#include<iomanip>
#define ll long long
using namespace std;
//SAP邻接表形式 注意初始化
const int MAXN = 20010;
const int MAXM = 200010;
const int INF = 0x3f3f3f3f;
struct Node {
    int to, next, cap;
}edge[MAXM];
int tol;
int head[MAXN];
int gap[MAXN], dis[MAXN], pre[MAXN], cur[MAXN];
void init() {
    tol = 0;
    memset(head, -1, sizeof(head));
}
void addedge(int u, int v, int w, int rw = 0) {
    edge[tol].to = v; edge[tol].cap = w; edge[tol].next = head[u]; head[u] = tol++;
    edge[tol].to = u; edge[tol].cap = rw; edge[tol].next = head[v]; head[v] = tol++;
}
int sap(int start, int end, int nodenum) {
    memset(dis, 0, sizeof(dis));
    memset(gap, 0, sizeof(gap));
    memcpy(cur, head, sizeof(head));
    int u = pre[start] = start, maxflow = 0, aug = -1;
    gap[0] = nodenum;
    while (dis[start] < nodenum) {
    loop:
        for (int& i = cur[u]; i != -1; i = edge[i].next) {
            int v = edge[i].to;
            if (edge[i].cap && dis[u] == dis[v] + 1) {
                if (aug == -1 || aug > edge[i].cap)
                    aug = edge[i].cap;
                pre[v] = u;
                u = v;
                if (v == end) {
                    maxflow += aug;
                    for (u = pre[u]; v != start; v = u, u = pre[u])
                    {
                        edge[cur[u]].cap -= aug;
                        edge[cur[u] ^ 1].cap += aug;
                    }
                    aug = -1;
                }
                goto loop;
            }
        }
        int mindis = nodenum;
        for (int i = head[u]; i != -1; i = edge[i].next) {
            int v = edge[i].to;
            if (edge[i].cap && mindis > dis[v]) {
                cur[u] = i;
                mindis = dis[v];
            }
        }
        if ((--gap[dis[u]]) == 0)break;
        gap[dis[u] = mindis + 1]++;
        u = pre[u];
    }
    return maxflow;
}

char s[110][110][10];
int lx[110][110], ly[110][110], num[20010], id[110][110];
int n, m;
int main() {
    while (~scanf("%d%d", &n, &m)) {
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                scanf("%s", s[i][j]);
            }
        }
        init();
        int tot = 0;
        memset(lx, 0, sizeof(lx)); //记录元素所在行编号
        memset(ly, 0, sizeof(ly)); //记录元素所在列编号
        memset(num, 0, sizeof(num)); //记录编号行（列）含有的元素个数
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (s[i][j][0] != '.') continue;
                if (j == 0 || lx[i][j - 1] == 0) lx[i][j] = ++tot;
                else lx[i][j] = lx[i][j - 1];
                num[lx[i][j]]++;
            }
        }
        for (int j = 0; j < m; j++) {
            for (int i = 0; i < n; i++) {
                if (s[i][j][0] != '.') continue;
                if (i == 0 || ly[i - 1][j] == 0) ly[i][j] = ++tot;
                else ly[i][j] = ly[i - 1][j];
                num[ly[i][j]]++;
            }
        }
        int start = 0, end = tot + 1, nodenum = tot + 2;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (s[i][j][0] != '.') continue;
                addedge(lx[i][j], ly[i][j], 8);
                id[i][j] = tol - 2;  //记录该点编号，输出流量
            }
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (s[i][j][3] != '\\') continue;
                if (s[i][j][0] != 'X') {  //黑格下有一列
                    int tmp = (s[i][j][0] - '0') * 100 + (s[i][j][1] - '0') * 10 + s[i][j][2] - '0';
                    addedge(ly[i + 1][j], end, tmp - num[ly[i + 1][j]]);
                }
                if (s[i][j][4] != 'X') {  //黑格右有一行
                    int tmp = (s[i][j][4] - '0') * 100 + (s[i][j][5] - '0') * 10 + s[i][j][6] - '0';
                    addedge(start, lx[i][j + 1], tmp - num[lx[i][j + 1]]);
                }
            }
        }
        sap(start, end, nodenum);
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (j > 0) printf(" ");
                if (s[i][j][0] != '.') printf("_");
                else printf("%d", 9 - edge[id[i][j]].cap);
            }
            printf("\n");
        }
    }
    return 0;
}