bzoj3698 XWW的难题

3698: XWW的难题

Time Limit: 10 Sec  Memory Limit: 128 MB
Submit: 562  Solved: 291
[Submit][Status][Discuss]

Description

XWW是个影响力很大的人，他有很多的追随者。这些追随者都想要加入XWW教成为XWW的教徒。但是这并不容易，需要通过XWW的考核。
XWW给你出了这么一个难题：XWW给你一个N*N的正实数矩阵A，满足XWW性。
称一个N*N的矩阵满足XWW性当且仅当：（1）A[N][N]=0；（2）矩阵中每行的最后一个元素等于该行前N-1个数的和；（3）矩阵中每列的最后一个元素等于该列前N-1个数的和。
现在你要给A中的数进行取整操作（可以是上取整或者下取整），使得最后的A矩阵仍然满足XWW性。同时XWW还要求A中的元素之和尽量大。

Input

第一行一个整数N,N ≤ 100。
接下来N行每行包含N个绝对值小于等于1000的实数，最多一位小数。

Output

输出一行，即取整后A矩阵的元素之和的最大值。无解输出No。

Sample Input

4
3.1 6.8 7.3 17.2
9.6 2.4 0.7 12.7
3.6 1.2 6.5 11.3
16.3 10.4 14.5 0

Sample Output

129

HINT

【数据规模与约定】
有10组数据，n的大小分别为10,20,30...100。
【样例说明】
样例中取整后满足XWW性的和最大的矩阵为：
3 7 8 18
10 3 0 13
4 1 7 12
17 11 15 0

分析：比较神奇的建图.

　　　每个位置有两个数可选，很显然就是dp或网络流嘛，因为有行末和列末的限制，只能用网络流来做.

　　　我一开始一直在想怎么表示出每一行前n-1个数的和.网络流肯定是用流量来表示嘛. 那我怎么构图才能使得流到某个点的流量是它前面的n-1个数的和呢？ 链式结构？显然不行.

　　　一个想法是把每一行每一列都看作一个点. 从源点向每一行连边,第i行向第j列连边，每一列向汇点连边. 这样，从第i行流出的流量就是第i行前n-1个数的和，流进第j列的流量就是第j列前n-1个数的和. 实际上就是利用流量的分散和汇总来表示前n-1个数的和.

　　　那么每条边的容量是多少呢？每个点的点权实际上是不确定的，也就是说，每条边的边权会有上下界. 对于S到第i行的边，容量为[l[i][n],r[i][n]].对于第i行到第j列的边，容量为[l[i][j],r[i][j]].对于第i列到T的边，容量为[l[n][i],r[n][i]].其中l,r对应的是两种取值. 可以看出，第i行对第j列的贡献是点(i,j).

　　　跑有源汇的上下界最大流即可.

　　　这道题是行列模型中行列之间互相有影响的题型.  目前我做过的有3种方法可以处理：

　　　1.当某一维特别小的时候，可以暴力枚举出这一维的所有状态，然后对另一维进行处理（一般是贪心），例如：传送门.

　　　2.每一行或每一列的影响可以互相抵消，也就是具有“奇偶性”，可以将对答案有影响的点变到最后一行和最后一列上去,例如：传送门.

　　　3.直接考虑第i行对第j列的影响，即点(i,j). 分析得到影响是多少，再用不同的方法去求. 例如本题.

　　　行列之间不影响怎么样呢？

　　　直接分开做最后累加答案即可. 例如：ctsc2009 移民站选址

　　　技巧？把行、列压缩成一点.

#include <cstdio>
#include <cmath>
#include <queue>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int maxn = 30010,inf = 0x7fffffff;
int n,l[110][110],r[110][110],S,T,SS,TT,du[1010],sum1,sum2,pos[110][110];
int ans,s,t,sum,d[maxn],head[maxn],to[maxn],nextt[maxn],w[maxn],tot = 2;

void add(int x,int y,int z)
{
    w[tot] = z;
    to[tot] = y;
    nextt[tot] = head[x];
    head[x] = tot++;

    w[tot] = 0;
    to[tot] = x;
    nextt[tot] = head[y];
    head[y] = tot++;
}

bool bfs()
{
    memset(d,-1,sizeof(d));
    d[s] = 0;
    queue <int> q;
    q.push(s);
    while (!q.empty())
    {
        int u = q.front();
        q.pop();
        if (u == t)
            return true;
        for (int i = head[u];i;i = nextt[i])
        {
            int v = to[i];
            if (w[i] && d[v] == -1)
            {
                d[v] = d[u] + 1;
                q.push(v);
            }
        }
    }
    return false;
}

int dfs(int u,int f)
{
    if (u == t)
        return f;
    int res = 0;
    for (int i = head[u];i;i = nextt[i])
    {
        int v = to[i];
        if (w[i] && d[v] == d[u] + 1)
        {
            int temp = dfs(v,min(f - res,w[i]));
            w[i] -= temp;
            w[i ^ 1] += temp;
            res += temp;
            if (res == f)
                return res;
        }
    }
    if (!res)
        d[u] = -1;
    return res;
}

void dinic()
{
    while (bfs())
        sum += dfs(s,inf);
}

int main()
{
    scanf("%d",&n);
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
        {
            double x;
            scanf("%lf",&x);
            l[i][j] = floor(x);
            r[i][j] = ceil(x);
        }
    S = 2 * n + 1;
    T = S + 1;
    SS = T + 1;
    TT = SS + 1;
    for (int i = 1; i < n; i++)
    {
        add(S,i,r[i][n] - l[i][n]);
        du[S] -= l[i][n];
        du[i] += l[i][n];
        add(i + n,T,r[n][i] - l[n][i]);
        du[i + n] -= l[n][i];
        du[T] += l[n][i];
    }
    for (int i = 1; i < n; i++)
        for (int j = 1; j < n; j++)
        {
            add(i,j + n,r[i][j] - l[i][j]);
            pos[i][j] = tot - 1;
            du[i] -= l[i][j];
            du[j + n] += l[i][j];
        }
    for (int i = 1; i <= T; i++)
    {
        if (du[i] > 0)
            add(SS,i,du[i]),sum1 += du[i];
        if (du[i] < 0)
            add(i,TT,-du[i]),sum2 -= du[i];
    }
    add(T,S,inf);
    s = SS;
    t = TT;
    dinic();
    if (sum != sum1)
    {
        printf("NO");
        return 0;
    }
    w[tot - 1] = w[tot - 2] = 0;
    s = S;
    t = T;
    dinic();
    for (int i = 1; i < n; i++)
        for (int j = 1; j < n; j++)
            ans += w[pos[i][j]] + l[i][j];
    printf("%d\n",ans * 3);

    return 0;
}

 

 

 

转载于:https://www.cnblogs.com/zbtrs/p/8619985.html