HDU 4888 Redraw Beautiful Drawings (2014-多校3-1002，最大流，判最大流有多解)

题目：

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

题意：

给一个n*m的矩阵的n行之和和m列之和以及限制k，使用0-k的数字填充矩阵使得其行与列之和为给定值

如果不行则输出Impossible

如果有多解则输出Not Unique

如果有一解则输出Unique，并输出构造的矩阵

方法：

最大流，判最大流有多解

1、建图：

每一行一个点，每一列一个点

源点与第i个行点连边，权值为第i行之和

第j个列点与汇点连边，权值为第j行之和

第i个行点与第j个列点连边，权值为k

2、跑最大流

3、如果源点与n个行点都流满且m个列点与汇点都流满，则有解，否则无解

4、判最大流有多解：

如果有多解，则某两点流量可以为(f1,f2)，(f1-f,f2+f)，所以可以根据这个结论判最大流是否有多解：

在残余网络中，如果存在大小大于2的环，则可以出现上述情况，即：有多解

bool dfsc(int u, int fa)
{
    vis[u] = 1;
    for (int i = head[u]; ~i; i = edge[i].next)
    {
        int v = edge[i].v;
        if (v == fa || edge[i].flow == edge[i].cap) continue;
        if (vis[v] || dfsc(v, u)) return 1;
    }
    vis[u] = 0;
    return 0;
}
bool check()
{
    memset(vis, 0, sizeof(vis));
    for (int i = 2; i < N + 2; i++)
    {
        if (!vis[i])
        {
            vis[i] = 1;
            if (dfsc(i, i)) return 0;
            vis[i] = 0;
        }
    }
    return 1;
}

5、构造矩阵：

第i个行点与第j个列点的流量即为(i,j)的值

代码：

// #pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <iostream>
#include <cstring>
#include <string>
#include <cmath>
#include <set>
#include <list>
#include <map>
#include <iterator>
#include <cstdlib>
#include <vector>
#include <queue>
#include <stack>
#include <algorithm>
#include <functional>
using namespace std;
typedef long long LL;
#define ROUND(x) round(x)
#define FLOOR(x) floor(x)
#define CEIL(x) ceil(x)
// const int maxn = 0;
// const int maxm = 0;
// const int inf = 0x3f3f3f3f;
const LL inf64 = 0x3f3f3f3f3f3f3f3fLL;
const double INF = 1e30;
const double eps = 1e-6;
const int P[4] = {0, 0, -1, 1};
const int Q[4] = {1, -1, 0, 0};
const int PP[8] = { -1, -1, -1, 0, 0, 1, 1, 1};
const int QQ[8] = { -1, 0, 1, -1, 1, -1, 0, 1};

/**
*最大流最小割：加各种优化的Dinic算法($O(V^2E)$)
*输入：图(链式前向星),n(顶点个数,包含源汇),st(源),ed(汇)
*输出：Dinic(NdFlow)(最大流),MinCut()(最小割)(需先求最大流)
*打印路径方法：按反向边(i&1)的flow 找，或者按边的flow找
*/
const int maxn = 810;
const int maxm = 400010;
const int inf = 0x3f3f3f3f;
struct Edge
{
    int u, v;
    int cap, flow;
    int next;
} edge[maxm];
int head[maxn], en; //需初始化
int n, m, d[maxn], cur[maxn];
int st, ed;
bool vis[maxn];
void addse(int u, int v, int cap, int flow)
{
    edge[en].u = u;
    edge[en].v = v;
    edge[en].cap = cap;
    edge[en].flow = flow;
    edge[en].next = head[u];
    head[u] = en++;
    cur[u] = head[u];
}
void adde(int u, int v, int cap)
{
    addse(u, v, cap, 0);
    addse(v, u, 0, 0); //注意加反向0边
}
bool BFS()
{
    queue<int> Q;
    memset(vis, 0, sizeof(vis));
    Q.push(st);
    d[st] = 0;
    vis[st] = 1;
    while (!Q.empty())
    {
        int u = Q.front();
        Q.pop();
        for (int i = head[u]; i != -1; i = edge[i].next)
        {
            int v = edge[i].v;
            int w = edge[i].cap - edge[i].flow;
            if (w > 0 && !vis[v])
            {
                vis[v] = 1;
                Q.push(v);
                d[v] = d[u] + 1;
                if (v == ed) return 1;
            }
        }
    }
    return false;
}
int Aug(int u, int a)
{
    if (u == ed) return a;
    int aug = 0, delta;
    for (int &i = cur[u]; i != -1; i = edge[i].next)
    {
        int v = edge[i].v;
        int w = edge[i].cap - edge[i].flow;
        if (w > 0 && d[v] == d[u] + 1)
        {
            delta = Aug(v, min(a, w));
            if (delta)
            {
                edge[i].flow += delta;
                edge[i ^ 1].flow -= delta;
                aug += delta;
                if (!(a -= delta)) break;
            }
        }
    }
    if (!aug) d[u] = -1;
    return aug;
}
int Dinic(int NdFlow)
{
    int flow = 0;
    while (BFS())
    {
        memcpy(cur, head, sizeof(int) * (n + 1));
        flow += Aug(st, inf);
        /*如果超过指定流量就return 掉*/
        if (NdFlow == inf) continue;
        if (flow > NdFlow) break;
    }
    return flow;
}
/*残余网络*/
void Reduce()
{
    for (int i = 0; i < en; i++) edge[i].cap -= edge[i].flow;
}
/*清空流量*/
void ClearFlow()
{
    for (int i = 0; i < en; i++) edge[i].flow = 0;
}
/*求最小割*/
vector<int> MinCut()
{
    BFS();
    vector<int> ans;
    for (int u = 0; u < n; u++)
    {
        if (!vis[u]) continue;
        for (int i = head[u]; i != -1; i = edge[i].next)
        {
            if (i & 1) continue; /*忽略反向边*/
            int v = edge[i].v;
            int w = edge[i].cap;
            if (!vis[v] && w > 0) ans.push_back(i);
        }
    }
    return ans;
}

