UVA11082 Matrix Decompressing 最大流

Problem I
Matrix Decompressing
Input: Standard Input

Output: Standard Output

 

Some RxC matrix of positive integers is encoded and represented by its R cumulative row sum and C column sum entries. Given, R, C and those R+C cumulative row sum and column sums, you want to decode the matrix (i.e., find all the individual R*C entries).

 

Here,

 

Or in other words, the i-th row sum is the sum of all the entries in row i. And the cumulative i-th row sum is the sum of all the row sums from row 1 to row i (inclusive).

 

Input

There can be multiple test cases. The first line of input contains the number of test cases, T (1 ≤T ≤ 100). Each test case contains 3 lines of input. The first line of the test case gives the size of the matrix: the number of rows, R (1 ≤ R ≤ 20) and the number of columns C (1 ≤ C ≤20). The next line contains all the R cumulative row sums, and the last line of the test case contains the C cumulative column sums. Any two successive numbers in the same line is separated by a single space.

 

Output

For each test case print the label of the test case in the first line. The format of this label should be “Matrix x” where x would be replaced by the serial number of the test case starting at 1. In each of the following R lines print C integers giving all the individual entries of the matrix. You can assume that there is at least one solution for each of the given encodings. To simplify the problem further, we add the constraint that each entry in the matrix must be an integer between 1 and 20. In case of multiple solutions, you can output any one of them.

 

Sample Input                             Output for Sample Input

2 3 4 10 31 58 10 20 37 58 3 4 10 31 58 10 20 37 58

Matrix 1 1 6 1 2 1 2 2 16 8 2 14 3   Matrix 2 1 1 1 7 1 1 7 12 8 8 9 2

---

Problemsetter: Monirul Hasan

Special Thanks: Sadrul Habib Chowdhury

题意：对于一个R行C列的正整数矩阵，(1<=R,C<=20),设a[i]为前i行所有元素之和，b[i]为前i列所有元素之和，已知道R，C，和数组a，b，找一个满足条件的矩阵，矩阵中的元素必须是1~20之间的正整数，输入保证有解。

这道题建图就花了一个钟头。

开始的思路：

根据a,b数组求出每一行的元素之和a，每一列的元素之和b

建一个源点s=0，汇点t=R+C+1

然后每一行看成一个顶点1~R,每一列看成一个顶点R+1~R+C

矩阵中每一个位置看成是一条边，比如2行3列的点，就是连接第2行和第3列的点的边。

然后从s到每一行建一条边，容量为a[i],

从每一列到t建一条边，容量为b[i]

然后每一行的点向每一列的点建边，容量为20(暂且说是20，继续看下去，20是错的，19才是对的)

这样的图的意义：

整个矩阵的和代表总的流量

从s出发，分别流向R行(所以有a[1]+...+a[R]=总流量)

每一行的流量会分给该行的C个元素，每一个列的顶点会从R行获得总的流量，就是该列的流量，最后流到t的总流量还是s出发的流量。

所以行的顶点和列的顶点的R*C条边流过的流量就代表矩阵中R*C个位置的值。

因为题目要求矩阵的位置的值在1~20之间，

所以R*C条边的流量应该在1~20之间，所以R*C条边的最大流量即容量就是20.

但是这样是不对的，如果一条边没有流量经过，则流量为0，代表对应的点的值为0，但是题目要求>=1

那么我们就要保证这R*C条边都有流量经过，并且最大流量<=20

怎么保证呢？

由于a[i]=C个值的和,则a[i]>=C

那我们可以先把C的流量分给这C条边，这样就保证了每条边的流量至少为1

剩余的流量a[i]-C再根据最大流找增广路的过程进行分配。

那么每一条边的容量为20，已经有1的流量经过了，现在的容量是19了。

所以在建R*C条边的时候，前面说是20，是不对的，应该是19

最后矩阵每一位置的值+=1

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>

using namespace std;

const int maxn=23;
const int inf=0x3f3f3f3f;

int R,C;
int a[maxn];
int b[maxn];
int aa[maxn];
int bb[maxn];
int s,t;
int level[50];
int id[50];
int cost[maxn][maxn];

int ans[maxn][maxn];

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

vector<Edge>edge[500];

void addedge(int from,int to,int cap)
{
    edge[from].push_back((Edge){to,cap,edge[to].size()});
    edge[to].push_back((Edge){from,0,edge[from].size()-1});
}

void bfs()
{
    memset(level,-1,sizeof(level));
    queue<int>que;
    while(!que.empty())
        que.pop();
    que.push(s);
    level[s]=0;
    while(!que.empty())
    {
        int u=que.front();
        que.pop();
        for(int i=0;i<edge[u].size();i++)
        {
            Edge &e=edge[u][i];
            if(e.cap>0&&level[e.to]<0)
            {
                level[e.to]=level[u]+1;
                que.push(e.to);
            }
        }
    }
}

int dfs(int u,int f)
{
    if(u==t)
        return f;
    for(int &i=id[u];i<edge[u].size();i++)
    {
        Edge &e=edge[u][i];
        if(e.cap>0&&level[e.to]>level[u])
        {
            int d=dfs(e.to,min(f,e.cap));
            if(d>0)
            {
                e.cap-=d;
                edge[e.to][e.rev].cap+=d;
                return d;
            }
        }
    }
    return 0;
}

void solve()
{
    while(true)
    {
        bfs();
        if(level[t]<0)
            break;
        int flow;
        memset(id,0,sizeof(id));
        while(flow=dfs(s,inf)>0)
        {
            ;
        }
    }

    for(int i=1;i<=R;i++)
    {
        for(int j=1;j<=C;j++)
        {
            ans[i][j]=19-edge[i][cost[i][j]].cap+1;
        }
    }
    return ;
}


int main()
{
    int cas=1;
    int test;
    scanf("%d",&test);
    while(test--)
    {
        if(cas>1)
            printf("
");
        printf("Matrix %d
",cas++);

        scanf("%d%d",&R,&C);
        for(int i=1;i<=R;i++)
            scanf("%d",&aa[i]);
        for(int i=1;i<=C;i++)
            scanf("%d",&bb[i]);
        aa[0]=bb[0]=0;
        for(int i=1;i<=R;i++)
        {
            a[i]=aa[i]-aa[i-1];
        }
        for(int i=1;i<=C;i++)
        {
            b[i]=bb[i]-bb[i-1];
        }

        s=0;
        t=C+R+1;

        for(int i=0;i<500;i++)
            edge[i].clear();

        for(int i=1;i<=R;i++)
        {
            addedge(s,i,a[i]-C);
        }
        for(int i=1;i<=C;i++)
        {
            addedge(i+R,t,b[i]-R);
        }

        for(int i=1;i<=R;i++)
        {
            for(int j=1;j<=C;j++)
            {
                cost[i][j]=edge[i].size();
                addedge(i,j+R,19);
            }
        }

        solve();

        for(int i=1;i<=R;i++)
        {
            for(int j=1;j<C;j++)
            {
                printf("%d ",ans[i][j]);
            }
            printf("%d
",ans[i][C]);
        }
    }
    return 0;
}