BZOJ 1266: [AHOI2006]上学路线route

题目描述

可可和卡卡家住合肥市的东郊，每天上学他们都要转车多次才能到达市区西端的学校。直到有一天他们两人参加了学校的信息学奥林匹克竞赛小组才发现每天上学的乘车路线不一定是最优的。

可可：“很可能我们在上学的路途上浪费了大量的时间，让我们写一个程序来计算上学需要的最少时间吧！”

合肥市一共设有N个公交车站，不妨将它们编号为1…N的自然数，并认为可可和卡卡家住在1号汽车站附近，而他们学校在N号汽车站。市内有M条直达汽车路线，执行第i条路线的公交车往返于站点pi和qi之间，从起点到终点需要花费的时间为ti。(1<=i<=M, 1<=pi, qi<=N)

两个人坐在电脑前，根据上面的信息很快就编程算出了最优的乘车方案。然而可可忽然有了一个鬼点子，他想趁卡卡不备，在卡卡的输入数据中删去一些路线，从而让卡卡的程序得出的答案大于实际的最短时间。而对于每一条路线i事实上都有一个代价ci：删去路线的ci越大卡卡就越容易发现这个玩笑，可可想知道什么样的删除方案可以达到他的目的而让被删除的公交车路线ci之和最小。

[任务]

编写一个程序：

l 从输入文件中读取合肥市公交路线的信息；

l 计算出实际上可可和卡卡上学需要花费的最少时间；

l 帮助可可设计一个方案，删除输入信息中的一些公交路线，使得删除后从家到学校需要的最少时间变大，而被删除路线的ci和最小；

l 向输出文件输出答案。

输入

输入文件中第一行有两个正整数N和M，分别表示合肥市公交车站和公交汽车路线的个数。以下M行，每行（第i行，总第(i+1)行）用四个正整数描述第i条路线：pi, qi, ti,ci；具体含义见上文描述。

输出

输出文件最多有两行。

第一行中仅有一个整数，表示从可可和卡卡家到学校需要的最短时间。

第二行ci之和的最小值。

样例输入

6 7 1 2 1 3 2 6 1 5 1 3 1 1 3 4 1 1 4 6 1 1 5 6 1 2 1 5 1 4

样例输出

2 5

提示

2<=N<=500, 1<=M<=124 750, 1<=ti, ci<=10 000

合肥市的公交网络十分发达，你可以认为任意两个车站间都可以通过直达或转车互相到达，当然如果在你提供的删除方案中，家和学校无法互相到达，那么则认为上学需要的最短为正无穷大：这显然是一个合法的方案。

 

先用SPFA跑出1到n的最短路，然后把满足最短路的边都选出来重新建图，最后跑一遍最小割，细节在于边有重复，容量要用+=.

具体看代码：

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<cmath>
 #include<cstdlib>
 #include<queue>
 #include<vector>
 using namespace std;
 const int M=;
 int gi()
 {
     int str=;char ch=getchar();
     while(ch>'' || ch<'')ch=getchar();
     while(ch>='' && ch<='')str=str*+ch-'',ch=getchar();
     return str;
 }
 const int N=;
 const int INF=;
 int n,m;int q[M*];
 struct Lin
 {
     int next,to,dis,ct;
 }a[M*];
 bool vis[N];int f[N][];
 int num=;int head[N];
 void init(int x,int y,int z,int ff)
 {
     a[++num].next=head[x];
     a[num].to=y;
     a[num].dis=z;
     a[num].ct=ff;
     head[x]=num;
 }
 void spfa(bool t,int sta)
 {
     int sum=,tail=;
     vis[sta]=;
     q[]=sta;
     int x,u;
     for(int i=;i<=n;i++)vis[i]=,f[i][t]=INF;
     f[sta][t]=;
     while(tail!=sum)
     {
         x=q[++tail];
         for(int i=head[x];i;i=a[i].next)
         {
             u=a[i].to;
             if(f[x][t]+a[i].dis<f[u][t])
             {
                 f[u][t]=a[i].dis+f[x][t];
                 if(!vis[u])
                 {
                     q[++sum]=u;
                     vis[u]=true;
                 }
             }
         }
         vis[x]=false;
     }
 }
 int flow[N][N];
 int dep[N];
 bool bfs()
 {
     memset(dep,,sizeof(dep));
     int t=,sum=;
     dep[]=;
     q[]=;
     int x;
     while(t!=sum)
     {
         x=q[++t];
         for(int i=;i<=n;i++)
         {
             if(dep[i] || flow[x][i]<=)continue;
             dep[i]=dep[x]+;
             q[++sum]=i;
         }
     }
     if(dep[n])
     return true;
     return false;
 }

 int dfs(int x,int flows)
 {
     if(x==n || !flows)return flows;
     int sum=,tmp;
     for(int i=;i<=n;i++)
     {
         if(flow[x][i]<= || dep[i]!=dep[x]+)continue;
         tmp=dfs(i,min(flows,flow[x][i]));
         flow[x][i]-=tmp;
         flow[i][x]+=tmp;
         flows-=tmp;
         sum+=tmp;
         if(!flows)break;
     }
     return sum;
 }
 void work()
 {
     int cc=,tot=;
     while(bfs()){
         cc=;cc=dfs(,INF);
         while(cc)tot+=cc,cc=dfs(,INF);
     }
     printf("%d",tot);
 }
 void build()
 {
     for(int i=;i<=n;i++){
         for(int j=head[i];j;j=a[j].next){
             if(f[n][]==f[a[j].to][]+f[i][]+a[j].dis)flow[i][a[j].to]+=a[j].ct;
         }
     }
 }
 int main()
 {
     n=gi();m=gi();
     int x,y,z,ss;
     for(int i=;i<=m;i++)
     {
         x=gi();y=gi();z=gi();ss=gi();
         init(x,y,z,ss);init(y,x,z,ss);
     }
     spfa(,);
     printf("%d\n",f[n][]);
     spfa(,n);
     build();
     work();
     return ;
 }