【LA3126 训练指南】出租车 【DAG最小路径覆盖】

题意

你在一座城市里负责一个大型活动的接待工作。明天将有m位客人从城市的不同的位置出发，到达他们各自的目的地。已知每个人的出发时间，出发地点和目的地。你的任务是用尽量少的出租车送他们，使得每次出租车接客人时，至少能提前一分钟到达他所在的位置。注意，为了满足这一条件，要么这位客人是这辆出租车接送的第一个人，要么在接送完上一个客人后，有足够的时间从上一个目的地开到这里。

为了简单起见，假定城区是网格型的，地址用坐标(x,y)表示，出租车从(x1,y1)到(x2,y2)处需要行驶|x1-x2|+|y1-y2|分钟。

分析

这个模型叫做DAG的最小路径覆盖。所谓最小路径覆盖，就是在图中找尽量少的路径，使得每个结点恰好在一条路径上（换句话说，不同的路径不能有公共点）。注意，单独的一个结点也可以作为一条路径。

DAG最小路径覆盖的解法如下：把所有的结点i拆为X结点i和Y结点i‘，如果图G中存在有向边i->j，则二分图中引入边i->j'。设二分图的最大匹配数为m，则结果就是n-m。因为匹配和路径覆盖是一一对应的。对于路径覆盖中的每条简单路径，除了最后一个“结尾结点”以外都有唯一的后继和他对应（既匹配结点），因此匹配数就是非结尾结点的个数，当匹配数达到最大时，此时，结尾结点的个数最少，既路径条数最少。

本题建模：每个客人是一个结点，如果同一个出租车接完客人u以后还来得及接客人v，连边u->v。不难发现，这个图是一个DAG，并且它的最小路径覆盖就是本题的答案。

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

 using namespace std;
 const int maxn=+;
 const int maxm=;
 const int INF=;
 struct Dinic{
     int head[maxn],Next[maxm],to[maxm],cap[maxm],flow[maxm];
     int sz,n,m,s,t;
     bool vis[maxn];
     int cur[maxn],d[maxn];
     void init(int n){
         this->n=n;
         memset(head,-,sizeof(head));
         this->sz=-;
     }
     void add_edge(int a,int b,int c){
         ++sz;
         to[sz]=b;
         cap[sz]=c;flow[sz]=;
         Next[sz]=head[a];head[a]=sz;
         ++sz;
         to[sz]=a;
         cap[sz]=c;flow[sz]=c;
         Next[sz]=head[b];head[b]=sz;
     }
     bool BFS(){
         memset(vis,,sizeof(vis));
         queue<int>Q;
         vis[s]=;
         d[s]=;
         Q.push(s);
         while(!Q.empty()){
             int u=Q.front();Q.pop();
             for(int i=head[u];i!=-;i=Next[i]){
                 int v=to[i];
                 if(!vis[v]&&cap[i]>flow[i]){
                     vis[v]=;
                     d[v]=d[u]+;
                     Q.push(v);
                 }
             }
         }
         return vis[t];
    }
     int DFS(int x,int a){
         if(x==t||a==)return a;
         int Flow=,f;
         for(int& i=cur[x];i!=-;i=Next[i]){
             int v=to[i];
             if(d[v]==d[x]+&&(f=DFS(v,min(a,cap[i]-flow[i])))>){
                 Flow+=f;
                 flow[i]+=f;
                 flow[i^]-=f;
                 a-=f;
                 if(a==)break;
             }
         }
         return Flow;
     }
     int Maxflow(int s,int t){
         this->s=s,this->t=t;
         int Flow=;
         while(BFS()){
             for(int i=;i<=n;i++)
              cur[i]=head[i];

             Flow+=DFS(s,INF);
         }
         return Flow;
     }
 }dinic;
 int T,m;
 int sth[maxn],stm[maxn],sx[maxn],sy[maxn],enx[maxn],eny[maxn];
 int dist(int x1,int y1,int x2,int y2){
     return abs(x1-x2)+abs(y1-y2);
 }
 void pass_time(int hou,int mi,int &Hou,int &Mi,int tim){
     Mi=mi+tim;
     Hou=hou+Mi/;
     Mi=Mi%;
     return;
 }
 int main(){
     scanf("%d",&T);
     for(int t=;t<=T;t++){
         scanf("%d",&m);
         dinic.init(*m+);
         for(int i=;i<=m;i++){
             scanf("%d:%d%d%d%d%d",&sth[i],&stm[i],&sx[i],&sy[i],&enx[i],&eny[i]);
         }

         for(int i=;i<=m;i++){
             for(int j=;j<=m;j++){
                 int tim=dist(sx[i],sy[i],enx[i],eny[i])+dist(enx[i],eny[i],sx[j],sy[j]);
                 int Enh,Enm;
                 pass_time(sth[i],stm[i],Enh,Enm,tim);
                 if(Enh*+Enm>=sth[j]*+stm[j])continue;
                 dinic.add_edge(i,j+m,);
             }
         }
         for(int i=;i<=m;i++)
           dinic.add_edge(,i,);
         for(int i=;i<=m;i++)
           dinic.add_edge(i+m,*m+,);
         int ans=dinic.Maxflow(,*m+);
         printf("%d\n",m-ans);

     }
 return ;
 }