War(最短路+最大流)

War

http://acm.hdu.edu.cn/showproblem.php?pid=3599

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 1870    Accepted Submission(s): 442

Problem Description

In the war between Anihc and Bandzi, Anihc has won Bangzi. At that time, Lvbin, the king of Anihc, want to start from Bangzi to beat Nebir across the channel between them. He let his army get to there as soon as possible, and there located many islands which can be used to have a break. In order to save time, the king forbid the army getting through the same pass for more than one time, but they can reach the same island for as many as times they want.
Yunfeng, the General of the army, must tell how many optimal ship routes are there to the king as soon as possible, or he will be killed. Now he asks for your help. You must help Yunfeng to save his life.
He tells you that there are N island. The islands are numbered from 1 to N(1 is Bangzi and N is Nebir, others are many islands). And there are many ways, each way contain the islands number U and V and the length W. Please output your answer.

 

Input

The first line in the input file contains a single integer number T means the case number. 
Each case contains a number N (N<=1500) means the number of the islands. 
And then many lines follow. Each line contains three numbers: U V W (W<10000), means that the distance between island U and V is W. The input of ways are terminated by “ 0 0 0 ”.

 

Output

Print the number of the optimal ship routes are there after each case in a line.

 

Sample Input

1

6

1 2 1

3 2 1

3 4 1

1 3 2

4 2 2

4 5 1

5 6 1

4 6 2

0 0 0

 

Sample Output

2

 

Author

alpc92

 

Source

2010 ACM-ICPC Multi-University Training Contest（16）——Host by NUDT

 

 

 

 #include<iostream>
 #include<cstring>
 #include<string>
 #include<cmath>
 #include<cstdio>
 #include<algorithm>
 #include<queue>
 #include<vector>
 #include<set>
 #define INF 0x3f3f3f3f
 #define maxn 2005
 #define MAXN 1000005
 #define mem(a,b) memset(a,b,sizeof(a))
 using namespace std;

 int n;
 struct sair{
     int len,pos;
     bool operator<(const sair &b)const{
         return len>b.len;
     }
 };
 int dis[maxn];
 int vis[maxn];
 vector<pair<int,int> >ve[maxn];
 void Dijstra(){
     priority_queue<sair>q;
     sair tmp;
     tmp.len=,tmp.pos=;
     dis[]=;
     q.push(tmp);
     while(!q.empty()){
         tmp=q.top();
         q.pop();
         int pos=tmp.pos;
         if(vis[pos]){
             continue;
         }
         vis[pos]=;
         for(int i=;i<ve[pos].size();i++){
             int f=ve[pos][i].first;
             int len=ve[pos][i].second;

             if(dis[f]>dis[pos]+len){
                 dis[f]=dis[pos]+len;
                 tmp.pos=f;
                 tmp.len=dis[f];
                 q.push(tmp);
             }
         }
     }
 }

 struct Edge{
     int v,next;
     int cap,flow;
 }edge[MAXN*];//注意这里要开的够大。。不然WA在这里真的想骂人。。问题是还不报RE。。
 int cur[MAXN],pre[MAXN],gap[MAXN],path[MAXN],dep[MAXN];
 int cnt=;//实际存储总边数
 void isap_init()
 {
     cnt=;
     memset(pre,-,sizeof(pre));
 }
 void isap_add(int u,int v,int w)//加边
 {
     edge[cnt].v=v;
     edge[cnt].cap=w;
     edge[cnt].flow=;
     edge[cnt].next=pre[u];
     pre[u]=cnt++;
 }
 void add(int u,int v,int w){
     isap_add(u,v,w);
     isap_add(v,u,);
 }
 bool bfs(int s,int t)//其实这个bfs可以融合到下面的迭代里，但是好像是时间要长
 {
     memset(dep,-,sizeof(dep));
     memset(gap,,sizeof(gap));
     gap[]=;
     dep[t]=;
     queue<int>q;
     while(!q.empty()) q.pop();
     q.push(t);//从汇点开始反向建层次图
     while(!q.empty())
     {
         int u=q.front();
         q.pop();
         for(int i=pre[u];i!=-;i=edge[i].next)
         {
             int v=edge[i].v;
             if(dep[v]==-&&edge[i^].cap>edge[i^].flow)//注意是从汇点反向bfs，但应该判断正向弧的余量
             {
                 dep[v]=dep[u]+;
                 gap[dep[v]]++;
                 q.push(v);
                 //if(v==sp)//感觉这两句优化加了一般没错，但是有的题可能会错，所以还是注释出来，到时候视情况而定
                 //break;
             }
         }
     }
     return dep[s]!=-;
 }
 int isap(int s,int t)
 {
     if(!bfs(s,t))
     return ;
     memcpy(cur,pre,sizeof(pre));
     //for(int i=1;i<=n;i++)
     //cout<<"cur "<<cur[i]<<endl;
     int u=s;
     path[u]=-;
     int ans=;
     while(dep[s]<n)//迭代寻找增广路,n为节点数
     {
         if(u==t)
         {
             int f=INF;
             for(int i=path[u];i!=-;i=path[edge[i^].v])//修改找到的增广路
                 f=min(f,edge[i].cap-edge[i].flow);
             for(int i=path[u];i!=-;i=path[edge[i^].v])
             {
                 edge[i].flow+=f;
                 edge[i^].flow-=f;
             }
             ans+=f;
             u=s;
             continue;
         }
         bool flag=false;
         int v;
         for(int i=cur[u];i!=-;i=edge[i].next)
         {
             v=edge[i].v;
             if(dep[v]+==dep[u]&&edge[i].cap-edge[i].flow)
             {
                 cur[u]=path[v]=i;//当前弧优化
                 flag=true;
                 break;
             }
         }
         if(flag)
         {
             u=v;
             continue;
         }
         int x=n;
         if(!(--gap[dep[u]]))return ans;//gap优化
         for(int i=pre[u];i!=-;i=edge[i].next)
         {
             if(edge[i].cap-edge[i].flow&&dep[edge[i].v]<x)
             {
                 x=dep[edge[i].v];
                 cur[u]=i;//常数优化
             }
         }
         dep[u]=x+;
         gap[dep[u]]++;
         if(u!=s)//当前点没有增广路则后退一个点
         u=edge[path[u]^].v;
      }
      return ans;
 }
 struct Bian{
     int x,y,v;
 }B[MAXN];

 int main(){

     std::ios::sync_with_stdio(false);
     int T;
     cin>>T;
     while(T--){
         cin>>n;
         for(int i=;i<=n;i++){
             dis[i]=INF;
             vis[i]=;
         }
         for(int i=;i<=n;i++){
             ve[i].clear();
         }
         int a,b,c;
         int j;
         int co=;
         while(cin>>B[co].x>>B[co].y>>B[co].v){
             if(!B[co].x&&!B[co].y&&!B[co].v){
                 break;
             }
             ve[B[co].x].push_back(make_pair(B[co].y,B[co].v));
             ve[B[co].y].push_back(make_pair(B[co].x,B[co].v));
             co++;
         }
         Dijstra();
         isap_init();
         if(dis[n]==INF||n==){
             cout<<<<endl;
             continue;
         }
         for(int i=;i<co;i++){///判断是不是最短路上的边
             if(dis[B[i].x]-dis[B[i].y]==B[i].v){
                 add(B[i].y,B[i].x,);
             }
             else if(dis[B[i].y]-dis[B[i].x]==B[i].v){
                 add(B[i].x,B[i].y,);
             }
         }
         int s=,t=n;
         int ans=isap(s,t);
         cout<<ans<<endl;
     }

 }