最小链/路径覆盖 x 最长反链 洛谷 P2764 最小路径覆盖问题 BZOJ 1143祭祀river

DAG最小路径覆盖

定义

对于给定的有向无环图，要求用最少的 ||不相交的|| 简单路径，覆盖图中的所有点

解法

将原图中每个结点拆点(即拆成u与u+n)
对于原图中的每条边u到v，在新图中u到v+n连边
将1~n作位二分图的左部，n+1 ~ n*2作位二分图的右部，进行二分图最大匹配
最后n-最大匹配数即为所求最少路径数

---

DAG最小链覆盖

定义

对于给定的有向无环图，要求用最少的 ||可以相交的|| 简单路径，覆盖图中的所有点

解法

用Floyd传递闭包的思想将图的连通性传递

for(int k=1;k<=n;k++)
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
mp[i][j]|=(mp[i][k]&mp[k][j]);

传递完成后若有$mp[u][v]==1$(即$u$可以到达$v$)
那么就在二分图中建边$u\to v$

建图完成后问题即转化为最小路径覆盖
n-最大匹配数即为答案

---

最长反链

定义

链：一条链是一些点的集合，链上任意两个点x, y，满足要么x能到达y，要么y能到达x
反链：一条反链是一些点的集合，链上任意两个点x, y，满足x不能到达y，且y也不能到达x

定理

最长反链长度 = 最小链覆盖

---

---

洛谷 P2764 最小路径覆盖问题

题目描述

给定有向图G=(V,E)。设P 是G 的一个简单路（顶点不相交）的集合。如果V 中每个顶点恰好在P 的一条路上，则称P是G 的一个路径覆盖。P 中路径可以从V 的任何一个顶点开始，长度也是任意的，特别地，可以为0。G 的最小路径覆盖是G 的所含路径条数最少的路径覆盖。设计一个有效算法求一个有向无环图G 的最小路径覆盖。提示：设V={1，2，… ，n}，构造网络G1=(V1,E1)如下

每条边的容量均为1。求网络G1的（ 0 x , 0 y ）最大流。

«编程任务：
对于给定的给定有向无环图G，编程找出G的一个最小路径覆盖。

输入格式：

件第1 行有2个正整数n和m。n是给定有向无环图G 的顶点数，m是G 的边数。接下来的m行，每行有2 个正整数i和j，表示一条有向边(i,j)。

输出格式：

从第1 行开始，每行输出一条路径。文件的最后一行是最少路径数。

说明

1<=n<=150,1<=m<=6000

---

分析

模板题，建边方式套用上述方法

对于方案输出
用匈牙利求的话，可以直接在match数组中查询

用最大流的话，遍历图中x部到y部的所有边
若某条边流量为0，则证明这条边某条路径的一条边

这里上的是最大流的写法
注意要连接超源和超汇

---

#include<iostream>
#include<vector>
#include<algorithm>
#include<queue>
#include<cstring>
#include<cstdio>
using namespace std;

int read()
{
    int f=1,x=0;
    char ss=getchar();
    while(ss<'0'||ss>'9'){if(ss=='-')f=-1;ss=getchar();}
    while(ss>='0'&&ss<='9'){x=x*10+ss-'0';ss=getchar();}
    return f*x;
}

const int inf=1e9;
int n,m;
int s,t;
struct node{int v,f,nxt;}E[100010];
int tot=1,head[500];
int vis[500],lev[500];
int pre[500],nxt[500];
int maxf;

void add(int u,int v,int f)
{
    E[++tot].nxt=head[u];
    E[tot].v=v;
    E[tot].f=f;
    head[u]=tot;
}

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

int dfs(int u,int cap)
{
    if(u==t) return cap;
    int flow=cap;
    
    for(int i=head[u];i;i=E[i].nxt)
    {
        int v=E[i].v;
        if(lev[v]==lev[u]+1&&E[i].f&&flow)
        {
            int f=dfs(v,min(flow,E[i].f));
            flow-=f;
            E[i].f-=f; E[i^1].f+=f;
        }
    }
    return cap-flow;
}

int main()
{
    n=read();m=read();
    t=n<<1|1;
    for(int i=1;i<=m;++i)
    {
        int u=read(),v=read();
        add(u,v+n,1);add(v+n,u,0);
    }
    for(int i=1;i<=n;++i)
    {
        add(s,i,1);add(i,s,0);
        add(i+n,t,1);add(t,i+n,0);
    }
    while(bfs())
    maxf+=dfs(s,inf);//求最大匹配
    
    for(int u=1;u<=n;++u)//寻找路径
    for(int i=head[u];i;i=E[i].nxt)
    if(E[i].f==0)
    {
        int v=E[i].v; 
        pre[v-n]=u; nxt[u]=v-n;//pre记录路径中u的上一个点，nxt记录下一个点
        break;
    }
    
    for(int i=1;i<=n;i++)
    if(!pre[i])//从所有没有pre的点开始输出路径
    {
        int u=i;
        while(u>0){ printf("%d ",u); u=nxt[u]; }
        putchar('\n');
    }
    
    cout<<n-maxf;
    return 0;
}

---

BZOJ 1143 [CTSC2008]祭祀river

Description

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

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

Input

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

Output

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

【样例说明】

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

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

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

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

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

---

分析：

很明显的最长反链
套用上述最小链覆盖的方法即可

---

#include<iostream>
#include<vector>
#include<algorithm>
#include<queue>
#include<cstring>
#include<cstdio>
using namespace std;
 
int read()
{
    int f=1,x=0;
    char ss=getchar();
    while(ss<'0'||ss>'9'){if(ss=='-')f=-1;ss=getchar();}
    while(ss>='0'&&ss<='9'){x=x*10+ss-'0';ss=getchar();}
    return f*x;
}
 
const int maxn=110;
int n,m;
int map[maxn][maxn];
bool vis[maxn];
int match[maxn];
int ans;
 
bool dfs(int u)
{
    for(int v=1;v<=n;v++)
    {
        if(!map[u][v]||vis[v]) continue;
        vis[v]=true;
        if(!match[v]||dfs(match[v]))
        {
            match[v]=u;
            return true;
        }
    }
    return false;
}
 
int main()
{
    n=read();m=read();
    for(int i=1;i<=m;++i)
    {
        int u=read(),v=read();
        map[u][v]=1;
    }
    for(int k=1;k<=n;k++)//floyd实现传递闭包
    for(int i=1;i<=n;i++)
    for(int j=1;j<=n;j++)
    map[i][j]|=(map[i][k]&map[k][j]);
     
    for(int i=1;i<=n;i++)
    {
        memset(vis,false,sizeof(vis));
        if(dfs(i))ans++;
    }
     
    cout<<n-ans;
    return 0;
}