hdu3416 最短路+最大流

题意：有 n 点 m 边，有出发点 A 到达点 B ，只允许走原图中的最短路，但每条边只允许被走一次，问最多能找出多少条边不重复的最短路

一开始做到的时候瞎做了一发最短路，WA了之后也知道显然不对，就放着了，后来打了今年的多校，再做到的时候发现和多校第一场的1007一样的……最短路+网络流就行了，只不过第一次做这个的时候我还不知道网络流是啥，不会做也正常啦。

首先对于原图跑一遍最短路求出每个点距离 A 点的最短路，然后对于每一条边，如果它的权值等于它连接的两点的最短路的差值的时候，就说明这条路是最短路上的边，将这个边加入网络流的建图中，流量定为1表示这条边只能用一次，这样跑一遍最大流就能直接解决问题了。

 #include<stdio.h>
 #include<string.h>
 #include<algorithm>
 #include<queue>
 #include<vector>
 using namespace std;
 typedef pair<int,int> pii;
 const int maxm=;
 const int INF=0x3f3f3f3f;

 struct cmp{
     bool operator()(pii a,pii b){
         return a.first>b.first;
     }
 };

 int head[],point[],val[],nxt[],size;
 bool vis[];
 int dis[],n,s,p,fa[],pa[];

 struct edge{             //弧的结构体，变量：弧的出发点、结束点、容量、流量
     int from,to,c,f;
     edge(int a,int b,int m,int n):from(a),to(b),c(m),f(n){}
 };

 struct dinic{
     int m,s,t;                    //边数、源点标号、汇点标号
     vector<edge>e;        //边
     vector<int>g[maxm];    //g[i][j]表示第i个点出发的第j条边在e中的编号
     bool vis[maxm];
     int d[maxm],cur[maxm];    //d为源点到点的距离，cur为当前遍历到的边
     void init(int n){                //初始化，n为点数量（标号0～n-1）
         for(int i=;i<n+;i++)g[i].clear();
         e.clear();
     }
     void add(int a,int b,int v){        //加入弧和反向弧
         e.push_back(edge(a,b,v,));    //正向弧容量v，反向弧容量0
         e.push_back(edge(b,a,,));
         m=e.size();
         g[a].push_back(m-);
         g[b].push_back(m-);
     }
     bool bfs(){
         memset(vis,,sizeof(vis));
         queue<int>q;
         q.push(s);
         d[s]=;
         vis[s]=;
         while(!q.empty()){
             int u=q.front();q.pop();
             for(int i=;i<g[u].size();i++){
                 edge tmp=e[g[u][i]];
                 if(!vis[tmp.to]&&tmp.c>tmp.f){
                     vis[tmp.to]=;
                     d[tmp.to]=d[u]+;
                     q.push(tmp.to);
                 }
             }
         }
         return vis[t];
     }
     int dfs(int x,int a){
         if(x==t||a==)return a;
         int flow=,f;
         for(int& i=cur[x];i<g[x].size();i++){
             edge &tmp=e[g[x][i]];
             if(d[x]+==d[tmp.to]&&(f=dfs(tmp.to,min(a,tmp.c-tmp.f)))>){
                 tmp.f+=f;
                 e[g[x][i]^].f-=f;
                 flow+=f;
                 a-=f;
                 if(a==)break;
             }
         }
         if(!flow)d[x]=-;
         return flow;
     }
     int mf(int s,int t){                //在主函数中使用的函数，求s到t的最大流
         this->s=s;
         this->t=t;
         int flow=;
         while(bfs()){
             memset(cur,,sizeof(cur));
             flow+=dfs(s,INF);
         }
         return flow;
     }
 };

 void add(int a,int b,int v){
     point[size]=b;
     val[size]=v;
     nxt[size]=head[a];
     head[a]=size++;
 }

 void dij(){
     int i;
     priority_queue<pii,vector<pii>,cmp>q;
     memset(dis,0x3f,sizeof(dis));
     memset(fa,-,sizeof(fa));
     dis[s]=;
     q.push(make_pair(dis[s],s));
     while(!q.empty()){
         pii u=q.top();
         q.pop();
         if(u.first>dis[u.second])continue;
         for(i=head[u.second];~i;i=nxt[i]){
             int j=point[i],v=u.first+val[i];
             if(!vis[i]&&dis[j]>v){
                 dis[j]=v;
                 fa[j]=u.second;
                 pa[j]=i;
                 q.push(make_pair(dis[j],j));
             }
         }
     }
 }

 int main(){
     int t;
     scanf("%d",&t);
     for(int q=;q<=t;q++){
         int m,i;
         memset(head,-,sizeof(head));
         memset(vis,,sizeof(vis));
         size=;
         scanf("%d%d",&n,&m);
         for(i=;i<=m;i++){
             int a,b,v;
             scanf("%d%d%d",&a,&b,&v);
             if(a!=b){
                 add(a,b,v);
             }
         }
         scanf("%d%d",&s,&p);
         dinic d;
         dij();
         for(i=;i<=n;++i){
             for(int j=head[i];~j;j=nxt[j]){
                 int k=point[j];
                 if(dis[i]+val[j]==dis[k])d.add(i,k,);
             }
         }
         printf("%d\n",d.mf(s,p));
     }
     return ;
 }