工程中的网络流

赵程同学问我个他项目中的问题让我突然觉得搞的算法还是蛮有用的，题目的这样的。求一个01矩阵，满足每行的1数和每列1数为给定值。

思路是：先按行填好1，然后移动来满足列的要求。移动时要保证每个点只能移动的一个位置，一个位置只能接受一个移动。网络流建6层节点来满足这些约束要求

第一层原点到第二层列表示 该列要流出多少1

第二层列 到 第三层 表示列可以流到的行，位置为1才可以流出（每列都对应所有的行 有n*m节点），这层保证每个点只能流出一次

第三层 到 第四层表示 行可以流到的节点，节点为0才可以流入

四层 到 五层表示 节点可以到的列

五层 到 流层汇点表示 列需要流入1的个数

#include <iostream>   
#include <string>   
#include <cstring>   
#include <algorithm>   
#include <cstdio>   
#include <cctype>   
#include <queue>   
#include <stdlib.h>   
#include <cstdlib>   
#include <math.h>   
#include <set>   
#include <vector>   
#define inf 100000000   
#define eps 1e-8 
#define MX 130
#define N 130*130*3
#define M 130*130*130*2
#define ll int
using namespace std;  
inline ll Max(ll a,ll b){return a>b?a:b;}  
inline ll Min(ll a,ll b){return a<b?a:b;}  
//M为边数 N为点数 点标从1-n   

struct Edge{  
    int from,to,flow,cap, nex;
    void show(){
        printf("[%d %d %d %d]", from, to, cap, flow);
    } 
}edge[M*2];//双向边，注意RE的情况 注意这个模版是 相同起末点的边 合并流量
int head[N],edgenum;//2个要初始化-1和0   
void addEdge(int u,int v,int cap){//网络流要加反向弧   
    Edge E={u,v,0,cap,head[u]};  
    edge[edgenum]=E;  
    head[u]=edgenum++;  
    Edge E2={v,u,0,0,head[v]}; //这里的cap若是单向边要为0   
    edge[edgenum]=E2;  
    head[v]=edgenum++;  
}  


int dis[N],cur[N];//距离起点的距离 cur[i]表示i点正在考虑的边 优化不再考虑已经用过的点 初始化为head   
bool vis[N];  
bool BFS(int Start,int End){  
    memset(vis,0,sizeof(vis));   
    memset(dis,-1,sizeof(dis));  
    queue<int>Q;  while(!Q.empty())Q.pop();  
    Q.push(Start);  dis[Start]=0;   vis[Start]=1;  
    while(!Q.empty())  
    {  
        int u = Q.front(); Q.pop();  
        for(int i=head[u];i!=-1;i=edge[i].nex){  
            Edge E =edge[i];  
            if(!vis[E.to] && E.cap>E.flow)  
            {  
                vis[E.to]=1;  
                dis[E.to]=dis[u]+1;  
                if(E.to==End)return true;  
                Q.push(E.to);  
            }  
        }  
    }  
    return false;  
}  
int DFS(int x, int a,int End){//流入x 的流量是a   
    if(x==End || a==0)return a;  
    int flow = 0, f;  
    for(int& i=cur[x];i!=-1;i=edge[i].nex)  
    {  
        Edge& E = edge[i];  
        if(dis[x]+1 == dis[E.to] && (f = DFS(E.to , Min(a, E.cap-E.flow), End))>0 )  
        {  
            E.flow += f;  
            edge[ i^1 ].flow -= f;//反向边要减掉   
            flow += f;  
            a -= f;  
            if(a==0)break;  
        }  
    }  
    return flow;  
}  
int Maxflow(int Start,int End){  
    int flow=0;   
    while(BFS(Start,End)){  
        memcpy(cur,head,sizeof(head));//把head的数组复制过去   
        flow += DFS(Start, inf, End);  
    }  
    return flow;  
}  
void init(){
    memset(head, -1, sizeof(head)); edgenum = 0;
}

int n, m;
int p[MX][MX];
int a[MX], b[MX], c[MX];
int s, e;

void showGraph(){
    for(int i=s; i<=e; ++i) {
        printf("node %d:", i);
        for(int j=head[i]; j!=-1; j=edge[j].nex) {
            edge[j].show();
        }
        printf("\n");
    }
    return ;
}
void showMatrix(){
    for(int i=0; i<n; i++){
        int first = 1;
        for(int j=0; j<m; ++j) {
            if(first) {
                printf("%d", p[i][j]);
                first = 0;
            }else{
                printf(" %d", p[i][j]);
            }
        }
        printf("\n");
    }
}
int main(int argc, char* argv[]) {
    while(scanf("%d%d", &n, &m) != EOF) {
        for(int i=0; i<n; ++i){
            scanf("%d", &a[i]);
        }
        for(int i=0; i<m; ++i) {
            scanf("%d", &b[i]);
        }
        memset(p, 0, sizeof(p));
        memset(c, 0, sizeof(c));
        init();
        for(int i=0; i<n; ++i) {
            for(int j=0; j<a[i]; ++j) {
                p[i][j] = 1;
                ++c[j];
            }
        }
//        showMatrix();
        s = 0, e = m+m*n+m*n+m+1;
        int needFlow = 0;
        for(int i=0; i<m; ++i) {
            if( c[i] > b[i]) {
                addEdge(s, i+1, c[i]-b[i]);
                needFlow += c[i]-b[i];
            }else if(c[i] < b[i]){
                addEdge(1+m+m*n+m*n+i, e, b[i]-c[i]);
            }
        }
        for(int k=0; k<m; ++k) {
            for(int i=0; i<n; i++){
                if(p[i][k] == 1)
                    addEdge(k+1, m+1+k*n+i, 1);
            }
        }
        int startEdgeNum = edgenum;
        for(int i=0; i<n; ++i){
            for(int j=0; j<m; ++j) {
                if(p[i][j] == 0) {
                    for(int k=0; k<m; k++) {
                        addEdge(m+1+k*n+i, m+1+m*n+i*m+j, 1);
                    }
                }
            }
        }
        int endEdgeNum = edgenum;
        for(int i=0; i<n; ++i){
            for(int j=0; j<m; ++j) {
                addEdge(m+1+m*n+i*m+j, m+1+m*n+m*n+j, 1);
            }
        }
//        showGraph();
        int f = Maxflow(s, e);
        printf("%d %d\n", f, needFlow);
        //showGraph();
        if(f != needFlow) {
            printf("IMPOSSIBLE!!\n");
        }else{
            for(int i=startEdgeNum; i!=endEdgeNum; i+=2) {
                if( edge[i].flow == 1) {
//                    edge[i].show();
                    int y = (edge[i].from-(m+1)) / n;
                    int x = (edge[i].from-(m+1))% n;
                    int xx = (edge[i].to-(m+1+n*m)) / m;
                    int yy = (edge[i].to-(m+1+n*m)) % m;
//                    printf("[from%d %d to %d %d]\n", x, y, xx, yy);
                    p[x][y] = 0;
                    p[xx][yy] = 1;
                }
            }
            showMatrix();
        }
    }
    return 0;
}