最短路与次短路计数

poj  3464  http://poj.org/problem?id=3463

问最短路的条数+比最短路权值大 1  的条数

做法  比较一下次短路和最短路的值  若次短路恰好比最短路大1,答案为最短路+次短路条数,否则答案就是最短路条数

 1 #include<cstdio>
 2 const int inf=0x3f3f3f3f;
 3 class Count_short_path { ///最短路与次短路计数Dijkstra_o(MV^2)
 4     typedef int typec;///边权的类型
 5     static const int ME=1e4+10;///边的个数
 6     static const int MV=1e3+10;///点的个数
 7     struct E {
 8         int v,next;
 9         typec w;
10     } e[ME];
11     int n,le,head[MV],cnt[MV][2],i,j,k,u,v,tmp,flag;
12     typec dist[MV][2],w;
13     bool used[MV][2];
14 public:
15     void init(int tn) { ///传入点的个数
16         n=tn;
17         le=0;
18         for(i=0; i<=n; i++) head[i]=-1;
19     }
20     void add(int u,int v,typec w) {
21         e[le].v=v;
22         e[le].w=w;
23         e[le].next=head[u];
24         head[u]=le++;
25     }
26     void solve(int s) { ///传入起点
27         for(i=0; i<=n; i++) {
28             for(j=0; j<2; j++) {
29                 cnt[i][j]=0;
30                 dist[i][j]=inf;
31                 used[i][j]=false;
32             }
33         }
34         dist[s][0]=0;
35         cnt[s][0]=1;
36         for(k=1; k<n*2; k++) {
37             tmp=inf;
38             for(j=0; j<=n; j++) {
39                 if(!used[j][0]&&tmp>dist[j][0]) {
40                     u=j;
41                     flag=0;
42                     tmp=dist[j][0];
43                 } else if(!used[j][1]&&tmp>dist[j][1]) {
44                     u=j;
45                     flag=1;
46                     tmp=dist[j][1];
47                 }
48             }
49             if(tmp==inf) break;
50             used[u][flag]=1;
51             for(i=head[u]; ~i; i=e[i].next) {
52                 v=e[i].v;
53                 w=e[i].w;
54                 if(tmp+w<dist[v][0]) {
55                     dist[v][1]=dist[v][0];
56                     cnt[v][1]=cnt[v][0];
57                     dist[v][0]=tmp+w;
58                     cnt[v][0]=cnt[u][flag];
59                 }
60                 else if(tmp+w==dist[v][0]) {
61                     cnt[v][0]+=cnt[u][flag];
62                 }
63                 else if(tmp+w<dist[v][1]) {
64                     dist[v][1]=tmp+w;
65                     cnt[v][1]=cnt[u][flag];
66                 }
67                 else if(tmp+w==dist[v][1]) {
68                     cnt[v][1]+=cnt[u][flag];
69                 }
70             }
71         }
72     }
73     typec getdist(int id,int flag) {///flag==0返回最短路,1返回次短路
74         return dist[id][flag];
75     }
76     int getcnt(int id,int flag) { ///返回路的个数
77         return cnt[id][flag];
78     }
79 } g;
80 int main(){
81     int t,n,m,u,v,w;
82     while(~scanf("%d",&t)){
83         while(t--){
84             scanf("%d%d",&n,&m);
85             g.init(n);
86             while(m--){
87                 scanf("%d%d%d",&u,&v,&w);
88                 g.add(u,v,w);
89             }
90             scanf("%d%d",&u,&v);
91             g.solve(u);
92             int ans=g.getcnt(v,0);
93             if(g.getdist(v,0)==g.getdist(v,1)-1) ans+=g.getcnt(v,1);
94             printf("%d\n",ans);
95         }
96     }
97     return 0;
98 }

