HDU 4975 A simple Gaussian elimination problem.

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

题意：同HDU 4888。给N行M列，每行之和，每列之和，判断矩阵是不是唯一。

题解：网络流。源点和每行之和建边，容量为和；汇点和没列之和建边，容量为和；行之和和列之和建边，容量为9（每位只能是0~9）。

　　　　判断可行性：行之和的和是否等于列之和的和；是否满流。

　　　　判断唯一解：残留网络里是否有长度大于等于2的环

#include <cstdio>
#include <cstring>
#include <iostream>
#include <cstdlib>
#include <string>
#include <algorithm>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <cmath>
#include <ctime>
#include <functional>
#include <cctype>

using namespace std;

typedef __int64 ll;

const int INF=0xfffffff;

const int maxm=500*500*10+10;
const int maxn=510+510;

struct edge{
    int to,cap,next;
    edge(int to=0,int cap=0,int next=0):to(to),cap(cap),next(next){}
}G[maxm];
int head[maxn],level[maxn];
bool used[maxn];
int g[maxn][maxn];
int sumr,sumc;
int N,M;
int flag;
int idx;
int s,t;

void add_edge(int from,int to,int cap)
{
    G[++idx]=edge(to,cap,head[from]);
    head[from]=idx;
    G[++idx]=edge(from,0,head[to]);
    head[to]=idx;
}

bool bfs(int S,int T)
{
    memset(level,0xff,sizeof(level));
    level[S]=0;
    queue<int> q;
    q.push(S);
    while(!q.empty())
    {
        int v=q.front();
        q.pop();
        for(int k=head[v];k!=-1;k=G[k].next)
        {
            edge &e=G[k];
            if(level[e.to]==-1&&e.cap){
                level[e.to]=level[v]+1;
                q.push(e.to);
            }
        }
    }
    return level[T]!=-1;
}

int dfs(int v,int f,int T)
{
    if(v==T||f==0) return f;
    int flow=0;
    for(int k=head[v];k!=-1;k=G[k].next)
    {
        edge &e=G[k];
        if(level[e.to]==level[v]+1){
            int d;
            if((d=dfs(e.to,min(f,e.cap),T))>0){
                G[k].cap-=d;
                G[k^1].cap+=d;
                flow+=d;
                f-=d;
                if(f==0) return flow;
            }
        }
    }
    level[v]=-1;
    return flow;
}

int max_flow(int s,int t)
{
    int flow=0;
    int f;
    while(bfs(s,t)==1)
    {
        while((f=dfs(s,INF,t))>0)
        {
            flow+=f;
        }
    }
    return flow;
}

int dfs_loop(int u,int rev)
{
    for(int &k=head[u];k!=-1;k=G[k].next)
    {
        if(k==(rev^1)) continue;
        if(G[k].cap){
            if(used[G[k].to]) return 1;
            used[G[k].to]=true;
            if(dfs_loop(G[k].to,k)==1) return 1;
            used[G[k].to]=false;
        }
    }
    return 0;
}

int judge()
{
    for(int i=1;i<=N;i++)
    {
        if(dfs_loop(i,-1)) return 0;
    }
    return 1;
}

void init()
{
    idx=-1;
    memset(head,0xff,sizeof(head));
    memset(used,0,sizeof(used));
    sumr=0;
    sumc=0;
    flag=0;
}

int main() {
    int T;
    scanf("%d",&T);
    for(int ca=1;ca<=T;ca++)
    {
        init();
        printf("Case #%d: ",ca);
        scanf("%d%d",&N,&M);
        s=0;
        t=N+M+1;
        int cr;
        for(int i=1;i<=N;i++)
        {
            scanf("%d",&cr);
            sumr+=cr;
            add_edge(s,i,cr);
            for(int j=1;j<=M;j++)
            {
                add_edge(i,N+j,9);
            }
        }
        int cc;
        for(int i=1;i<=M;i++)
        {
            scanf("%d",&cc);
            sumc+=cc;
            add_edge(N+i,t,cc);
        }
        int maxflow=max_flow(s,t);
        if(sumr!=sumc) puts("So naive!");
        else if(sumr!=maxflow) puts("So naive!");
        else if(!judge()) puts("So young!");
        else puts("So simple!");
    }
    return 0;
}