【Srm590】Fox And City(fox)

最新推荐文章于 2019-09-12 21:24:33 发布

EMber _

最新推荐文章于 2019-09-12 21:24:33 发布

阅读量887

点赞数 1

分类专栏： codeforces 最小割

本文链接：https://blog.csdn.net/qq_35866453/article/details/69782240

版权

codeforces 同时被 2 个专栏收录

15 篇文章 0 订阅

订阅专栏

最小割

10 篇文章 0 订阅

订阅专栏

Description

A long time ago, 有一个国家有n 座从0 到n-1编号的城市。城市0 是首都。国家道路网络形成了一个无向连通图。换句话说：某些对城市被双向通行的道路所连接。

对于每座城市，可以从城市出发经过一系列连续的道路到达首都。（当两条道路需要在城市外相交时，相交处总是会有一座桥梁，因此城市外并没有路口。）

你会获得一个用于描述道路网络的字符矩阵linked。对于每个i 和j，当城市i 和城市j 已由一条道路直接连通时linked[i][j] 为‘Y’ ，否则为‘N’ 。

两个城市间的距离为从一个城市到达另一个城市所需通过的道路的最小数目。居住在首都以外的市民通常都对他们与首都之间的距离不爽。因此你会获得一个n 个元素的数组want。对于每个i，want[i] 是城市i 与首都之间的市民

期望距离。

福克斯· 夏尔正在负责建造新的道路。每个新道路必须双向且连接两座城市。一旦所有的新道路落成，市民们会计算他们对最终道路网络的不爽值：

对于每个i：令real[i] 为从城市i 到达首都的新距离。那么城市i 的市民增加的对国家的不爽值为(want[i]-real[i])^2。

计算并回答夏尔建造一些（可能是零）新道路之后新增不爽值之和的最小值。

Input

多组数据，读入到文件结束。

每组数据第一行，一个整数n——夏尔的国家内的城市数量。

接下来n 行，描述字符矩阵linked。第i 行第j 列的字符为linked[i][j]。

字符矩阵之后还有单独一行的n 个整数，为期望距离数组want。

Output

对于每组数据，输出单独一行一个整数——夏尔的最优方案中新道路都落成之后市民们新增的不爽值的最小值。

Sample Input

NYN

YNY

NYN

0 1 1

NYNN

YNYN

NYNY

NNYN

0 3 3 3

NYNNNY

YNYNNN

NYNYNN

NNYNYN

NNNYNY

YNNNYN

0 2 2 2 2 2

NYY

YNN

0 0 0

NYNNNN

YNYNNN

NYNYYY

NNYNYY

NNYYNY

NNYYYN

0 1 2 3 0 3

NYNNNN

YNYNNN

NYNYYY

NNYNYY

NNYYNY

NNYYYN

0 1 2 4 0 4

NYNYYYYYYYY

YNYNNYYNYYY

NYNNNYYNYYN

YNNNYYYYYYY

YNNYNYYYNYY

YYYYYNNYYNY

YYYYYNNNYYY

YNNYYYNNNYY

YYYYNYYNNNY

YYYYYNYYNNY

YYNYYYYYYYN

0 1 2 0 0 5 1 3 0 2 3

Sample Output

【样例解释】

第一组数据：夏尔可以建造一条连接城市0 和城市2 的道路。然后有real[1] = 1; real[2] = 1，并且总不爽值为零。

第二组数据：最优方案是不建造新道路。然后总不爽值将会为(3-1)^2+(3-2)^2+ (3-3)^2 = 5。

第三组数据：最优方案中的一种是，在城市1 和城市3 之间建造一条新道路。

Data Constraint

对于30% 的数据，能够新增的不同的道路的数量不超过16 条，数据组数<=10。

对于100% 的数据满足：

   数据组<=15。

    2<= n <=40; 0 <=want[i] < n;want[0] = 0。

    对于所有的i 和j，有linked[i][j] = linked[j][i]

    对于所有的i，有linked[i][i] =’ N’

