HDU

题意：给一个方格，每行每列都有对白色格子中的数之和的要求。每个格子中的数范围在[1,9]中。现在给出了这些要求，求满足条件的解。
分析：本题读入和建图比较恶心...
用网络流求解。建立源点S和汇点T，设列之和的点为A，行之和的点为B，白色格点为C。
由{A}向{C}建边，因为每个白色格点的容量不超过9且不能为0，所以在建边的时候统一减去1，最后输出解的时候再+1，则其余的弧也要相应地减去对应的白色点个数；
由{C}向{B}建边，容量为8；
由S向{A}建边，容量为 |A的列和要求 - 其下方白色点的个数|；
由{B}向T建边，容量为 |B的行和要求 - 其右方白色点的个数|。

但，这样做可能会出现某个黑色点既对列和有要求，又对行和有要求，这样建图后，这个点和源点和汇点都连接，跑出来的结果有问题。所以，将这类点拆成两个点，一个作为列之和的要求与源点相连，另一个与汇点相连。
跑出最大流后，残余网上对应弧的流量+1即为所求的解。

#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MAXN=100010;//点数的最大值
const int MAXM=400010;//边数的最大值
#define captype int
struct EDGE{
    int to,next;
    captype cap;
};
struct SAP_MaxFlow{
    EDGE edg[MAXM];
    int eid,head[MAXN];
    int gap[MAXN];  
    int dis[MAXN];  
    int cur[MAXN];  
    int pre[MAXN];
    
    void init(){
        eid=0;
        memset(head,-1,sizeof(head));
    }
    void AddEdge(int u,int v,captype c,captype rc=0){
        edg[eid].to=v; edg[eid].next=head[u];
        edg[eid].cap=c;  head[u]=eid++;
        edg[eid].to=u; edg[eid].next=head[v];
        edg[eid].cap=rc; head[v]=eid++;
    }
    captype maxFlow_sap(int sNode,int eNode, int n){//n是包括源点和汇点的总点个数，这个一定要注意
        memset(gap,0,sizeof(gap));
        memset(dis,0,sizeof(dis));
        memcpy(cur,head,sizeof(head));
        pre[sNode] = -1;
        gap[0]=n;
        captype ans=0;  
        int u=sNode;
        while(dis[sNode]<n){   
            if(u==eNode){  
                captype Min=INF ;
                int inser;
                for(int i=pre[u]; i!=-1; i=pre[edg[i^1].to])    
                if(Min>edg[i].cap){
                    Min=edg[i].cap;
                    inser=i;
                }
                for(int i=pre[u]; i!=-1; i=pre[edg[i^1].to]){
                    edg[i].cap-=Min;
                    edg[i^1].cap+=Min;  
                }
                ans+=Min;
                u=edg[inser^1].to;
                continue;
            }
            bool flag = false; 
            int v;
            for(int i=cur[u]; i!=-1; i=edg[i].next){
                v=edg[i].to;
                if(edg[i].cap>0 && dis[u]==dis[v]+1){
                    flag=true;
                    cur[u]=pre[v]=i;
                    break;
                }
            }
            if(flag){
                u=v;
                continue;
            }
            int Mind= n;
            for(int i=head[u]; i!=-1; i=edg[i].next)
            if(edg[i].cap>0 && Mind>dis[edg[i].to]){
                Mind=dis[edg[i].to];
                cur[u]=i;
            }
            gap[dis[u]]--;
            if(gap[dis[u]]==0) return ans;  
            dis[u]=Mind+1;
            gap[dis[u]]++;
            if(u!=sNode) u=edg[pre[u]^1].to;  //退一条边
        }
        return ans;
    }
}F;



pair<int,int> G[105][105];
char str[20];
int N,M,s,t;
int res[105][105];

void debug(){
    for(int i=1;i<=N;++i){
        for(int j=1;j<=M;++j){
            cout<<G[i][j].first<<"/"<<G[i][j].second<<" ";
        }
        cout<<endl;
    }
}

