hdu 4975 A simple Gaussian elimination problem 最大流+找环

原题链接

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

这是一道很裸的最大流，将每个点(i,j)看作是从Ri向Cj的一条容量为9的边，从源点除法连接每个Ri，再从每个Ci连接至汇点。如若最大流不是滿流，则问题无解。这道题的关键就是在于如何判断是否有多解。考虑这样一个事实，若残余网络上有多个点构成一个环，那么流量可在这个环上调整，某条边上多余的流量可以被环上的其他的边弥补回来。所以如果残余网络上存在一个边数大于2的环，那么问题则是多解。我判断是否有环的方法是Tarjan。

详见代码：

#include<iostream>
#include<stack>
#include<vector>
#include<cstring>
#include<algorithm>
#include<queue>
#define MAX_V 2015
#define MAX_N 10004
#define INF 2500005
using namespace std;

struct edge{int to,cap,rev;};

vector<edge> G[MAX_N];
int level[MAX_V];
int iter[MAX_V];

void add_edge(int from,int to,int cap) {
    G[from].push_back((edge) {to, cap, G[to].size()});
    G[to].push_back((edge) {from, , G[from].size() - });
}

void bfs(int s) {
    memset(level, -, sizeof(level));
    queue<int> que;
    level[s] = ;
    que.push(s);
    while (!que.empty()) {
        int v = que.front();
        que.pop();
        for (int i = ; i < G[v].size(); i++) {
            edge &e = G[v][i];
            if (e.cap >  && level[e.to] < ) {
                level[e.to] = level[v] + ;
                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 >  && level[v] < level[e.to]) {
            int d = dfs(e.to, t, min(f, e.cap));
            if (d > ) {
                e.cap -= d;
                G[e.to][e.rev].cap += d;
                return d;
            }
        }
    }
    return ;
}

int max_flow(int s,int t) {
    int flow = ;
    for (; ;) {
        bfs(s);
        if (level[t] < )return flow;
        memset(iter, , sizeof(iter));
        int f;
        while ((f = dfs(s, t, INF)) > ) {
            flow += f;
        }
    }
}

bool vis[MAX_N];
int low[MAX_N],dfn[MAX_N],tot=;
bool inStack[MAX_N];

stack<int> st;
bool exitCircle=false;

void Tarjan(int u) {
    if (exitCircle)return;
    vis[u] = ;
    inStack[u] = ;
    st.push(u);
    low[u] = dfn[u] = ++tot;
    for (int i = ; i < G[u].size(); i++) {
        int v = G[u][i].to;
        if (G[u][i].cap == )continue;
        if (!vis[v]) {
            Tarjan(v);
            low[u] = min(low[u], low[v]);
        }
        else if (inStack[v])
            low[u] = min(low[u], dfn[v]);
    }
    if (dfn[u] == low[u]) {
        int cnt = ;
        while (inStack[u]) {
            if (st.empty())break;
            cnt++;
            //cout << st.top() << " ";
            inStack[st.top()] = ;
            st.pop();
        }
        if (cnt > )exitCircle = true;
        //cout << endl;
    }
}

int T;
int N,M;

int main() {
    cin.sync_with_stdio(false);
    cin >> T;
    int cas = ;
    while (T--) {

        int sum = ;
        cin >> N >> M;

        for(int i=;i<N+M+;i++)G[i].clear();
        memset(vis,,sizeof(vis));
        memset(dfn,,sizeof(dfn));
        memset(low,,sizeof(low));
        tot=;
        memset(inStack,,sizeof(inStack));
        exitCircle=false;
        while(st.size())st.pop();

        for (int i = ; i < N; i++) {
            int a;
            cin >> a;
            sum += a;
            add_edge(, i + , a);
        }
        for (int i = ; i < M; i++) {
            int a;
            cin >> a;
            add_edge(N + i + , N + M + , a);
        }
        for (int i = ; i <= N; i++)
            for (int j = ; j <= M; j++)
                add_edge(i, j + N, );
        int flow = max_flow(, N + M + );

        cout << "Case #" << ++cas << ": ";
        if (flow != sum) {
            cout << "So naive!" << endl;
            continue;
        }

        for (int i = ; i <= N + M + ; i++)if (!vis[i])Tarjan(i);
        if (exitCircle)cout << "So young!" << endl;
        else cout << "So simple!" << endl;
    }

    return ;
}