JZYZOJ1525 HAOI2012道路 堆优化的dijkstra+pair

From Tyvj Guest ☆[haoi2012]道路

	描述 Description
		C国有n座城市，城市之间通过m条单向道路连接。一条路径被称为最短路，当且仅当不存在从它的起点到终点的另外一条路径总长度比它小。两条最短路不同，当且仅当它们包含的道路序列不同。我们需要对每条道路的重要性进行评估，评估方式为计算有多少条不同的最短路经过该道路。现在，这个任务交给了你。

	输入格式 Input Format
		第一行包含两个正整数n、m 接下来m行每行包含三个正整数u、v、w，表示有一条从u到v长度为w的道路

	输出格式 Output Format
		输出应有m行，第i行包含一个数，代表经过第i条道路的最短路的数目对1000000007取模后的结果

样例输入

4 4

1 2 5

2 3 5

3 4 5

1 4 8

样例输出

2

3

2

1

 

最后的代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
#define pa pair<int,int>
const int mymod=1000000007;
const int bign=1000000000;
int n,m;
struct wtff{
    int y;
    int next;
    int zhi;
}wtf[5010];
int head[1510]={};
int tail=0;
long long ans[5010]={};
long long a[5010]={};
long long b[5010]={};
int c[1510]={};
long long dis[1510]={};
bool vis[1510]={};
void init(int x,int y,int zhi){
    wtf[++tail].next=head[x];
    wtf[tail].zhi=zhi;
    wtf[tail].y=y;
    head[x]=tail;
}
void jiuming(int st){
    priority_queue< pa,vector<pa>,greater<pa> >q;
    memset(vis,0,sizeof(vis));
    for(int i=1;i<=n;i++){
        dis[i]=bign;
    }
    dis[st]=0;
    q.push(make_pair(0,st));
    int cn=0;
    while(!q.empty()){
        int x=q.top().second;
        q.pop();
        if(vis[x]){
            continue;
        }
        vis[x]=1;
        c[++cn]=x;
        for(int i=head[x];i!=0;i=wtf[i].next){
            int y;
            y=wtf[i].y;
            if(dis[x]+wtf[i].zhi<dis[y]){
                dis[y]=dis[x]+wtf[i].zhi;
                q.push(make_pair(dis[y],y));
            }
        }
    }
    memset(a,0,sizeof(a));
    memset(b,0,sizeof(b));
    a[st]=1;
    for(int i=1;i<=cn;i++){
        b[c[i]]=1;
    }
    for(int i=1;i<=cn;i++){
        for(int w=head[c[i]];w!=0;w=wtf[w].next){
            int y=wtf[w].y;
            if(dis[c[i]]+wtf[w].zhi==dis[y]){
                a[y]+=a[c[i]];
                if(a[y]>mymod){
                    a[y]%=mymod;
                }
            }
        }
    }
    for(int i=cn;i>=1;i--){
        for(int w=head[c[i]];w!=0;w=wtf[w].next){
            int y=wtf[w].y;
            if(dis[c[i]]+wtf[w].zhi==dis[y]){
                b[c[i]]+=b[y];
                if(b[c[i]]>mymod){
                    b[c[i]]%=mymod;
                }
            }
        }
    }
    for(int i=1;i<=n;i++){
        for(int w=head[i];w!=0;w=wtf[w].next){
            int y=wtf[w].y;
            if(dis[i]+wtf[w].zhi==dis[y]){
                ans[w]+=(a[i]*b[y]);
                if(ans[w]>mymod){
                    ans[w]%=mymod;
                }
            }
        }
    }
}
int main(){
    cin>>n>>m;
    for(int i=1;i<=m;i++){
        int a1,b1,c1;
        cin>>a1>>b1>>c1;
        init(a1,b1,c1);
    }
    for(int i=1;i<=n;i++){
        jiuming(i);
    }
    for(int i=1;i<=m;i++){
        cout<<ans[i]<<endl;
    }
    return 0;
}

http://www.cnblogs.com/zyfzyf/p/3995257.html

完全没有进展，迪杰斯特拉部分的堆之类的大部分看不懂，加油啃。。。

几乎是抄着代码过的,还要自己再写一遍.....

 

大概算是理解时候的备注

c指代经过其他点得到最短路的点

 

dijkstra算法可以在算出最短路的同时将点的源点的距离排序，然后按照这个

从前往后枚举在最短路上的边可以得到源点到每个点的最短路的数目，记为a[i]

从后往前枚举在最短路上的边可以得到经过每个点有多少条最短路，记为b[i] 

然后对于每条边就是 +=a[e[i].from]*b[e[i].go]

↑大神的方法...

 

 

用小根堆写迪杰斯特拉来记录c...我觉得我永远想不出来这么神奇的方法QAQ

最后的三个出答案的循环太难写+难理解了,垃圾如我:D

磕磕绊绊最后还是码出来了;

大概学到了一些小知识?

pair相当于把两个数据整合成一个数据,就像结构体一样,第一个是first,第二个是second;

定义→pair <数据类型,数据类型> 变量名;

http://blog.csdn.net/hiwoshixiaoyu/article/details/53894162

具体↑

greater<>里面可以用pair,比较的是第一个数据,如果第一个数据一样就比较第二个;

其他大概是加深了对邻接表的理解????