hdu  http://acm.hdu.edu.cn/showproblem.php?pid=3191

 1 #include<cstdio>
 2 #include<queue>
 3 using namespace std;
 4 const int inf=0x3f3f3f3f;
 5 class Count_short_path { ///最短路与次短路计数Dijkstra_o(MV^2)
 6     typedef int typec;///边权的类型
 7     static const int ME=1e6+10;///边的个数
 8     static const int MV=1e3+10;///点的个数
 9     struct E {
10         int v,next;
11         typec w;
12     } e[ME];
13     int n,le,head[MV],cnt[MV][2],i,j,k,u,v,tmp,flag;
14     typec dist[MV][2],w;
15     bool used[MV][2];
16 public:
17     void init(int tn) { ///传入点的个数
18         n=tn;
19         le=0;
20         for(i=0; i<=n; i++) head[i]=-1;
21     }
22     void add(int u,int v,typec w) {
23         e[le].v=v;
24         e[le].w=w;
25         e[le].next=head[u];
26         head[u]=le++;
27     }
28     void solve(int s) { ///传入起点
29         for(i=0; i<=n; i++) {
30             for(j=0; j<2; j++) {
31                 cnt[i][j]=0;
32                 dist[i][j]=inf;
33                 used[i][j]=false;
34             }
35         }
36         dist[s][0]=0;
37         cnt[s][0]=1;
38         for(k=1; k<n*2; k++) {
39             tmp=inf;
40             for(j=0; j<=n; j++) {
41                 if(!used[j][0]&&tmp>dist[j][0]) {
42                     u=j;
43                     flag=0;
44                     tmp=dist[j][0];
45                 } else if(!used[j][1]&&tmp>dist[j][1]) {
46                     u=j;
47                     flag=1;
48                     tmp=dist[j][1];
49                 }
50             }
51             if(tmp==inf) break;
52             used[u][flag]=1;
53             for(i=head[u]; ~i; i=e[i].next) {
54                 v=e[i].v;
55                 w=e[i].w;
56                 if(tmp+w<dist[v][0]) {
57                     dist[v][1]=dist[v][0];
58                     cnt[v][1]=cnt[v][0];
59                     dist[v][0]=tmp+w;
60                     cnt[v][0]=cnt[u][flag];
61                 }
62                 else if(tmp+w==dist[v][0]) {
63                     cnt[v][0]+=cnt[u][flag];
64                 }
65                 else if(tmp+w<dist[v][1]) {
66                     dist[v][1]=tmp+w;
67                     cnt[v][1]=cnt[u][flag];
68                 }
69                 else if(tmp+w==dist[v][1]) {
70                     cnt[v][1]+=cnt[u][flag];
71                 }
72             }
73         }
74     }
75     typec getdist(int id,int flag) {///flag==0返回最短路,1返回次短路
76         return dist[id][flag];
77     }
78     int getcnt(int id,int flag) { ///返回路的个数
79         return cnt[id][flag];
80     }
81 } g;
82 int main() {
83     int n,m,s,e,u,v,w;
84     while(~scanf("%d%d%d%d",&n,&m,&s,&e)) {
85         g.init(n);
86         while(m--) {
87             scanf("%d%d%d",&u,&v,&w);
88             g.add(u,v,w);
89         }
90         g.solve(s);
91         printf("%d %d\n",g.getdist(e,1),g.getcnt(e,1));
92     }
93     return 0;
94 }

时间: 2024-12-13 10:15:38

最短路与次短路计数的相关文章

poj 3463 Sightseeing (dij 求最短路和次短路并计数)

dijkstra求最短路和次短路的求法和计算  模板 dijkstra求最短路的变形. 外循环要循环2*n-1次,因为dis[n][2]有2*n个状态,而dis[s][0]已经用过一次. 算法: 1.如果比最短路短就更新最短路和次短路. 2.如果和最短路相等,更新最短路的计数. 3.如果和次短路相等,更新次短路的方法数. 4.如果比次短路短,更新次短路. #include<cstdio> #include<iostream> #include<cstring> #inc

最短路和次短路问题,dijkstra算法

