acdream1415(dij+优先队列+桥)

这题好坑，卡SPFA。。。

无奈只能用dij+优先队列了。 因为好久没有写过代码了，所以今天写dij时候突然觉得复杂度不对，dij+优先队列的复杂度是（n+m）logn，这种复杂度对于稠密图是非常慢！，而且还有超内存的可能（最坏情况要把n*n个点都存进优先队列）,与我以前记得复杂度是nlogn不一样。。。 瞬间吓尿。

其实事实确实是这样，在采用斐波那契堆+dij时，斐波那契堆是插入复杂度为O（1），所以复杂度为nlogn+m,而普通我们用的STL种的priority_queue插入查询复杂度都是logn，所以总的复杂度为(n+m)logn.

所以，dij+优先队列虽然方便好写，但只适用用稀疏图,也就是m小的时候。

最后关于这题的思路，求一次从1开始到其他所有点的最短距离diss[i],再求一次从n开始到其他所有点的最短距离dist[i],然后如果边 <u,v>w 满足diss[u]+w+dist[v]=min（其中min是1到n的最短距离）说明这条边，绝对在一条最短路线中。 这样把所有这样的边找出来，并重新构图，那么只要找出这个图中的桥，并且满足1，n分别在桥的两端。

Important Roads

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

SubmitStatisticNext Problem

Problem Description

      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.

Input

      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

      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.

Sample Input

6 7
1 2 1
2 3 1
2 5 3
1 3 2
3 5 1
2 4 1
5 6 2

Sample Output

2
5 7

Source

Andrew Stankevich Contest 22

Manager

mathlover

#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[2*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+10];//用循环队列怎么样
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,0,sizeof(mark));
    while(pque.size()!=0) pque.pop();

    for(int i=1;i<=n;i++)
        dis[i]=INF;

    dis[s]=0;
    node1 fi;
    fi.id=s;
    fi.w=0;
    pque.push(fi);
    //我就说， 用优先队列优化，对于稠密图基本没意义
    node1 nwnode,cur;
    while(pque.size()!=0)
    {
        cur = pque.top();
        pque.pop();
        if(mark[cur.id]==1) continue;
        int u=cur.id;
        mark[u]=1;
        for(int p=pre[u];p!=-1;p=edge[p].next)
        {
            int v=edge[p].to;
            if(mark[v]==1) 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,0,sizeof(mark));
    for(int i=1;i<=n;i++)
    {
        dis[i]=INF;
    }

    int qf=0,qd=0;
    que[qf]=s;
    qf++;

    dis[s]=0;
    mark[s]=1;

    while(qf!=qd)//作为一个循环队列，
    {
        int cur=que[qd];
        qd=(qd+1)%M;
        mark[cur]=0;
        for(int p=pre[cur];p!=-1;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]==0)
                {
                    que[qf]=v;
                    qf=(qf+1)%M;
                    mark[v]=1;
                }
            }
        }
    }
}


void dfs(int s)
{
    //len[s]==-1表示没来过

    len[s]=index1++;
    int tmp = len[s];
    for(int p=pre[s];p!=-1;p=edge[p].next)
    {
        int v=edge[p].to;
        if( mark[edge[p].id]==1 ) continue;

        if(len[v]==-1)
        {
            mark[edge[p].id]=1;//把这条边标记了
            dfs(v);
            tmp=min(tmp,len[v]);
            if(len[v]>len[s])//这个就是桥
            {
                if(len[n]!=-1)
                {
                    if(len[1]<=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=0;
    memset(pre,-1,sizeof(pre));

    for(int i=1;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,1);
    dij(dist,n);

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

    cnt=0;
    memset(pre,-1,sizeof(pre));

    for(int i=0;i<tcnt;i+=2)
    {
        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,0,sizeof(mark)); //感觉要用来记录边比较好
    memset(len,-1,sizeof(len));
    index1=0;
    ans = 0;

    dfs(1);
     printf("%d
",ans);
     if(ans!=0)
    {
         for(int i=0;i<ans-1;i++)
             printf("%d ",save[i]);
        printf("%d
",save[ans-1]);
    }
    return 0;
}