void down(int x,int y)
{
    int u = (x-1)*M+y;
    int j = y;
    int cnt = 0;
    for(int i=x+1;i<=N;++i){
        if(G[i][j].first!=-1) break;
        int v = (i-1)*M+j;
        F.AddEdge(u,v,8);
        cnt++;
    }
    F.AddEdge(s,u,G[x][y].first-cnt);
}

void right(int x,int y)
{
    int v = (x-1)*M+y;
    int i = x;
    int cnt = 0;
    for(int j = y+1;j<=M;++j){
        if(G[i][j].first!=-1) break;
        int u = (i-1)*M+j;
        F.AddEdge(u,v,8);
        cnt++;
    }
    F.AddEdge(v,t,G[x][y].second-cnt);
}

void downAndRight(int x,int y)
{
    int u = (x-1)*M+y;
    int j = y;
    int cnt = 0;
    for(int i=x+1;i<=N;++i){
        if(G[i][j].first!=-1) break;
        int v = (i-1)*M+j;
        F.AddEdge(u,v,8);
        cnt++;
    }
    F.AddEdge(s,u,G[x][y].first-cnt);

    int v = (x-1)*M+y+M*N;              //这种点需要拆点
    int i = x;
    cnt = 0;
    for(int j = y+1;j<=M;++j){
        if(G[i][j].first!=-1) break;
        int u = (i-1)*M+j;
        F.AddEdge(u,v,8);
        cnt++;
    }
    F.AddEdge(v,t,G[x][y].second-cnt);
}

vector<pair<int,int> > col,row,both;

int main()
{
    #ifndef ONLINE_JUDGE
        freopen("in.txt","r",stdin);
        freopen("out.txt","w",stdout);
    #endif
    while(scanf("%d %d",&N, &M)==2){
        F.init();
        col.clear();
        row.clear();
        both.clear();
        for(int i=1;i<=N;++i){
            for(int j=1;j<=M;++j){
                scanf("%s",str);
                if(str[0]=='X') G[i][j].first = -2;
                else if(str[0]=='.') G[i][j].first = -1;
                else{
                    G[i][j].first = (str[0]-'0')*100+ (str[1]-'0')*10 + (str[2]-'0');
                }
                if(str[4]=='X') G[i][j].second = -2;
                else if(str[4]=='.') G[i][j].second = -1;
                else{
                    G[i][j].second = (str[4]-'0')*100 +(str[5]-'0')*10 + (str[6]-'0');
                }
                if(G[i][j].first>0 && G[i][j].second>0){
                    both.push_back(make_pair(i,j));
                }
                else if(G[i][j].first>0){
                    col.push_back(make_pair(i,j)); 
                }
                else if(G[i][j].second>0){
                    row.push_back(make_pair(i,j)); 
                }
            }
        }
        //debug();
        memset(res,0,sizeof(res));
        s= 0 ,t = N*M*2+2;
        for(auto & v:col){
            down(v.first,v.second);
        }
        for(auto & v:row){
            right(v.first,v.second);
        }
        for(auto &v:both){
            downAndRight(v.first,v.second);
        }
        int flow = F.maxFlow_sap(s,t,t+1);
        //cout<<flow<<endl;
        for(int i= F.head[s];~i;i=F.edg[i].next){
            int u = F.edg[i].to;
            //cout<<u<<endl;
            for(int j= F.head[u];~j;j=F.edg[j].next){
                EDGE & e =F.edg[j];
                int v = e.to;
                if(v==s) continue;
                int x = (v-1)/M+1;
                int y = v%M; if(y==0) y = M;
                //cout<<e.flow+1<<" ";
                //cout<<v<<" "<<x<<" "<<y<<endl;
                res[x][y] = 9-e.cap;
            }
            //cout<<endl;
        }

        for(int i=1;i<=N;++i){
            for(int j=1;j<=M;++j){
                if(G[i][j].first!=-1) printf("_");
                else printf("%d",res[i][j]);
                if(j==M) printf("
");
                else printf(" ");
            }
        }
    }
    return 0;
}