hdu4294-网络流+最短路

给一个图，问你去掉多少边能让这个图的最短路不联通，最多去掉多少边能让他继续联通
这道题卡了好久，不过具体思路是确定的
先用spfa求最短路经，怎样记录最短路呢
满足条件 d[s]=d[v]+’<’v,s>>的边都在那个最短路图里啦
然后在这些边在建立一个图
最关键的时刻来了
1 我用的dinic，死活都不过，也用优化了，见代码1，但是总是tle，气死了
2 后来我直接走了一遍dfs，就阔以了。。。。妈蛋，这是为什么
看来以后要听 贴吧大神的话，用isap。。。。。

1 dinic
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <queue>
#include <vector>
using namespace std;
const int maxn=2000;
int dis[maxn];
int ranks[maxn];
bool vis[maxn];
int cengci[maxn];
int n,m;
int itr[maxn];
struct Edge
{   int from,to,next,cost;
    //Edge(int a,int b,int c,int d){from=a;to=b;cost=c;rev=d;}
}edge[maxn*2];
struct EG
{  int to,rev,cap;
    EG(int l,int b,int c){to=l;cap=b;rev=c;}
};
int head[maxn];
int len;
//bool vis[maxn];
vector<EG>G[maxn];
int cur[maxn];
void add(int from,int to,int value)
{   edge[len].from=from;
    edge[len].to=to;
    edge[len].cost=value;
    edge[len].next=head[from];
    head[from]=len++;


}
void addedge(int from,int to,int value)
{  G[from].push_back((EG){to,value,G[to].size()});
   G[to].push_back((EG){from,0,G[from].size()-1});


}
void init()
{  len=0;
   memset(head,-1,sizeof(head));
}
int spfa()
{   memset(dis,0x3f,sizeof(dis));
    memset(vis,0,sizeof(vis));
    memset(ranks,0x3f,sizeof(ranks));
    dis[1]=0;
    vis[1]=true;
    queue<int>q;
    q.push(1);
    ranks[1]=0;
    while(!q.empty())
    {   int u=q.front();
         q.pop();
         vis[u]=false;
        for(int i=head[u];i!=-1;i=edge[i].next)
         {   int s=edge[i].to;
             int len=edge[i].cost;
             if(dis[s]>dis[u]+len)//there
             {  dis[s]=dis[u]+len;
               ranks[s]=ranks[u]+1;
                       if(!vis[s])
                        {q.push(s);
                         vis[s]=1;}
             }
             else if(dis[s]==dis[u]+len)
             {   ranks[s]=min(ranks[s],ranks[u]+1);
                 if(!vis[s])
                 { q.push(s);
                    vis[s]=1;

                 }

             }

         }
    }
    return 0;
}
int sum,cas;
bool build()
{    
    sum=0;
    for(int i=1;i<=m;i++)
    {  for(int j=head[i];j!=-1;j=edge[j].next)
        {   int s=edge[j].to;
            if(dis[i]+edge[j].cost==dis[s])
             { addedge(i,s,1);
                sum++;
             }
        }
    }
return true;
}
int bfs()
{   queue<int>q;
   memset(ranks,-1,sizeof(ranks));
    ranks[1]=1;
    q.push(1);
    while(!q.empty())
    {   int u=q.front();
        q.pop();
        for(int i=0;i<G[u].size();i++)
        {   EG & e=G[u][i];
           if(ranks[e.to]==-1)
           {  ranks[e.to]=ranks[u]+1;
              q.push(e.to);
           }
        }
    }
    return 0;
}
int dfs(int v, int t, int f)
{   if(v==t)
    return f;
    for(int &i=cur[v];i<G[v].size();i++)
    {   EG &s=G[v][i];
        int x=G[v][i].to;
        int l=G[v][i].cap;
        int d=dfs(x,t,min(s.cap,f));
         if(d>0)
         {  s.cap-=d;
            G[s.to][s.rev].cap+=d;
         }
    }
return 0;
}
int max_flow(int s, int t)
{  int flow=0;
   int l;
   while(1)
   {   //printf("11\n");
       bfs();
      memset(cur,0,sizeof(cur));
      if(ranks[t]==-1)
        return flow;
      if(l=dfs(s,t,0x3f3f3f3f))
      {   flow+=l;
          printf("%d",f
    q.push(s);
    while(!q.empty())
    {   int u=q.front();
        q.pop();
        for(int i=0;i<G[u].size();i++)
        {   EG &e=G[u][i];
            if(cengci[e.to]<0&&e.cap>0)
            {  cengci[e.to]=cengci[u]+1;
               q.push(e.to);
            }
            if(cengci[e.to]>0)
            { cengci[e.to]=min(cengci[e.to],cengci[u]+1);
            }

        }
    }
}
int dfs(int s,int t,int f)
{  if(s==t)  return f;
     vis[s]=true;
    for(int &i=itr[s];i<G[s].size();i++)
    {   EG &e=G[s][i];
       if(!vis[e.to]&&e.cap>0)
       {   int d=dfs(e.to,t,min(e.cap,f));
           if(d>0)
           {   e.cap-=d;
              G[e.to][e.rev].cap+=d;
              return d;
           }
       }
    }
  return 0;
}
int max_flow(int s,int t)
{  int INF=0x3f3f3f3f;
int flow=0;
cas=1;
sum=0x3f3f3f3f;
bfs(s);
   while(cas++)
   {   bfs(s);
     memset(itr,0,sizeof(itr));
     memset(vis,0,sizeof(vis));
      if(cengci[t]<0)
            return flow;
      int l;
      while(l=dfs(s,t,INF))
         flow+=l;
   }
}
int main()
{
int a,b,c;
      cin>>m>>n;
      init();
      for(int i=0;i<n;i++)
      {   scanf("%d%d%d",&a,&b,&c);
         add(a,b,c);
        add(b,a,c);
      }
     spfa();
     build();
     int www=max_flow(1,m);
     printf("%d %d\n",www,n-ranks[m]);


    return 0;
}

2 普通的
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <queue>
#include <vector>
using namespace std;
const int maxn=12e4+5;
int dis[maxn];
int ranks[maxn];
bool vis[maxn];
int cengci[maxn];
int n,m;
int itr[maxn];
struct Edge
{   int from,to,next,cost;
    //Edge(int a,int b,int c,int d){from=a;to=b;cost=c;rev=d;}
}edge[maxn*2];
struct EG
{  int to,rev,cap;
    EG(int l,int b,int c){to=l;cap=b;rev=c;}
};
int head[maxn];
int len;
//bool vis[maxn];
vector<EG>G[maxn];
int cur[maxn];
void add(int from,int to,int value)
{   edge[len].from=from;
    edge[len].to=to;
    edge[len].cost=value;
    edge[len].next=head[from];
    head[from]=len++;


}
void addedge(int from,int to,int value)
{  G[from].push_back((EG){to,value,G[to].size()});
   G[to].push_back((EG){from,0,G[from].size()-1});


}
void init()
{  len=0;
   memset(head,-1,sizeof(head));
   for(int i=0;i<=n;i++)
    G[i].clear();
}
int spfa()
{   memset(dis,0x3f,sizeof(dis));
    memset(vis,0,sizeof(vis));
    memset(ranks,0x3f,sizeof(ranks));
    dis[1]=0;
    vis[1]=true;
    queue<int>q;
    q.push(1);
    ranks[1]=0;
    while(!q.empty())
    {   int u=q.front();
         q.pop();
         vis[u]=false;
        for(int i=head[u];i!=-1;i=edge[i].next)
         {   int s=edge[i].to;
             int len=edge[i].cost;
             if(dis[s]>dis[u]+len)//there
             {  dis[s]=dis[u]+len;
               ranks[s]=ranks[u]+1;
                       if(!vis[s])
                        {q.push(s);
                         vis[s]=1;}
             }
             else if(dis[s]==dis[u]+len)
             {   ranks[s]=min(ranks[s],ranks[u]+1);
                 if(!vis[s])
                 { q.push(s);
                    vis[s]=1;

                 }

             }

         }
    }
    return 0;
}
int sum,cas;
bool build()
{

    for(int i=1;i<=m;i++)
    {  for(int j=head[i];j!=-1;j=edge[j].next)
        {   int s=edge[j].to;
            if(dis[i]+edge[j].cost==dis[s])
             { addedge(i,s,1);

             }
        }
    }
return true;
}
int dfs(int s,int t,int f)
{  if(s==t)  return f;
     //if(vis[s]) return 0;
     vis[s]=true;
    for(int i=0;i<G[s].size();i++)
    {   EG &e=G[s][i];
       if(!vis[e.to]&&e.cap>0)
       {   int d=dfs(e.to,t,min(e.cap,f));
           if(d>0)
           {   e.cap-=d;
              G[e.to][e.rev].cap+=d;
              return d;
           }
       }
    }
  //vis[s]=0;
  return 0;
}
int max_flow(int s,int t)
{  int INF=0x3f3f3f3f;
int flow=0;
cas=1;
sum=0x3f3f3f3f;
   while(1)
   {  // bfs(s);
     //memset(itr,0,sizeof(itr));
     memset(vis,0,sizeof(vis));
      //if(cengci[t]<0)
        //{  //printf("%d!!! %d\n",t,cengci[t]);
            //printf("%d!!!!\n",cas++);
            //return flow;
      int l=dfs(s,t,0x3f3f3f3f);//=dfs(s,t,INF);
      if(l==0)return flow;
         flow+=l;
         //if(l==0) return flow;



   }
   //return 0;
}
int main()
{
int a,b,c;
      while(~scanf("%d%d",&m,&n))
      {//cin>>m>>n;
      init();
      for(int i=0;i<n;i++)
      {   scanf("%d%d%d",&a,&b,&c);
         add(a,b,c);
        add(b,a,c);
      }
     spfa();
     //printf("%d\n",dis[m]);
     build();
     /*for(int i=1;i<=m;i++)
        for(int j=0;j<G[i].size();j++)
     {   printf("%d %d %d\n",i,G[i][j].to,G[i][j].cap);


     }*/
     int www=max_flow(1,m);
     printf("%d %d\n",www,n-ranks[m]);

      }
    return 0;
}