hdu 1595 BFS 记录边+SPFA

/*
题意：从点1到点n有一条最短路，但是这条最短路上有条边坏了，但是不确定是哪条，要你求坏一条边后的最大的最短路
输入 输出 n,m,n个点，m条边。输出最大的最短路
思路：用bfs先遍历求出1到n的最短路并保存，然后用SPRA算法枚举最短路上的任和一条边，求最短路，然后比较出最大值即可
*/
#include<stdio.h>
#include<string.h>
#include<queue>
#include<stdlib.h>
#include<vector>
using namespace std;
#define INF 999999999
struct edge
{
    int from,to;
    int w;
    int flag;
    int id;
};
struct node
{
   int x;
   int sum;
   int id;
   int idd;
   friend bool operator < (node n1,node n2)
    {
        return n1.sum>n2.sum; //<为从大到小，>大于从小到大；
    }
};
bool vis[1000001];
vector<edge>edges;
vector<int>G[1001];
int way[1000001][2];
int n,m;
int dis[1001];
int ans;
int tot;
void addedge(int x,int y,int w)
{
    edge a={x,y,w,1,tot++};
    edges.push_back(a);
    edge b={y,x,w,1,tot++};
    edges.push_back(b);
    G[y].push_back(edges.size()-1);
    G[x].push_back(edges.size()-2);
}
void inint()
{
    for(int i=1;i<=n;i++)
    {
        G[i].clear();
    }
    edges.clear();
}
void SPFA1()
{
    for(int i=1;i<=n;i++)
        dis[i]=INF;
    queue<int>q;
    dis[1]=0;
    q.push(1);
    int a,b;
    while(!q.empty())
    {
        a=q.front();
        q.pop();
        for(int i=0;i<G[a].size();i++)
        {
            edge b=edges[G[a][i]];
            if(!b.flag) continue;
            if(dis[a]+b.w<dis[b.to])
            {
                dis[b.to]=dis[a]+b.w;
                q.push(b.to);

            }
        }
    }
  if(ans<dis[n]) ans=dis[n];
}
void BFS()//bfs求两点间的最短路,将路用way数组保存。way[x][0]表示最短路上的边，way[x][1]表示他由那个状态扩展来的。就是他的父亲状态，
//way也就是保存了状态 到下一个状态 的顺序，的那条边的扩展顺序；
{
   priority_queue<node>q;
   node a={1,0};
   int tot=0;
   a.id=tot;//保存自己保存在 way中的下标
   a.idd=0;//保存父亲状态
   q.push(a);
   memset(vis,0,sizeof(vis));
   way[tot][0]=0,way[tot++][1]=-1;
   while(!q.empty())
   {
       a=q.top();
       q.pop();
       if(a.x==n)
       {
           ans=a.sum;
        int xm=a.id;
        while(xm!=-1)
        {
            edges[way[xm][0]].flag=0;
             SPFA1();
             edges[way[xm][0]].flag=1;
             xm=way[xm][1];

        }
           return ;
       }
       for(int i=0;i<G[a.x].size();i++)
       {
           edge b=edges[G[a.x][i]];
           if(vis[b.id]) continue;
           vis[b.id]=1;
           node bb=a;
           bb.x=b.to;
           bb.sum+=b.w;
           bb.id=tot;
           a.idd=tot;
           way[tot][0]=G[a.x][i],way[tot++][1]=a.id;
           q.push(bb);

       }
   }

}


int main()
{
   while(scanf("%d%d",&n,&m)!=EOF)
   { tot=1;
     inint();
       for(int i=1;i<=m;i++)
       {
            int x,y,w;
            scanf("%d %d %d",&x,&y,&w);
            addedge(x,y,w);
       }
       ans=-1;
       BFS();
       printf("%d\n",ans);
   }
}