这题其实主要在连边，连完了跑个裸的最小割就行了。
比赛的时候感觉这题最可做，随便xjbyy一下连边姿势说不定就过了呢，结果立下天大的flag，两次推倒重连，还有一些小修小改。。结果比赛刚结束我才调完。。真是有毒。

怠惰的我选择直接贴题解=w=
令 distance[i]为给出的无向图中节点 i 到节点 0 的最短路的长度。显然有：
1，distance[0]=0。
2，对于任意一条无向边(i,j)，有|distance[i]-distance[j]|<=1。
3，对于任意一节点点 i(i≠0)，至少存在一个节点 j 使得 distance[i]=distance[j]+1。
不难发现，这三条是 distance 合法的充分必要条件。根据这一点，可以发现，一个
distance 数组只要满足以下三个条件，就可以以在原图的基础上条件若干条无向边得到：
1，有且仅有一个节点 0 的 distance 值为 0。
2，对于原图的任意一条无向边(i,j)，有|distance[i]-distance[j]|<=1。
3，对于任意整数 1≤d≤max(distance[i])，存在至少一个节点 i 使得 distance[i]=d。
这三个条件的必要性显然，下面证明它们的充分性。根据 distance，可以按照如下过程
构造出无向图。
从节点 0 开始，令 distance[0]=0。然后令 p 从 1 到 max(distance[i])，对于每个
distance[i]=p-1 的节点 i，向任意一个满足 distance[j]=p-1 的节点 j 连一条无向边。最后将原
图的边加入。这个构造法的正确性显然，不做证明。
更进一步，可以发现，只要满足三个条件的前两个条件，就必然满足第三个条件（过程
见原题解）。因此一个合法的 distance 序列只要满足以下两个条件：
1，有且仅有一个节点 0 的 distance 值为 0。
2，对于原图的任意一条无向边(i,j)，有|distance[i]-distance[j]|<=1。
在满足两个条件的序列中，找到∑(distance[i]-want[i])^2 最小的序列即为所求。
求这个序列，可以使用最小割算法。
建立源点S，汇点T。将原图中每个节点i拆成n个点，point(i,k)(0≤k≤n-1)，令节点point(i,k)
表示 distance[i]<=k。若最小割中，节点 point(i,k)在 S 集中，代表 distance[i]<=k 为 false，
否则为 true。构图方法如下：
1，从 S 向 point(i,0)(1≤i≤n-1)连一条容量为正无穷的边。除节点 0 外的所有节点权值均
不可能为 0。
2，从每个 point(i,n-1)(0≤i≤n-1)向 T 连一条容量为正无穷的边。任意节点的 distance 值
均不超过 n-1。
3，从 point(i,k)向 point(i,k+1)一条容量为((k+1)-want[i])^2(若 i=0,这条边的容量为正无
穷)。可以用这条边容量的代价将 point(i,k)和 point(i,k+1)分到两个不同的集合。
4，显然，若 point(i,k)为 false，point(i,k-1)必然也为 false，因此从每个 point(i,k)向
point(i,k-1)连一条权值为正无穷的边。
5，对于原图中的每条边(i,j)，因为|distance[i]-distance[j]|为 0。所以若 point(i,k)为 false，
必然有 point(j,k-1)为 false。所以从每个 point(i,k)向 point(j,k-1)连一条容量为正无穷的边，
从每个 point(j,k)向 point(i,k-1)连一条容量为正无穷的边。
最后求出最小割即为答案。
这样构图的点数是 O(n^2)，边数为 O(n^3)。如果使用 dinic 求最小割，时间复杂度为
O(n^7)，但实际上远达不到这样的复杂度，因此可以通过本题。
【时空复杂度】
时间复杂度：O(n^7)
空间复杂度：O(n^3)

code(后来去topcoder上交了一发所以比较丑，见谅。。)：

#include "bits/stdc++.h"
#define LL long long
using namespace std;

const int N = 30000;
const int M = 500000;
const int INF = 1e9;

int n,E,S,T,head[N],to[M],nxt[M],flow[M],MX[N];

