HDU 3338 Kakuro Extension 网络流

题意：给一个$N*N$的矩阵，白色的格子要求填数（范围1~9）,要求：如果有出现如028\XXX（称为上边的情况）,则表示，我这个格子下面所有的白格子中的数字之和要等于这个。如果有出现XXX\028（称为左边的情况）,则表示，我这个格子右边所有的白格子中的数字之和要等于这个。

思路：神奇的网络流。白格子需要拆为入点和出点，来控制经过白格子的流量。源点与每个左边的情况连一条流量为左边情况数字的边，每个左边的情况与他右边的白格子的入点连一条流量为$INF$边。每个上边的点与汇点连一条流量为上边数字的边，他下边的所有白格子出点与上边的情况，连一条流量为$INF$的边。每个白格子的入点和出点连一条流量为8的边。（因为流量可以为0，所以所有的流量都减去1，用0~8来表示1~9，注意的是，上边情况和左边情况的数值都要减去它所连的边的数量，最后输出结果时统一+1）

坑点：细节很多，调试起来有点烦。

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

/*********************************************
    Problem : HDU 3338
    Author  : NMfloat
    InkTime (c) NM . All Rights Reserved .
********************************************/

#include <map>
#include <set>
#include <queue>
#include <cmath>
#include <ctime>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>

#define rep(i,a,b)  for(int i = a ; i <= b ; i ++)
#define rrep(i,a,b) for(int i = b ; i >= a ; i --)
#define repE(p,u) for(Edge * p = G[u].first ; p ; p = p -> next)
#define cls(a,x)   memset(a,x,sizeof(a))
#define eps 1e-8

using namespace std;

const int MOD = 1e9+7;

typedef long long LL;

int T,n,m,k;

const int MAXN = 100010;  
const int MAXE = 400010;  
const int INF = 0x3f3f3f3f;  

struct Edge{  
    int to,next,cap,flow;  
}edge[MAXE];  

int tol;  
int head[MAXN];  
int gap[MAXN],dep[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){  
    //printf("%d->%d\t",u,v);
    edge[tol].to = v;edge[tol].cap = w;edge[tol].next = head[u];  
    edge[tol].flow = 0;head[u] = tol ++;  
    edge[tol].to = u;edge[tol].cap = rw;edge[tol].next = head[v];  
    edge[tol].flow = 0;head[v] = tol ++;  
}  

int sap(int start,int end,int N){  
    memset(gap,0,sizeof(gap));  
    memset(dep,0,sizeof(dep));  
    memcpy(cur,head,sizeof(head));  
    int u = start;  
    pre[u] = -1;  
    gap[0] = N;  
    int ans = 0;  
    while(dep[start] < N){  
        if(u == end){  
            int Min = INF;  
            for(int i= pre[u];i!=-1;i=pre[edge[i^1].to]){  
                if(Min > edge[i].cap - edge[i].flow)  
                    Min = edge[i].cap - edge[i].flow;  
            }  
            for(int i= pre[u];i!=-1;i=pre[edge[i^1].to]){  
                edge[i].flow += Min;  
                edge[i^1].flow -= Min;  
            }  
            u = start;  
            ans += Min;  
            continue;  
        }  
        bool flag = false;  
        int v;  
        for(int i=cur[u];i != -1;i = edge[i].next){  
            v = edge[i].to;  
            if(edge[i].cap - edge[i].flow && dep[v] + 1 == dep[u]){  
                flag = true;  
                cur[u] = pre[v] = i;  
                break;  
            }  
        }  
        if(flag){  
            u = v;  
            continue;  
        }  
        int Min = N;  
        for(int i = head[u];i != -1;i=edge[i].next){  
            if(edge[i].cap-edge[i].flow && dep[edge[i].to] < Min){  
                Min = dep[edge[i].to];  
                cur[u] = i;  
            }  
        }  
        gap[dep[u]]--;  
        if(!gap[dep[u]]) return ans;  
        dep[u] = Min + 1;  
        gap[dep[u]] ++;  
        if(u != start) u = edge[pre[u]^1].to;  
    }  
    return ans;  
}  

