HDU 4975 A simple Gaussian elimination problem

HDU 4975 A simple Gaussian elimination problem

网络流，残余网络判环

题意

有一个矩阵，给你它的每行的行和以及每列的列和，矩阵中每个元素值0~9。问你能否还原这个矩阵？输出无解/唯一解/多解。

思路

网络流。矩阵建图模型。个人感觉与这题有些像。

读入时如果发现非法，比如行和超过9*列数，比如所有行和与所有列和不相等，直接gg。每行用一个点表示，每列用一个点表示。源连边到每行，权是行和。每列连边到汇，权值是列和。行列点之间连边，权值是9，表示最大值9。

然后跑网络流，如果流不等于行和，那么无解。

下面判断多解还是唯一解。方法是在残余网络上找环，如果有一个包含了2个以上(等价于至少4个)的环，那么我们可以调整这个残量网络，得到矩阵的另一个解。

具体来说需要重新建图，每条边如果有余量，那么加入新图。在新图中dfs找环。每次dfs时记录当前的father，如果找到回father的边，那么这个环是包含两点的环，不计。要是还找到环了，就有多解。

不过注意，因为原图是二分图，新图也必然是二分图。所以dfs时只dfs一半就可以了。否则会T的，时间卡的紧。另外注意，MAXN要开二倍，因为行列都要存进去。

代码

#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <vector>
#include <cmath>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <iomanip>
#define _ ios_base::sync_with_stdio(0),cin.tie(0)
#define M(a,b) memset(a,b,sizeof(a))
#define N n
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1

using namespace std;

const int MAXN=1007;
const int oo=0x3f3f3f3f;
typedef long long LL;
const LL loo=4223372036854775807ll;
typedef long double LB;
const LL mod=1e9+7;
const double eps=1e-6;
int hang[MAXN], lie[MAXN];
struct Dinic
{
    struct Edge
    {
        int from, to, cap, flow;//cap容量 flow流量
        Edge() {}
        Edge(int u, int v, int c, int f) { from=u;to=v;cap=c;flow=f; }
    };
    vector<Edge> edges;//顺序的插入边
    vector<int> G[MAXN];//保存边号
    bool vis[MAXN];//BFS使用
    int d[MAXN];
    int cur[MAXN];
    void init(int n=MAXN)
    {
        memset(d, 0, sizeof(d));
        for(int i=0;i<n;i++) G[i].clear();
        edges.clear();
    }

    void AddEdge(int from, int to, int cap)
    {
        edges.push_back(Edge(from, to, cap, 0));
        edges.push_back(Edge(to, from, 0, 0));//单向边第三个参数写0，双向边写cap
        int t_m=edges.size();
        G[from].push_back(t_m-2);
        G[to].push_back(t_m-1);
    }

    bool BFS(int s, int t)
    {
        memset(vis, 0, sizeof(vis));
        queue<int> Q;
        Q.push(s);
        d[s]=0;
        vis[s]=1;
        while(!Q.empty())
        {
            int x=Q.front();Q.pop();
            for(int i=0;i<G[x].size();i++)
            {
                Edge& e=edges[G[x][i]];
                if(!vis[e.to]&&e.cap>e.flow)//残量网络
                {
                    vis[e.to]=1;
                    d[e.to]=d[x]+1;
                    Q.push(e.to);
                }
            }
        }
        return vis[t];
    }
    int DFS(int x, int a, int s, int t)
    {
        if(x==t||a==0) return a;
        int flow=0, _f;
        for(int& i=cur[x];i<G[x].size();i++)
        {
            Edge& e=edges[G[x][i]];
            if(d[x]+1==d[e.to]&&(_f=DFS(e.to, min(a, e.cap-e.flow), s, t))>0)
            {
                e.flow+=_f;
                edges[G[x][i]^1].flow-=_f;
                flow+=_f;
                a-=_f;
                if(a==0) break;
            }
        }
        return flow;
    }
    int Maxflow(int s, int t)
    {
        int flow=0;
        while(BFS(s, t))
        {
            memset(cur, 0, sizeof(cur));
            flow+=DFS(s, oo, s, t);
        }
        return flow;
    }
}dinic;

vector<int> G[MAXN];
void init()
{
    M(hang, 0), M(lie, 0);
    dinic.init();
    for(int i=0;i<MAXN;i++)
        G[i].clear();
}
bool vis[MAXN];
int dfs(int now, int fa)
{
    vis[now]=1;
    for(int i=0;i<G[now].size();i++)
    {
        if(G[now][i]==fa) continue;
        if(vis[G[now][i]]) return 1;
        else if(dfs(G[now][i], now)) return 1;
    }
    vis[now]=0;
    return 0;
}
bool check(int n)
{
    M(vis, 0);
    for(int i=1;i<=n;i++)
        if(dfs(i, -1))
            return 1;

    return 0;
}
int main()
{
    int T;scanf("%d", &T);
    for(int t=1;t<=T;t++)
    {
        init();
        int m, n;scanf("%d%d", &n, &m);
        int hsum=0, lsum=0, fl=0;
        for(int i=1;i<=n;i++)
        {
            scanf("%d", &hang[i]);
            if(hang[i]>9*m) fl=1;
            hsum+=hang[i];
        }
        for(int i=1;i<=m;i++)
        {
            scanf("%d", &lie[i]);
            if(lie[i]>9*n) fl=1;
            lsum+=lie[i];
        }
        if(hsum!=lsum) fl=1;
        printf("Case #%d: ", t);
        if(fl) printf("So naive!\n");
        else
        {
            const int sup_s=0, sup_t=n+m+1;
            for(int i=1;i<=n;i++)
                dinic.AddEdge(sup_s, i, hang[i]);
            for(int i=1;i<=m;i++)
                dinic.AddEdge(i+n, sup_t, lie[i]);
            for(int i=1;i<=n;i++)
                for(int j=n+1;j<=n+m;j++)
                    dinic.AddEdge(i, j, 9);
            int ans=dinic.Maxflow(sup_s, sup_t);
            if(ans!=hsum) printf("So naive!\n");
            else
            {
                for(int i=0;i<dinic.edges.size();i++)
                {
                    if(dinic.edges[i].cap-dinic.edges[i].flow>0)
                    {
                        G[dinic.edges[i].from].push_back(dinic.edges[i].to);
                    }
                }
                if(check(n)) printf("So young!\n");
                else printf("So simple!\n");
            }
        }

    }
    return 0;
}