网络流isap+判断唯一性

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int inf=0x3f3f3f3f;
const int maxn=1010;
struct edge{
    int to,cap,rev;
    edge(int a,int b,int c){to=a;cap=b;rev=c;}
};
vector<edge>G[maxn];
vector<int>G1[maxn];
int level[maxn],iter[maxn],vis[maxn],n,m;
void addedge(int from,int to,int cap){
    G[from].push_back(edge(to,cap,G[to].size()));
    G[to].push_back(edge(from,0,G[from].size()-1));
}
void add_edge(int from,int to){
    G1[from].push_back(to);
}
void bfs(int s){
    memset(level,-1,sizeof(level));
    queue<int>que;level[s]=0;
    que.push(s);
    while(!que.empty()){
        int v=que.front();que.pop();
        for(unsigned int i=0;i<G[v].size();i++){
            edge &e=G[v][i];
            if(e.cap>0&&level[e.to]<0){
                level[e.to]=level[v]+1;
                que.push(e.to);
            }
        }
    }
}
int dfs(int v,int t,int f){
    if(v==t) return f;
    for(int &i=iter[v];i<G[v].size();i++){
        edge &e=G[v][i];
        if(e.cap>0&&level[v]<level[e.to]){
            int d=dfs(e.to,t,min(f,e.cap));
            if(d>0){
                e.cap-=d;
                G[e.to][e.rev].cap+=d;
                return d;
            }
        }
    }
    return 0;
}
int max_flow(int s,int t){
    int flow=0;
    while(1){
        bfs(s);
        if(level[t]<0) return flow;
        memset(iter,0,sizeof(iter));
        int f;
        while((f=dfs(s,t,inf))>0) flow+=f;
    }
}
bool Judge_dfs(int x,int val){//从val点为据点射出到了X点
    vis[x]=1;//进入就标记
    for(unsigned int i=0;i<G1[x].size();i++){//遍历每条边
        int t=G1[x][i];//读出来
        if(t==val) continue;//VAL->X，X->T==VAL，则表示这是一对逆向边，无效
        if(vis[t]) return 1;//由上行知不是二点环或三点环，四点环含两行两列，成环有效
        if(Judge_dfs(t,x)) return 1;//不然的话就继续搜吧
    }
    vis[x]=0;//退出删标记（这样在JUDGE函数的FOR下Judge_dfs不用每次都重新MEMSET）
    return 0;
}
bool judge(){
    memset(vis,0,sizeof(vis));//现在已确定有解，只是判断是否有多解，就是有流的位置变化
    for(int i=0;i<=n+m+1;i++){//每个点扫一次
        for(unsigned int j=0;j<G[i].size();j++){//点的每边边都扫一次
            edge &e=G[i][j];//读出此边
            if(e.cap>0) add_edge(i,e.to);//如果此边的容量大于0，则建立反向边，注意这里是add_edge是对G1操作
        }
    }
    for(int i=0;i<=n;i++)//最后从每个行结点开始进行遍历，一开始的-1只是为了每一次进去搜的时候不会有点跟它相同
        if(Judge_dfs(i,-1)) return 1;//判断是否有环，有环就是有多解
    return 0;
}
int main(){
    int T,a,b,t=1;
    scanf("%d",&T);
    while(T--){
        for(int i=0;i<maxn;i++){
            G[i].clear();
            G1[i].clear();
        }
        scanf("%d%d",&n,&m);
        int sum=0,sum1=0,sum2=0;
        for(int i=1;i<=n;i++){
            scanf("%d",&a);sum+=a;sum1+=a;
            addedge(0,i,a);
        }
        for(int j=1;j<=m;j++){
            scanf("%d",&b);sum2+=b;
            addedge(j+n,n+m+1,b);
        }
        if(sum1!=sum2){
            printf("Case #%d: So naive!\n",t++);
            continue;
        }
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++)
                addedge(i,j+n,9);
        }
        int ans=max_flow(0,n+m+1);
        if(ans!=sum) printf("Case #%d: So naive!\n",t++);
        else{
            if(judge()) printf("Case #%d: So young!\n",t++);
            else printf("Case #%d: So simple!\n",t++);
        }
    }
    return 0;
}
网络流isap+判断唯一性
hdu4975
题意：给出n行，m列的和，然后每个格子只能是0~9的数，问你满足给出的数据填数的方案，无解naive，一解simple，多解young
Sample Input
3 		1 1 5 5 		2 2 0 10 0 10 		2 2 2 2 2 2
Sample Output
Case #1: So simple! Case #2: So naive! Case #3: So young!
思路：
1、	是否有解：源点与每行建一条流量为行和的边，每一列与汇点建一条流量为列和的边，每行与每列建一条流量为9的边（是行边，列边），跑最大流后判断是否满流（就是Dinic）
2、	判多组解：当残余网络中有环时，调整这个环来符合条件，将一条边加1，则另一条边可以减去1，符合有环就表示有多组解