int Map[105][105][2];//0代表左，1代表上。
int Mat[105][105][2];//0是入点，1是出点。左0，上1。
int Ans[105][105];
int idx ;

void outMap() {
    rep(i,1,n) { rep(j,1,m) printf("%d %d\t",Map[i][j][0],Map[i][j][1]); puts("");}
}

void outMat() {
    rep(i,1,n) { rep(j,1,m) printf("%d %d\t",Mat[i][j][0],Mat[i][j][1]); puts("");}
}

int get_num(char s1,char s2,char s3,int flag,int x,int y) {
    flag = 1 - flag;
    if(s1 == 'X') Map[x][y][flag] = -1;
    else if(s1 == '.') { Map[x][y][flag] = 0;Mat[x][y][flag] = idx ++;}
    else { Map[x][y][flag] = (s1-'0')*100+(s2-'0')*10+(s3-'0');Mat[x][y][flag] = idx++;}
}

void input() {
    char tmp_c[10];
    idx = 1;
    cls(Mat,0);
    rep(i,1,n) rep(j,1,m) {
        scanf("%s",tmp_c);
        get_num(tmp_c[0],tmp_c[1],tmp_c[2],0,i,j);
        get_num(tmp_c[4],tmp_c[5],tmp_c[6],1,i,j);
    }
}

bool dvis[MAXN];

void dfs(int u) {
    int v;
    for(int i = head[u] ; i != -1 ; i = edge[i].next) {
        v = edge[i].to;
        if(!dvis[v]) {
            dvis[v] = 1;
            printf("%d->%d\t",u,v);
            dfs(v);
        }
    }
}

void solve() {
    //建边
    //outMap();puts("");
    //outMat();puts("");
    int start = 0 , end = idx ,totnum = idx + 1;
    int tmp;
    rep(i,1,n) rep(j,1,m) {
        if(Map[i][j][0] > 0) { //左
            tmp = 0;
            rep(k,j+1,m) {
                if(Map[i][k][0] == 0) {
                    tmp ++;
                    //printf("%d %d\n",Mat[i][j][0],Mat[i][k][0]);
                    addedge(Mat[i][j][0],Mat[i][k][0],INF);
                }
                else break;
            }
            addedge(start,Mat[i][j][0],Map[i][j][0]-tmp);

        }
        if(Map[i][j][1] > 0) { //上
            tmp = 0;
            rep(k,i+1,n) {
                if(Map[k][j][1] == 0) {
                    tmp ++;
                    addedge(Mat[k][j][1],Mat[i][j][1],INF);
                }
                else break;
            } 
            addedge(Mat[i][j][1],end,Map[i][j][1]-tmp);
        }
        if(Map[i][j][0] == 0) { //...
            addedge(Mat[i][j][0],Mat[i][j][1],8);
        }
    }

    sap(start,end,totnum);
    // cls(dvis,0);
    // dvis[0] = 1;
    // dfs(0);

    cls(Ans,-1);
    rep(i,1,n) rep(j,1,m) {
        if(Map[i][j][0] == 0) {
            //printf("%d->%d ",Mat[i][j][0],edge[head[Mat[i][j][0]]].to);
            Ans[i][j] = edge[head[Mat[i][j][0]]].flow;
        }
    }
    rep(i,1,n) rep(j,1,m) {
            if(Ans[i][j] == -1) printf("_");
            else printf("%d",Ans[i][j]+1);
            if(j == m) puts("");
            else printf(" ");
        }
}

int main(void) {
    //freopen("a.in","r",stdin);
    //scanf("%d",&T);
    //while(T--) {
    while(~scanf("%d %d",&n,&m)) {
        init();
        input();
        solve();
    }
    return 0;
}