1 /* 2  *题目大意: 3  *在一个有向图中,求从s到t两个点之间的最短路和比最短路长1的次短路的条数之和; 4  * 5  *算法思想: 6  *用A*求第K短路,目测会超时,直接在dijkstra算法上求次短路; 7  *将dist数组开成二维的,即dist[v][2],第二维分别用于记录最短路和次短路; 8  *再用一个cnt二维数组分别记录最短路和次短路的条数; 9  *每次更新路径的条数时,不能直接加1,,应该加上cnt[u][k],k为次短路径或者最短路径的标记; 10  *

UESTC30-最短路-Floyd最短路、spfa+链式前向星建图

最短路 Time Limit: 3000/1000MS (Java/Others) Memory Limit: 65535/65535KB (Java/Others) 在每年的校赛里,所有进入决赛的同学都会获得一件很漂亮的T-shirt.但是每当我们的工作人员把上百件的衣服从商店运回到赛场的时候,却是非常累的!所以现在他们想要寻找最短的从商店到赛场的路线,你可以帮助他们吗? Input 输入包括多组数据. 每组数据第一行是两个整数NN ,MM (N≤100N≤100 ,M≤10000M≤1000

hdu1688(dijkstra求最短路和次短路)

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=1688 题意:第k短路,这里要求的是第1短路(即最短路),第2短路(即次短路),以及路径条数,最后如果最短路和次短路长度差1,则输出两种路径条数之和,否则只输出最短路条数. 思路:dijkstra变形,注意状态的转移,代码上附了注释,就不多说了.. 代码: 1 #include <bits/stdc++.h> 2 #define MAXN 1010 3 using namespace std; 4

hdu 1688 Sightseeing【最短路,次短路条数】

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=1688 题意:求最短路和次短路条数如果次短路长度=最短路长度+1 这输出次短路条数+最短路条数,否则输出最短路条数 分析:这是到模版题,献上模版: #include<stdio.h> #include<string.h> #include<algorithm> #include<iostream> #include<queue> #include<

次短路 + 第K短路 模版

虽然从字面上看,次短路和第2短路是一样的.但是我在题目中遇到的却不是这样的. 在有些题目中,需要判断次短路是否存在.比如说,u.v之间只有一条路径.那么只有最短路.次短路是不存在的.这时候,解题方法是先求出最短路,然后枚举删除最短路径中的边,然后求最小值.题目可以看poj3986. 第K短路的实现是 SPFA + A* 算法. A*算法通过一个估价函数f(h)来估计途中的当前点p到终点的距离,并由此决定它的搜索方向,当这条路径失败时,它会尝试其他路径.对于A*,估价函数 = 当前值 + 当前位置

poj3463 Sightseeing --- dij最短路和次短路

最短路好题啊. 题目给定起点和终点,要求最短路和次短路(要求次短路只比最短路大1)的道路数量. 重点在于次短路如何处理是最高效的呢 这就要求对dij算法路径更新的理解了. 我们用一个数组记录最短路,一个数组记录次短路. 每次对当前最短边,先更新最短路,更新不了最短路再更新次短路. 每条边处理两次,这样就可以在2n×n的复杂度内求得最短路和次短路了. #include<cstdio> #include<cstring> #include<queue> #include&l

最短路与次短路

1.poj3255  求次短路 思路:遍历每条边<u, v>, 看begin[u] + dis<u, v> + end[v] 是否为次短路 //求次短路 #include <cstdio> #include <cstring> #include <iostream> #include <algorithm> #include <vector> #include <cmath> #include <queu

poj3463 最短路和次短路

这道题就是让你求出有向图中最短路和比最短路长1的路的数量, 我们求出次短路和最短路的数量即可解决这道题 /* 求s到t的最短路与次短路(这里要求只比最短路多1)的条数之和 联想到最小,次小的一种更新关系: if(x<最小)更新最小,次小 else if(==最小)更新方法数 else if(x<次小)更新次小 else if(x==次小)更新方法数 同时记录s到u最短,次短路及方法数 用一个堆每次取最小的,更新完后再入堆 还是那个原理,第一次遇到的就是最优的,然后vi标记为真 方法数注意是加法