Special JudgeTime Limit: 20000/10000MS (Java/Others)Memory Limit: 128000/64000KB (Java/Others)

SubmitStatisticNext Problem

The city where Georgie lives has n junctions some of which are connected by bidirectional roads.
      Every day Georgie drives from his home to work and back. But the roads in the city where Georgie lives are very bad, so they are very often closed for repair. Georgie noticed that when some roads are closed he still can get from home to work in the same time as if all roads were available.

But there are such roads that if they are closed for repair the time Georgie needs to get from home to work increases, and sometimes Georgie even cannot get to work by a car any more. Georgie calls such roads important.
      Help Georgie to find all important roads in the city.

The first line of the input file contains n and m — the number of junctions and roads in the city where Georgie lives, respectively (2 ≤ n ≤ 20 000, 1 ≤ m ≤ 100 000). Georgie lives at the junction 1 and works at the junction n.

The following m lines contain information about roads. Each road is specified by the junctions it connects and the time Georgie needs to drive along it. The time to drive along the road is positive and doesn’t exceed 100 000. There can be several roads between a pair of junctions, but no road connects a junction to itself. It is guaranteed that if all roads are available, Georgie can get from home to work.

      Output l — the number of important roads — at the first line of the output file. The second line must contain l numbers, the numbers of important roads. Roads are numbered from 1 to m as they are given in the input file.

6 7

1 2 1

2 3 1

2 5 3

1 3 2

3 5 1

2 4 1

5 6 2

2

5 7

Andrew Stankevich Contest 22

 #include <iostream>

 #include <stdio.h>

 #include <string.h>

 #include <string>

 #include <algorithm>

 #include <stdlib.h>

 #include <queue>

 using namespace std;

 #define M 100100

 #define N 20020

 #define INF 0x3fffffffff

 int n,m;

 struct node

 {

     int from,to,next,w,id;

 }edge[*M];

 struct node1

 {

     long long w;

     int id;

     bool operator < (const node1 t)const

     {

         return t.w<w;

     }

 };

 int pre[N],cnt;

 long long int diss[N],dist[N];

 int que[M+];//用循环队列怎么样

 int ans,save[M];

 //然后就是找桥了

 priority_queue<node1> pque;

 int len[N],mark[M];

 int index1;

 void add_edge(int u,int v,int w,int id)

 {

     edge[cnt].from=u;

     edge[cnt].to=v;

     edge[cnt].w=w;

     edge[cnt].id=id;

     edge[cnt].next=pre[u];

     pre[u]=cnt++;

 }

 void dij(long long int dis[N],int s)

 {

     memset(mark,,sizeof(mark));

     while(pque.size()!=) pque.pop();

     for(int i=;i<=n;i++)

         dis[i]=INF;

     dis[s]=;

     node1 fi;

     fi.id=s;

     fi.w=;

     pque.push(fi);

     //我就说， 用优先队列优化，对于稠密图基本没意义

     node1 nwnode,cur;

     while(pque.size()!=)

     {

         cur = pque.top();

         pque.pop();

         if(mark[cur.id]==) continue;

         int u=cur.id;

         mark[u]=;

         for(int p=pre[u];p!=-;p=edge[p].next)

         {

             int v=edge[p].to;

             if(mark[v]==) continue;

             if(dis[v]>cur.w+edge[p].w)

             {

                 dis[v]=cur.w+edge[p].w;

                 nwnode.id=v;

                 nwnode.w=dis[v];

                 pque.push(nwnode);

             }

         }

     }

 }

 void spfa(long long int dis[N],int s,int t)

 {

     //SPFA都忘记怎么写了

     memset(mark,,sizeof(mark));

     for(int i=;i<=n;i++)

     {

         dis[i]=INF;

     }

     int qf=,qd=;

     que[qf]=s;

     qf++;

     dis[s]=;

     mark[s]=;

     while(qf!=qd)//作为一个循环队列，

     {

         int cur=que[qd];

         qd=(qd+)%M;

         mark[cur]=;

         for(int p=pre[cur];p!=-;p=edge[p].next)

         {

             int v = edge[p].to;

             if( dis[v]>dis[cur] + edge[p].w )

             {

                 dis[v]=dis[cur]+edge[p].w;

                 if(mark[v]==)

                 {

                     que[qf]=v;

                     qf=(qf+)%M;

                     mark[v]=;

                 }

             }

         }

     }

 }

 void dfs(int s)

 {

     //len[s]==-1表示没来过

     len[s]=index1++;

     int tmp = len[s];

     for(int p=pre[s];p!=-;p=edge[p].next)

     {

         int v=edge[p].to;

         if( mark[edge[p].id]== ) continue;

         if(len[v]==-)

         {

             mark[edge[p].id]=;//把这条边标记了

             dfs(v);

             tmp=min(tmp,len[v]);

             if(len[v]>len[s])//这个就是桥

             {

                 if(len[n]!=-)

                 {

                     if(len[]<=len[s]&&len[n]>=len[v])

                     {

                         save[ans++]=edge[p].id;

                     }

                 }

             }

         }//无向图的桥怎么求。。。，忘光了。

         else

         {

             tmp=min(tmp,len[v]);

         }

     }

     len[s]=tmp;

 }

 int main()

 {

     scanf("%d%d",&n,&m);

     cnt=;

     memset(pre,-,sizeof(pre));

     for(int i=;i<=m;i++)

     {

         int x,y,w;

         scanf("%d%d%d",&x,&y,&w);

         add_edge(x,y,w,i);

         add_edge(y,x,w,i);

     }

     //卡SPFA???

     //去你妹的

     //spfa(diss,1,n);

     //spfa(dist,n,1);

     dij(diss,);

     dij(dist,n);

     long long int mi=diss[n]; //最短距离

     int tcnt = cnt;

     cnt=;

     memset(pre,-,sizeof(pre));

     for(int i=;i<tcnt;i+=)

     {

         int x,y,w,id;

         x=edge[i].from;

         y=edge[i].to;

         w=edge[i].w;

         id=edge[i].id;

         if( diss[x]+dist[y]+w ==mi || dist[x] + diss[y]+w==mi )

         {

             add_edge(x,y,w,id);

             add_edge(y,x,w,id);

         }

     }

     //构建了一个由所有可能最短路边构成的图

     memset(mark,,sizeof(mark)); //感觉要用来记录边比较好

     memset(len,-,sizeof(len));

     index1=;

     ans = ;

     dfs();

      printf("%d\n",ans);

      if(ans!=)

     {

          for(int i=;i<ans-;i++)

              printf("%d ",save[i]);

         printf("%d\n",save[ans-]);

     }

     return ;

 }