【ZJOI2011】营救皮卡丘

题面

https://www.luogu.org/problem/P4542

神仙题。

做最小路径覆盖。

有一个很像的地方，就是最小路径覆盖必须覆盖到每个点，这道题也一样。

这道题有4个和最小路径覆盖不一样的地方

1. 可以重复访问（这个可以用$Floyed$传递闭包解决）
2. 每条路径必须从原点出发
3. 每个点必须被“到达”（并不能一个节点成一个路径）
4. 假设已经访问了$1..x$，那么至少有一个人，它的访问序列中第一个比$x$大的元素为$x+1$

我们从第四点突破，假设已经访问了$1..x$，那么至少有一个人$p_i$，它的访问序列中第一个比$x$大的元素为$x+1$，我们称$p_i$击破了$x+1$。

显然，对于一个合法的路径覆盖，一个人的击破序列是递增的，且击破序列中，每个点出现且仅出现一次。

那我们就直接对击破序列做最小路径覆盖，$dis[i][j]$表示上一个击破的是$i$，这次要来击破$j$了$(i<j)$，不能访问比$j$大的节点，做一次$Floyed$即可求出。

但是这样还不照，因为对于每个人，我们都需要支付它从$0$到第一个击破的点的费用，二分图上，我们建$k$个新的$0$点，连得边和老$0$点一样的。在网络流中，就直接给$0$点流$k$即可。

这样还是有问题，首先不能保证恰好是$k$条，其次不能保证$k$条都是每条对应一个起点。

也很简单。

$k$条都是每条对应一个起点，因为起点之间没有连边，所以不可能有两个起点在一起的。

总共$n+k$个点，只有最大流是$n$，则恰好就是$k$条，由霍尔定理，$Y$部上面的$n$个点肯定饱和，下面$k$个点肯定匹配不到，所以最大流是$n$。

代码

#include<map>
#include<stack>
#include<queue>
#include<vector>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define N 500
#define S 0
#define T (2*n+3)
#define LL long long
#define ri register int
#define INF 1000000007
using namespace std;

int n,m,k;
int dis[N][N];

struct graph {
  vector<int> to,w,c;
  vector<int> ed[N];
  LL dis[N]; int cur[N];
  bool vis[N];
  void add_edge(int a,int b,int aw,int ac) {
    to.push_back(b); w.push_back(aw); c.push_back(ac);  ed[a].push_back(to.size()-1);
    to.push_back(a); w.push_back(0);  c.push_back(-ac); ed[b].push_back(to.size()-1);
  }
  bool spfa() {
    memset(dis,0x3f,sizeof(dis));
    memset(vis,0,sizeof(vis));
    queue<int> q;
    dis[S]=0;q.push(S);vis[S]=1;
    while (!q.empty()) {
      int x=q.front(); q.pop();
      for (ri i=0;i<ed[x].size();i++) {
        int e=ed[x][i];
        if (dis[to[e]]>dis[x]+c[e] && w[e]) {
          dis[to[e]]=dis[x]+c[e];
          if (!vis[to[e]]) vis[to[e]]=1,q.push(to[e]);
        }
      }
      vis[x]=0;
    }
    return dis[T]<INF;
  }
  int dfs(int x,int lim) {
    if (x==T || !lim) return lim;
    LL sum=0; vis[x]=1;
    for (ri &i=cur[x];i<ed[x].size();i++) {
      int e=ed[x][i];
      if (dis[x]+c[e]==dis[to[e]] && w[e] && !vis[to[e]]) {
        int f=dfs(to[e],min(lim,w[e]));
        w[e]-=f; w[1^e]+=f;
        lim-=f; sum+=f;
        if (!lim) return sum;
      }
    }
    return sum;
  }
  LL zkw() {
    LL ret=0;
    while (spfa()) {
      memset(vis,0,sizeof(vis));
      memset(cur,0,sizeof(cur));
      ret+=dfs(S,INF)*dis[T];
    }
    return ret;
  }
} G;

int main() {
  int a,b,l;
  scanf("%d %d %d",&n,&m,&k);
  memset(dis,0x3f,sizeof(dis));
  for (ri i=0;i<=n;i++) dis[i][i]=0;
  for (ri i=1;i<=m;i++) {
    scanf("%d %d %d",&a,&b,&l);
    dis[a][b]=dis[b][a]=min(dis[a][b],l);
  }
  for (ri kk=0;kk<=n;kk++)
    for (ri i=0;i<=n;i++)
      for (ri j=0;j<=n;j++) 
        if (kk<=i || kk<=j) dis[i][j]=min(dis[i][j],dis[i][kk]+dis[kk][j]);
  for (ri i=1;i<=n+1;i++) 
    for (ri j=i+1;j<=n+1;j++) if (i!=j) G.add_edge(i,n+1+j,1,dis[i-1][j-1]);
  G.add_edge(S,1,k,0);
  for (ri i=2;i<=n+1;i++) G.add_edge(S,i,1,0);
  for (ri i=n+2;i<=2*(n+1);i++) G.add_edge(i,T,1,0);
  cout<<G.zkw()<<endl;
}