int N, M, K;
int a[maxn], b[maxn];
int mtx[410][410];
void init()
{
    memset(head, -1, sizeof(head));
    en = 0;
}
void input()
{
    for (int i = 0; i < N; i++)
        scanf("%d", &a[i]);
    for (int i = 0; i < M; i++)
        scanf("%d", &b[i]);
}
void debug()
{
    //
}
void build()
{
    st = 0, ed = 1;
    n = N + M + 2;
    for (int i = 0; i < N; i++)
    {
        adde(st, i + 2, a[i]);
    }
    for (int i = 0; i < M; i++)
    {
        adde(i + N + 2, ed, b[i]);
    }
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < M; j++)
        {
            adde(i + 2, j + N + 2, K);
        }
    }
}
bool dfsc(int u, int fa)
{
    vis[u] = 1;
    for (int i = head[u]; ~i; i = edge[i].next)
    {
        int v = edge[i].v;
        if (v == fa || edge[i].flow == edge[i].cap) continue;
        if (vis[v] || dfsc(v, u)) return 1;
    }
    vis[u] = 0;
    return 0;
}
bool check()
{
    memset(vis, 0, sizeof(vis));
    for (int i = 2; i < N + 2; i++)
    {
        if (!vis[i])
        {
            vis[i] = 1;
            if (dfsc(i, i)) return 0;
            vis[i] = 0;
        }
    }
    return 1;
}
void solve()
{
    build();
    Dinic(inf);
    // cout << "flow: " << Dinic(inf) << endl;
    int flag = 1;
    for (int i = head[st]; ~i; i = edge[i].next)
    {
        if (i & 1) continue;
        if (edge[i].cap > edge[i].flow)
        {
            flag = 0;
            break;
        }
    }
    for (int i = head[ed]; ~i; i = edge[i].next)
    {
        if (i & 0) continue;
        if (-edge[i].flow < edge[i ^ 1].flow)
        {
            flag = 0;
            break;
        }
    }
    if (!flag)
    {
        puts("Impossible");
        return;
    }
    if (!check())
    {
        puts("Not Unique");
        return;
    }
    for (int u = 0; u < N; u++)
    {
        for (int i = head[u + 2]; ~i; i = edge[i].next)
        {
            if (i & 1) continue;
            int v = edge[i].v - N - 2;
            mtx[u][v] = edge[i].flow;
        }
    }
    puts("Unique");
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < M; j++)
        {
            if (j < M - 1) printf("%d ", mtx[i][j]);
            else printf("%d
", mtx[i][j]);
        }
    }
}
void output()
{
    //
}
int main()
{
    // int size = 256 << 20; // 256MB
    // char *p = (char *)malloc(size) + size;
    // __asm__("movl %0, %%esp
" :: "r"(p));

    // std::ios_base::sync_with_stdio(false);
#ifndef ONLINE_JUDGE
    freopen("in.cpp", "r", stdin);
#endif

    while (~scanf("%d%d%d", &N, &M, &K))
    {
        init();
        input();
        solve();
        output();
    }
    return 0;
}