蛋蛋安利的双倍经验题

1143: [CTSC2008]祭祀river

Time Limit: 10 Sec Memory Limit: 162 MB

Submit: 1901 Solved: 951

[Submit][Status][Discuss]

Description

在遥远的东方，有一个神秘的民族，自称Y族。他们世代居住在水面上，奉龙王为神。每逢重大庆典， Y族都会在水面上举办盛大的祭祀活动。我们可以把Y族居住地水系看成一个由岔口和河道组成的网络。每条河道连接着两个岔口，并且水在河道内按照一个固定的方向流动。显然，水系中不会有环流（下图描述一个环流的例子）。



由于人数众多的原因，Y族的祭祀活动会在多个岔口上同时举行。出于对龙王的尊重，这些祭祀地点的选择必须非常慎重。准确地说，Y族人认为，如果水流可以从一个祭祀点流到另外一个祭祀点，那么祭祀就会失去它神圣的意义。族长希望在保持祭祀神圣性的基础上，选择尽可能多的祭祀的地点。

Input

第一行包含两个用空格隔开的整数N、M，分别表示岔口和河道的数目，岔口从1到N编号。接下来M行，每行包含两个用空格隔开的整数u、v，描述一条连接岔口u和岔口v的河道，水流方向为自u向v。

Output

第一行包含一个整数K，表示最多能选取的祭祀点的个数。

Sample Input

4 4

1 2

3 4

3 2

4 2

Sample Output

2

【样例说明】

在样例给出的水系中，不存在一种方法能够选择三个或者三个以上的祭祀点。包含两个祭祀点的测试点的方案有两种：

选择岔口1与岔口3（如样例输出第二行），选择岔口1与岔口4。

水流可以从任意岔口流至岔口2。如果在岔口2建立祭祀点，那么任意其他岔口都不能建立祭祀点

但是在最优的一种祭祀点的选取方案中我们可以建立两个祭祀点，所以岔口2不能建立祭祀点。对于其他岔口

至少存在一个最优方案选择该岔口为祭祀点，所以输出为1011。

HINT

对于每个测试点：如果你仅输出了正确的被选取的祭祀点个数，那么你将得到该测试点30%的分数；如果你仅输出了正确的被选取的祭祀点个数与一个可行的方案，那么你将得到该测试点60%的分数；如果你的输出完全正确，那么你将得到该测试点100%的分数

【数据规模】 N ≤ 100 M ≤ 1 000

Source

2718: [Violet 4]毕业旅行

Time Limit: 10 Sec Memory Limit: 128 MB

Submit: 376 Solved: 209

[Submit][Status][Discuss]

Description



Input



Output

最多可选多少景点

Sample Input

7 6

1 2

2 3

5 4

4 3

3 6

6 7

Sample Output

2

HINT



Source

Ctsc2008 River & ural 1533. Fat Hobbits

题意：

给出一个有向无环图。在其中找出一个最大的点集使得点集中任意两个点之间不可达。

思路：

最长反链；那么何为反链？ 链是一个点的集合，这个集合中任意两个元素v、u，要么v能走到u，要么u能走到v。 反链是一个点的集合，这个集合中任意两点谁也不能走到谁。

求法：

Dilworth定理：最长反链长度 = 最小链覆盖数

对于最小链覆盖数，可以利用二分图匹配来求；又应用了一个结论：最小链覆盖数=总点数-最大匹配数

实现：

Floyed传递闭包，处理连通性问题； 匈牙利算法硬上，得结果。

证明：(Dilworth定理)

首先，最长反链中的每个点，一定在不同的链中，所以得到：最长反链长度 ≤ 最小链覆盖数

下面关心的是，最长反链长度 ≥ 最小链覆盖数吗？

用数学归纳法。

首先空的图显然成立。

假设对于所有点数小于图G的图都成立，现在来证G也满足条件。

两个定义：源：没有一个点能走到它的点。（入度为0） 汇：不能走到任何一个点的点。（出度为0）

设：

这个图点集为V

这个图的最长反链为A

能走到A中某个点的点的集合为B，A中某个点能走到的点构成的集合为C。

（1）若A中至少有一个点既不是源也不是汇

则：

