携程 最短路径的代价

携程的一道图论题

题意：给出一张无向图 每条边有一个长度和 删除该边的权值  再给出起点和终点 求从起点到终点的最短路增加 要删除的边的最小的权值和。

【思路】要使 从起点到终点的最短路长度增加 就要把该最短路破坏掉  从起点到终点的最短路可能不止一条，我们可以把 这些路径都找出来 重新构成一个图

            再求这个图的最小割 就是答案了    怎么把这些路径都找出来呢  求两次最短路 第一次求 所有点到起点的最短路d1[x]  第二次求所有点到终点的最短               路 d2[x]    从起点到终点的最短路为ans 。再遍历每一条边 对于d1[u]+d2[v]+w[u][v]== ans 的边就可以加入了~

    

还要改一点 先放这里

#include<iostream>
#include<stdio.h>
#include<cstring>
#include<cstdlib>
#include<queue>
#include<math.h>
#include<algorithm>
#include<vector>
#define maxx 9999999
using namespace std;

struct E{int from;int to;int c;int f;};
struct node{int v;int w;int c;};
vector <node> g1[1002];
vector <int > g[1002];
vector<E> edge;
int vis[1002],d1[1002],d2[1002],n,a[1002],p[1002],num[1002],cur[1002],d[1002];

void add(int from,int to,int c)
 {
     E temp1,temp2;
     temp1.from =from; temp1.to=to; temp1.c=c;temp1.f=0;
     temp2.from =to; temp2.to=from; temp2.c=0;temp2.f=0;
     edge.push_back (temp1);
     edge.push_back (temp2);
     int m=edge.size ();
     g[from].push_back (m-2);
     g[to].push_back (m-1);
 }

 void bfs(int s,int t)
 {
     int i;
     queue<int > q;
     q.push (t);
     d[t]=0;
     memset(vis,0,sizeof(vis));
     vis[t]=1;
     while(!q.empty ())
     {
         int t=q.front ();q.pop ();
         for(i=0;i<g[t].size ();i++)
         {
            E e;e=edge[g[t][i]];
            if(!vis[e.to])
            {
                q.push (e.to);
                vis[e.to]=1;
                d[e.to]=d[t]+1;
            }
         }
     }
 }

 int zg(int s,int t)
 {
     int x=t,a=maxx;
     while(x!=s)
     {
         //printf("x   %d
",x);
         E e=edge[p[x]];
         if(a>e.c-e.f)
             a=e.c-e.f;
         x=e.from;
     }
     x=t;
     while(x!=s)
     {
         edge[p[x]].f+=a;
         edge[p[x]^1].f-=a;
         x=edge[p[x]].from ;
     }
     return a;
 }

 int maxflow(int s,int t,int n)
 {
     int flow=0,i;
     bfs(s,t);
     memset(num,0,sizeof(num));
     memset(cur,0,sizeof(cur));
     for(i=0;i<=t;i++)
         num[d[i]]++;
     int x=s;
     while(d[s]<n)
     {
         if(x==t)
         {
             flow+=zg(s,t);
             x=s;
             printf("flow  %d
",flow);
         }
         int ok=0;
         for(i=cur[x];i<g[x].size ();i++)
         {
             E e;
             e=edge[g[x][i]];
             if(e.c>e.f&&d[x]==d[e.to]+1)
             {
                 ok=1;

                 p[e.to]=g[x][i];

                 cur[x]=i;
                 x=e.to;//!@#$%^&
                 break;
             }
         }
         if(ok==0)
         {
             int m=n;
             for(i=0;i<g[x].size ();i++)
             {
                 E e;
                 e=edge[g[x][i]];
                 if(e.c>e.f&&m>d[e.to])
                     m=d[e.to];
             }
             if(--num[d[x]]==0)  break;
             num[d[x]=m+1]++;
             cur[x]=0;////!@#$%^^&
             if(x!=s)
                 x=edge[p[x]].from ;

         }
     }
     return flow;
 }


int spfa1(int s,int t)
{
    queue<int > q;
    memset(vis,0,sizeof(vis));
    for(int i=0;i<=n;i++)
        d1[i]=maxx;
    d1[s]=0;
    vis[s]=1;
    q.push(s);
    while(!q.empty())
    {
        int u;
        u=q.front(); q.pop(); vis[u]=0;
        for(int i=0;i<g1[u].size();i++)
        {
            int v;
            v=g1[u][i].v;
            if((d1[u]+g1[u][i].w)<d1[v])
            {
                d1[v]=d1[u]+g1[u][i].w;
                if(!vis[v])
                {
                    vis[v]=1;
                    q.push(v);
                }
            }
        }
    }
    return d1[t];
}
int spfa2(int s,int t)
{
    queue<int > q;
    memset(vis,0,sizeof(vis));
    for(int i=0;i<=n;i++)
        d2[i]=maxx;
    d2[s]=0;
    vis[s]=1;
    q.push(s);
    while(!q.empty())
    {
        int u;
        u=q.front(); q.pop(); vis[u]=0;
        for(int i=0;i<g1[u].size();i++)
        {
            int v;
            v=g1[u][i].v;
            if((d2[u]+g1[u][i].w)<d2[v])
            {
                d2[v]=d2[u]+g1[u][i].w;
                if(!vis[v])
                {
                    vis[v]=1;
                    q.push(v);
                }
            }
        }
    }
    return d2[t];
}


int main()
{
    int m,i,j,a,b,s,t,t1,t2;
    while(~scanf("%d%d",&n,&m))
    {
        if(n==0&&m==0)
            break;
        scanf("%d%d",&s,&t);
        for(i=0;i<=n;i++)
        {
            g[i].clear();
            g1[i].clear();
        }
        edge.clear();
        while(m--)
        {
            scanf("%d%d%d%d",&a,&b,&t1,&t2);
            node temp;
            temp.v=b; temp.c=t2; temp.w=t1;
            g1[a].push_back(temp);
            temp.v=a;
            g1[b].push_back(temp);

        }
       int ans;
       ans=spfa1(s,t);
       spfa2(t,s);
       //printf("chang   %d
",ans);
       for(int i=1;i<=n;i++)  //构图 求最大流
           for(int j=0;j<g1[i].size();j++)
           {
               int v;
               v=g1[i][j].v;
               //printf("%d %d %d %d %d
",i,v,d1[i],d2[v],g[i][j].w);
               if((d1[i]+d2[v]+g1[i][j].w)==ans||(d2[i]+d1[v]+g1[i][j].w)==ans)//
               {
                   //printf("iv  %d %d %d
",i,v,g1[i][j].c);
                   add(i,v,g1[i][j].c);////////
               }
           }
           //printf("***");
           //printf("st  %d %d
",s,t);
           printf("ans     %d
",maxflow(s,t,n));
    }
    return 0;
}