class Network_Flow{
    int cur[N],dis[N];
    queue<int> que;
public:
    inline int MaxFlow() {
        int ret = 0;
        while (BFS()) {
            memcpy(cur, head, sizeof(head));
            ret += DFS(S, INF);
        }
        return ret;
    }
private:
    inline bool BFS() {
        memset(dis,60,sizeof(dis));
        que.push(S); dis[S] = 0;

        while (!que.empty()) {
            int w = que.front(); que.pop();
            for (int i=head[w];i;i=nxt[i]) {
                if (dis[to[i]] > INF && flow[i]) {
                    dis[to[i]] = dis[w] + 1;
                    que.push(to[i]);
                }
            }
        }
        return dis[T] < INF;
    }
    int DFS(int w, int f) {
        if (w == T) return f;
        else {
            int ret = 0;
            for (int tmp,&i=cur[w];i;i=nxt[i]) {
                if (dis[to[i]] == dis[w] + 1 && flow[i]) {
                    tmp = DFS(to[i], min(f, flow[i]));
                    flow[i] -= tmp; flow[i^1] += tmp;
                    f -= tmp; ret += tmp;
                    if (!f) break;
                }
            }
            return ret;
        }
    }
}Dinic;

class FoxAndCity {
    int dis[100][100];
public:
    int minimalCost(vector<string> linked, vector<int> want) {
        init();
        n = want.size();
        for (int i=0;i<n;i++) {
            for (int j=0;j<n;j++) {
                if (linked[i][j] == 'Y') dis[i+1][j+1] = 1;
                else dis[i+1][j+1] =  INF;
            }
        }
        Floyd();
        for (int i=2;i<=n;i++)
            MX[i] = dis[1][i];
        init(); S = 0; T = N - 1;
        for (int i=2;i<=n;i++) {
            Add_Edge(S, id(i, 1));
            Add_Edge(id(i, MX[i]+1), T);
            for (int j=1;j<=MX[i];j++) {
                Add_Edge(id(i,j), id(i,j+1), sqr(want[i-1]-j));
                for (int k=2;k<=n;k++) {
                    if (i != k && dis[i][k] == 1 && j > 1) {
                        Add_Edge(id(i, j), id(k, j-1));
                    }
                }
            }
        }
        return Dinic.MaxFlow();
    }
private:
    inline void init() {
        E = 1;
        memset(head,0,sizeof(head));
    }
    inline int id(int x, int y) {
        return (x-1) * (n+1) + y;
    }
    inline int sqr(int w) {
        return w * w;
    }
    inline void Add_Edge(int u, int v, int f = INF) {
        to[++E] = v; nxt[E] = head[u]; head[u] = E; flow[E] = f;
        to[++E] = u; nxt[E] = head[v]; head[v] = E; flow[E] = 0;
    }
    inline void Floyd() {
        for (int k=1;k<=n;k++) {
            for (int i=1;i<=n;i++) {
                for (int j=1;j<=n;j++) {
                    dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
                }
            }
        }
    }
};
FoxAndCity ins;
int main(){
    freopen("fox.in","r",stdin);
    freopen("fox.out","w",stdout);
    int n;
    while(cin>>n){
        vector<string>linked(n);
        vector<int>want(n);
          for(int i=0;i<n;i++)cin>>linked[i];
        for(int i=0;i<n;i++)cin>>want[i];
        cout<<ins.minimalCost(linked, want)<<endl;
    }
}

EMber _

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【Srm590】Fox And City(fox)

DescriptionA long time ago, 有一个国家有n 座从0 到n-1编号的城市。城市0 是首都。国家道路网络形成了一个无向连通图。换句话说：某些对城市被双向通行的道路所连接。对于每座城市，可以从城市出发经过一系列连续的道路到达首都。（当两条道路需要在城市外相交时，相交处总是会有一座桥梁，因此城市外并没有路口。）你会获得一个用于描述道路网络的字符矩阵linked。对于每个i 和j，
复制链接

扫一扫