k短路

无聊整理一下

 1 #include<bits/stdc++.h>
 2 #define clr(a,x) memset(a,x,sizeof(a))
 3 #define rep(i,l,r) for(int i=l;i<r;i++)
 4 typedef long long ll;
 5 using namespace std;
 6 int read()
 7 {
 8     char c=getchar();
 9     int ans=0,f=1;
10     while(!isdigit(c)){
11         if(c==‘-‘) f=-1;
12         c=getchar();
13     }
14     while(isdigit(c)){
15         ans=ans*10+c-‘0‘;
16         c=getchar();
17     }
18     return ans*f;
19 }
20 struct edge{
21     int d,to;
22 };
23 struct node{
24     int num,d;
25     inline bool operator <(const node&A)const{
26         return d>A.d;
27     }
28 };
29 const int maxn=1009,inf=0x3fffffff;
30 int n,m,k,d[maxn];
31 priority_queue<node>Q;
32 vector<edge>e[maxn];
33 vector<edge>e1[maxn];
34 void dijkstra()
35 {
36     rep(i,i,n+1) d[i]=inf;
37     d[1]=0;
38     node start;
39     start.num=1,start.d=0;
40     Q.push(start);
41     while(!Q.empty()){
42         node now=Q.top();
43         Q.pop();
44         if(now.d==d[now.num]){
45             rep(i,0,e1[now.num].size()){
46                 if(d[now.num]+e1[now.num][i].d<d[e1[now.num][i].to]){
47                     d[e1[now.num][i].to]=d[now.num]+e1[now.num][i].d;
48                     node next;
49                     next.num=e1[now.num][i].to;
50                     next.d=d[e1[now.num][i].to];
51                     Q.push(next);
52                 }
53             }
54         }
55     }
56 }
57 void work()
58 {
59     int cnt=0;
60     while(!Q.empty()) Q.pop();
61     node start;
62     start.num=n,start.d=d[n];
63     Q.push(start);
64     while(cnt<k&&!Q.empty()){
65         node now=Q.top();
66         Q.pop();
67         if(now.num==1){
68             ++cnt;
69             printf("%d\n",now.d);
70         }else{
71             rep(i,0,e[now.num].size()){
72                 node next;
73                 next.num=e[now.num][i].to;
74                 next.d=now.d-d[now.num]+e[now.num][i].d+d[e[now.num][i].to];
75                 Q.push(next);
76             }
77         }
78     }
79     if(cnt<k) printf("-1\n");
80 }
81 int main()
82 {
83     n=read(),m=read(),k=read();
84     rep(i,0,m){
85         edge ed;
86         int from=read();
87         ed.to=read(),ed.d=read();
88         e[from].push_back(ed);
89         swap(ed.to,from);
90         e1[from].push_back(ed);
91     }
92     dijkstra();
93     work();
94     return 0;
95 }

跑步 【STSR】Round #3

描述

有一个人,他在一座山上,他准备用从顶峰跑到山脚的方法来锻炼,而且只沿着下坡的路跑到山脚。山一共有M条路,每条路连接两个用1..N标号的地点,如果X>Y,则地点X大于地点Y的高度。但是因为他比较懒,所以他想跑最短的路径。但是很快他厌倦了一直走同一条路,

所以他想找出K条不同的路径并使得这K条路为最短的K条路径。

输入格式

第1行:三个数:N,M,K

第2..M+1行:每一行包含三个数x,y,d,表示有一条从x到y的路,路径长度为d,保证x>y

输出格式

第1..K行:第i行包含第i短路的长度(如果存在的话)。如果不存在第i短路的长度则输出-1

注意只输出一行-1。比如样例中没有第7和第8短路我们只输出一行-1 。

样例输入

5 8 8

5 4 1

5 3 1

5 2 1

5 1 1

4 3 4

3 1 1

3 2 1

2 1 1

样例输出

1

2

2

3

6

7

-1

数据范围与约定

  • 对于30%的数据:0<=n<=100,0<=m<=10000,0<=k<=100
  • 对于100%的数据:0<=n<=1000,0<=m<=10000,0<=k<=100
时间: 2024-08-24 23:26:05

k短路的相关文章

图论(A*算法,K短路) :POJ 2449 Remmarguts&#39; Date

Remmarguts' Date Time Limit: 4000MS   Memory Limit: 65536K Total Submissions: 25216   Accepted: 6882 Description "Good man never makes girls wait or breaks an appointment!" said the mandarin duck father. Softly touching his little ducks' head, h

poj2449:第k短路问题