1. B ≠ V （否则反链的点全是汇）

2. C ≠ V （否则反链的点全是源）

3. B ∪ C = V：反证法，假设有一个点v既不属于B也不属于C，那么说明反链上任何一点不能到v，v也不能到反链上任何一个点，反链加上v之后能成为更长的反链，与假设矛盾。

4. B ∩ C = A：反证法，假设有一个点v既属于B也属于C但不属于A，那么说明反链上某点a能到v，v能到反链上某点b。若a = b，则与图是有向无环图矛盾。若a ≠ b，则a能先到v，在从v到达b，与a、b都在反链上矛盾。

设B构成的子图、C构成的子图的最小链覆盖的链的集合分别为C[B]和C[C]。因为|B| < |V|，|C| < |V|，由归纳假设，C[B]、C[C]大小分别等于B构成的子图和C构成的子图的最长反链的大小。

考虑一条链c ∈ C[B]，则c中必然存在一个在最长反链上的点v，不然最小链覆盖会大于最长反链，与归纳假设矛盾。因为B ∩ C = A，所以C[B]中v不能到任何一个点。所以v必为c的汇。

于是得到：A中的点都是C[B]中某条链的汇。

同理：A中的点都是C[C]中某条链的源。

又B ∪ C = V，B ∩ C = A，C[B]中某条链的汇必为C[C]中某条链的源，于是把C[B]和C[C]拼起来，就得到一个原图G的一种可行的链覆盖了！

考虑这个链覆盖，发现这个链覆盖大小 = 最长反链长度，得到最小链覆盖大小 ≤ 最长反链长度。又由前面的最小链覆盖大小 ≥ 最长反链长度，所以G中最小链覆盖大小 = 最长反链长度

（2）若A是所有源的集合或所有汇的集合

若A是所有源的集合，那么从A中随便取一个元素v（这个可以随便找到吧）

再从V中随便找一个汇u，使得v可以到u（这个也可以随便找到吧）（u可以等于v）

然后G中去掉v、u形成图G’。则G’的最长反链大小一定小于等于|A| - 1，不然的就可以在G中找到一条不选v、u的最长反链，利用（1）的结论可以证明正确性。

由于归纳假设，则G’中一定可以找到一个数量为|A| - 1的链覆盖。再加上{v} ∪ {u}这条链，则可以在G中找到一个数量为|A|的链覆盖，所以G的最小链覆盖 ≤ 最长反链长度。

又由前面的最小链覆盖大小 ≥ 最长反链长度，所以G中最小链覆盖大小 = 最长反链长度。

证完了，这就是传说中的Dilworth定理：最小链覆盖数 = 最长反链长度。

其对偶定理：最长链长度 = 最小反链覆盖数 就不证了，网上的证明烂大街了。

by vfk

code:

#include<iostream>

#include<cstdio>

#include<cstring>

#include<cmath>

#include<algorithm>

using namespace std;

int read()

{

    int x=0,f=1; char ch=getchar();

    while (ch<'0' || ch>'9') {if (ch=='-') f=-1; ch=getchar();}

    while (ch>='0' && ch<='9') {x=x*10+ch-'0'; ch=getchar();}

    return x*f;

}

#define maxn 210

#define maxm 1010

int n,m,ans=0;

int road[maxn][maxn],part[maxn],f[maxn];

bool used[maxn];

void floyed()

{

    for (int k=1; k<=n; k++)

        for (int i=1; i<=n; i++)

            for (int j=1; j<=n; j++)

                if (road[i][k] && road[k][j])

                    road[i][j]=1;

}

bool find(int x)

{

    if (f[x]) return 0;

    f[x]=1;

    for (int i=1; i<=n; i++)

        if (road[x][i])

            {

                if (!used[i] || find(part[i]))

                    {

                        used[i]=1;part[i]=x;return 1;

                    }

            }

    return 0;

}

int main()

{

    n=read(),m=read();

    for (int i=1; i<=m; i++)

        {

            int u=read(),v=read();

            road[u][v]=1;

        }

    floyed();

    for (int i=1; i<=n; i++)

        {

            memset(f,0,sizeof(f));

            if (find(i)) ans++;

        }

    printf("%d\n",n-ans);

    return 0;

}