Description "Good man never makes girls wait or breaks an appointment!" said the mandarin duck father. Softly touching his little ducks' head, he told them a story. "Prince Remmarguts lives in his kingdom UDF – United Delta of Freedom. One

图的第k短路

[问题描述] 给你一个有向图,求从1到n的第k短路. [解法] SPFA+A*搜索. 1 A*算法 A*算法在人工智能中是一种典型的启发式搜索算法,启发中的估价是用估价函数表示的: h(n)=f(n)+g(n) 其中f(n)是节点n的估价函数,g(n)表示实际状态空间中从初始节点到n节点的实际代价,h(n)是从n到目标节点最佳路径的估计代价.另外定义h'(n)为n到目标节点最佳路径的实际值.如果h'(n)≥h(n)则如果存在从初始状态走到目标状态的最小代价的解,那么用该估价函数搜索的算法就叫A*

POJ 2499 A*求第K短路

DES就是给你一个图.然后给你起点和终点.问你从起点到终点的第K短路. 第一次接触A*算法. // 大概懂思路了.A*算法需要的估价函数里的两个函数.一个是起点到当前点的消耗. //一个是当前点到目标点的估测消耗.所以需要用Dijstra或者Spfa求出目标点到所有点的最短路. //然后就可以用A*算法来求了. // 确实.学了位运算.链式表. #include<cstdio> #include<iostream> #include<queue> #include<

poj2449 Remmarguts&#39; Date,第K短路

点击打开链接 SPFA  + A* #include <cstdio> #include <queue> #include <cstring> #include <algorithm> using namespace std; struct node { int v, dis, f, next; friend bool operator <(node a, node b){ return a.f>b.f; } }; const int INF =

poj 2449 Remmarguts&#39; Date k短路

/*poj 2449 k短路 A* 估价函数是 s到i的距离+i到t的距离 */ #include<cstdio> #include<queue> #include<vector> #define inf 1e7 #define maxn 100010 using namespace std; int n,m,S,T,K,num1,num2,head1[maxn],head2[maxn],dis[maxn]; int q[maxn],hea,tai,f[maxn],cn

POJ 2449Remmarguts&#39; Date K短路模板 A*+SPFA

太水了我不想说了,模板在这里 14312K 313MS 1 #include<queue> 2 #include<cstdio> 3 #include<cstring> 4 #include<algorithm> 5 using namespace std; 6 int v[100010],v2[100010],c[100010],c2[100010],s,t,k,duin; 7 int n,m,point[1010],next[100010],cnt=0,

POJ 2449(求k短路,A*)

题目:求s到t的第k短路. 思路:网上是清一色的A*算法,所以学习了一下.所谓Astar算法其实就是启发式的bfs.这里设置了一个估价函数h,结合当前位置的最短路和到终点的估计最短路长度来选择下一个要扩展的节点(dijkstra算法对于所有的点的h值可以视为是一样的,所以下一个扩展的节点只与当前的最短路g有关).这个h的值越接近手记最短路越好,但是不能少于实际最短路(否则会错误),假设h值就是实际最短路的值,那么这个Astar算法可以一次找到最短路,相对的,如果h比实际值稍大,那么仍然可以去掉很

【k短路&amp;A*算法】BZOJ1975: [Sdoi2010]魔法猪学院

Description 找出1~k短路的长度. Solution k短路的求解要用到A*算法 A*算法的启发式函数f(n)=g(n)+h(n) g(n)是状态空间中搜索到n所花的实际代价 h(n)是n到结束状态最佳路径的估计代价 关于h(n)的选取,当h(n)<实际代价时,搜索慢但可出解:h(n)=实际代价时,正确率与效率最高:h(n)>实际代价,快但只能得到近似解. 但在k短路问题中,h(n)是可以选到准确值的,就是n到结束节点的最短路,预处理时从结束节点做一次单源最短路即可. 按广搜的方式

再探第k短路

其实这是一个很古老的姿势啦- 只不过今天跟同学讨论A*算法求k短路的时候,同学不信A*算法能被卡掉. 于是我翻了翻课件找出了一种n元环的特殊情况,卡掉了A*算法. A*算法是只有到达终点的时候才能统计答案,这导致可能拓展很多个状态才能得到一个用来更新答案的有效状态. 例如一个n元环,当我们到达终点之后,可能还要拓展n次才能得到下一个状态.于是若求k短路时间复杂度就为O(nk).于是就容易被卡掉. 我们考虑换一种方式来定义一条从起点s到终点t的路径. 构建出以t为终点的最短路树,t是这棵树的根,对