最短路练习题

最新推荐文章于 2022-10-22 23:54:12 发布
最新推荐文章于 2022-10-22 23:54:12 发布
阅读量144 收藏
点赞数
分类专栏： # 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/roadtohacker/article/details/117000368
版权

目录

Til the Cows Come Home

  • 模板题，注意输入顺序是先 t t t后 n n n
#include <iostream>
#include <queue>
#include <cstring>
using namespace std;
const int MAXN = 1005;
struct st{
	int ID;
	int val;
	friend bool operator<(st x, st y){
		return x.val > y.val;
	}
};
struct Edge{
	int next;
	int to;
	int val;
}edge[200000];
int cnt;
int head[MAXN];
int vis[MAXN];
int dis[MAXN];
void Add_Edge(int u, int v, int w){
	edge[cnt].next = head[u];
	edge[cnt].to = v;
	edge[cnt].val = w;
	head[u] = cnt++;	
}
void dijstra(int s){
	priority_queue<st> q;
	st now;
	now.ID = s;
	dis[s] = 0;
	now.val = dis[s];
	q.push(now);
	while(!q.empty()){
		st u = q.top();
		q.pop();
		if(vis[u.ID]) continue;
		vis[u.ID] = 1;
		for(int i=head[u.ID];i!=-1;i=edge[i].next){
			if(dis[u.ID] + edge[i].val < dis[edge[i].to] && !vis[edge[i].to]){
				dis[edge[i].to] = dis[u.ID] + edge[i].val;
				now.ID = edge[i].to;
				now.val = dis[edge[i].to];
				q.push(now);
			}
		}
	}
}
int main(){
	int t, n, u, v, w;
	cin >> t >> n;
	memset(dis, 0x3f, sizeof dis);
	memset(head, -1, sizeof head);	
	for(int i=0;i<t;i++){
		cin >> u >> v >> w; 
		Add_Edge(u, v, w);
		Add_Edge(v, u, w);
	}
	dijstra(1);
	cout << dis[n];
	return 0;
}

Frogger

  • 题意：有两只青蛙，分别在一号和二号位置，现在一号青蛙想到二号青蛙的位置上去，借助其他位置，问到达二号位置的过程中每次跳跃的最短跳跃距离
  • 数据范围比较小，求出所有石头两两之间距离，更改 d i j s t r a dijstra dijstra算法的判断条件为取当前最短距离和需要跳跃的距离之间的最大值
#include <iostream>
#include <queue>
#include <cstring>
#include <cstdio>
#include <cmath>
using namespace std;
const int MAXN = 1005;
struct st{
	int ID;
	double val;
	friend bool operator<(st x, st y){
		return x.val > y.val;
	}
};
struct Edge{
	int next;
	int to;
	double val;
}edge[200000];
struct NODE{
	int x, y;
}node[MAXN];
int cnt;
int head[MAXN];
int vis[MAXN];
double dis[MAXN];
void Add_Edge(int u, int v, double w){
	edge[cnt].next = head[u];
	edge[cnt].to = v;
	edge[cnt].val = w;
	head[u] = cnt++;	
}
void dijstra(int s){
	priority_queue<st> q;
	st now;
	now.ID = s;
	dis[s] = 0;
	now.val = dis[s];
	q.push(now);
	while(!q.empty()){
		st u = q.top();
		q.pop();
		if(vis[u.ID]) continue;
		vis[u.ID] = 1;
		for(int i=head[u.ID];i!=-1;i=edge[i].next){
			if(max(dis[u.ID], edge[i].val) < dis[edge[i].to] && !vis[edge[i].to]){
				dis[edge[i].to] = max(dis[u.ID], edge[i].val);
				now.ID = edge[i].to;
				now.val = dis[edge[i].to];
				q.push(now);
			}
		}
	}
}
int main(){
	int t, n, u, v, x, y;
	double w;
	int num = 1;
	while(cin >> n && n){
		for(int i=1;i<=n;i++) dis[i] = 999999999.0;
		memset(head, -1, sizeof head);
		memset(vis, 0, sizeof vis);
		for(int i=1;i<=n;i++){
			cin >> x >> y;
			node[i].x = x;
			node[i].y = y;
		}
		for(int i=1;i<=n;i++){
			for(int j=1;j<=n;j++){
				Add_Edge(i, j, sqrt((node[i].x - node[j].x) * (node[i].x - node[j].x) + (node[i].y - node[j].y) * (node[i].y - node[j].y)));
				Add_Edge(j, i, sqrt((node[i].x - node[j].x) * (node[i].x - node[j].x) + (node[i].y - node[j].y) * (node[i].y - node[j].y)));
			}
		}
		dijstra(1);
		printf("Scenario #%d\n", num++);
		printf("Frog Distance = %.3f\n\n", dis[2]);
	}
	return 0;
}

Heavy Transportation

  • 给出每条路的最大允许载重量，要求从位置 1 1 1到位置 n n n所经过的路径中最大的允许重量，如果1到2最大载重量为3,2到3最大载重量为5，1到3最大载重量为4，那么因为有两条路径能够到达位置n，所以经过2的路径最多只能载重3；而直接到3的最大载重量为4，综合这两条路径，所以总的最大载重量为4
  • 同样是最短路的变形问题，在每一个点扩展的过程中每次找从起点到当前点载重量的最小值，这是这个点的最大载重量，最后需要取整体最大的载重量，优先级应为从大到小
#include <iostream>
#include <queue>
#include <cstring>
#include <cmath>
#include <cstdio>
using namespace std;
const int MAXN = 1e3 + 100;
struct st{
    int ID;
    int val;
    bool operator<(st x)const {
        return val < x.val;
    }
};
struct Edge{
    int next;
    int to;
    int val;
}edge[200000];
int head[MAXN];
int vis[MAXN];
int dis[MAXN];
int cnt;
void Add_Edge(int u, int v, int w){
    edge[cnt].to = v;
    edge[cnt].next = head[u];
    edge[cnt].val = w;
    head[u] = cnt++;
}
void dijstra(int s){
    priority_queue<st> q;
    st now;
    dis[s] = 0x3f3f3f3f;
    now.ID = s;
    now.val = dis[s];
    q.push(now);
    while(!q.empty()){
        st u = q.top();
        q.pop();
        if(vis[u.ID]) continue;
        vis[u.ID] = 1;
        for(int i=head[u.ID];i != -1;i = edge[i].next){
            if(!vis[edge[i].to] && min(dis[u.ID], edge[i].val) > dis[edge[i].to]){
                dis[edge[i].to] = min(dis[u.ID], edge[i].val);
                now.ID = edge[i].to;
                now.val = dis[edge[i].to];
                q.push(now);
            }
        }
    }
}
int main(){
    int t, n, m, u, v, w;
    scanf("%d", &t);
    for(int j=1;j<=t;j++){
        memset(head, -1, sizeof head);
        memset(vis, 0, sizeof vis);
        memset(dis, -0x3f, sizeof dis);
        cnt = 0;
        scanf("%d%d", &n, &m);
        for(int i=0;i<m;i++){
            scanf("%d%d%d", &u, &v, &w);
            Add_Edge(u, v, w);
            Add_Edge(v, u, w);
        }
        dijstra(1);
        printf("Scenario #%d:\n", j);
        printf("%d\n\n", dis[n]);
    }
    return 0;
}

Silver Cow Party

  • 有 n n n头奶牛，分别在 1 − n 1-n 1−n号农场，现在在 X X X号农场要开一个晚会，道路是有向的，问这些奶牛到达农场再回来要经过的最短路
  • 数组开小一些防止 m e m s e t memset memset时间过慢，直接跑 n n n次最短路，最后分别求奶牛的最短路取最大值即可
#include <iostream>
#include <cstdio>
#include <map>
#include <algorithm>
#include <queue>
#include <cstring>
using namespace std;
const int MAXN = 1e3 + 100;
struct st{
	int ID;
	int val;
	bool operator<(st x)const {
		return val > x.val;
	}
};
struct Edge{
	int next;
	int to;
	int val;
}edge[200000];
int head[MAXN];
int vis[MAXN];
int dis[MAXN];
int cnt;
void Add_Edge(int u, int v, int w){
	edge[cnt].next = head[u];
	edge[cnt].to = v;
	edge[cnt].val = w;
	head[u] = cnt++;
}
map<int, int> mp;
void dijstra(int s){
	priority_queue<st> q;
	st now;
	dis[s] = 0;
	now.ID = s;
	now.val = dis[s];
	q.push(now);
	while(!q.empty()){
		st u = q.top();
		q.pop();
		if(vis[u.ID]) continue;
		vis[u.ID] = 1;
		for(int i=head[u.ID];i!=-1;i=edge[i].next){
			if(!vis[edge[i].to] && dis[u.ID] + edge[i].val < dis[edge[i].to]){
				dis[edge[i].to] = dis[u.ID] + edge[i].val;
				now.ID = edge[i].to;
				now.val = dis[edge[i].to];
				q.push(now);
			}
		}
	}
} 
int main(){
	int n, m, x, u, v, w;
	scanf("%d%d%d", &n, &m, &x);
	memset(head, -1, sizeof head);
	memset(dis, 0x3f, sizeof dis);	
	while(m--){
		scanf("%d%d%d", &u, &v, &w);
		Add_Edge(u, v, w);
	}
	dijstra(x);
	for(int i=1;i<=n;i++){
		mp[i] = dis[i];
	}
	int ans = -0x3f3f3f3f;
	for(int i=1;i<=n;i++){
		if(i == x) continue;
		memset(dis, 0x3f, sizeof dis);
		memset(vis, 0, sizeof vis);
		dijstra(i);
		ans = max(ans, mp[i] + dis[x]);
	}
	cout << ans;
	return 0;
}

Currency Exchange

  • 题目描述了一个情景，告诉我们用A换B的汇率和佣金，现在问经过兑换，最后需要换回原来的币种，能不能换完之后发现钱变多了
  • 问题明显是求正环的问题，使用 b e l l m a n − f o r d bellman-ford bellman−ford算法求解，我们进行 ∣ V ∣ − 1 |V|-1 ∣V∣−1次松弛操作，记录现在的结果，然后重新跑一边 b e l l m a n − f o r d bellman-ford bellman−ford，这时候如果没正环，应该是最大的情况，如果发现又变大了，只能说明图中存在正环
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <vector>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int INF = 0x3f3f3f3f;
const int MAXN = 1e6 + 100;
const double eps = 1e-6;
int Data[MAXN];
double edge1[200][200];
double edge2[200][200];
double dis[200];
bool Bellman_Ford(int n){
    double d[200];
    for(int i=1;i<=n;i++){
        d[i] = dis[i];
    }
    for(int k=1;k<n;k++){
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(dis[j] < (dis[i] - edge2[i][j]) * edge1[i][j]){
                    dis[j] = (dis[i] - edge2[i][j]) * edge1[i][j];
                }
            }
        }
    }
    for(int i=1; i<=n; i++){
        if(d[i] < dis[i]) return true;
    }
    return false;
}
int main(){
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    int n, m, s, u, x, y;
    double v;
    double rab, rba, cab, cba;
    scanf("%d%d%d%lf", &n, &m, &s, &v);
    dis[s] = v;
    while(m--){
        scanf("%d%d%lf%lf%lf%lf", &x, &y, &rab, &cab, &rba, &cba);
        edge1[x][y] = rab;
        edge1[y][x] = rba;
        edge2[x][y] = cab;
        edge2[y][x] = cba;
    }
    Bellman_Ford(n);
    if(Bellman_Ford(n)) printf("YES");
    else printf("NO");
    return 0;
}

Wormholes

  • 给出一些路径，农场之间的路径是双向的，虫洞是单向的，进入虫洞会使时间倒退，走正常的路会消耗时间，问有没有可能在从某个地方出发之前到达该地方
  • 如果把进入虫洞的时间设为负值，那么这就是一个判断有没有负环的问题，可以使用 B e l l m a n − f o r d Bellman-ford Bellman−ford和 f l o y d floyd floyd两种方法
  • 黑书上介绍的是 f l o y d floyd floyd方法，思路是令 e d g e [ i ] [ i ] = 0 edge[i][i]=0 edge[i][i]=0，之后跑一遍 f l o y d floyd floyd，如果发现对于某个 i i i，从 i i i到 i i i时间为负数，说明有负环，但是时间复杂度很高，需要在 f l o y d floyd floyd加一个小小的优化，剪掉路径不存在的情况
  • 我写的朴素 b e l l m a n − f o r d bellman-ford bellman−ford没通过，但是思路是清晰的
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <vector>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int INF = 0x3f3f3f3f;
const int MAXN = 1e6 + 100;
const double eps = 1e-6;
int Data[MAXN];
int edge[600][600];
bool floyd(int n){
    for(int k=1;k<=n;k++){
        for(int i=1;i<=n;i++){
            if(edge[i][k] != INF)
            for(int j=1;j<=n;j++){
                if(edge[i][j] > edge[i][k] + edge[k][j]){
                    edge[i][j] = edge[i][k] + edge[k][j];
                }
            }
        }
    }
    for(int i=1;i<=n;i++){
        if(edge[i][i] < 0) return true;
    }
    return false;
}
int main(){
    int F, n, m, w, s, e, t;
    scanf("%d", &F);
    while(F--){
        scanf("%d%d%d", &n, &m, &w);
        memset(edge, INF, sizeof edge);
        while(m--){
            scanf("%d%d%d", &s, &e, &t);
            if(t < edge[s][e]){
                edge[s][e] = edge[e][s] = t;
            }
        }
        while(w--){
            scanf("%d%d%d", &s, &e, &t);
            edge[s][e] = min(-t, edge[s][e]);
        }
        for(int i=1;i<=n;i++) edge[i][i] = 0;
        if(floyd(n)) printf("YES");
        else printf("NO");
        printf("\n");
    }
    return 0;
}

Cow Contest

  • 给出若干组比赛结果，格式为 A    B A\ \ B A  B，表示 A A A赢了 B B B，问有几个能够确定的名次
  • 如果想确定名次，必须要知道他和其他所有人的比赛结果，可以利用 f l o y d floyd floyd的递推关系，对于 A , B , C A,B,C A,B,C如果 A A A赢了 B B B，那么令 e d g e [ A ] [ B ] = 1 , e d g e [ B ] [ A ] = − 1 edge[A][B]=1,edge[B][A]=-1 edge[A][B]=1,edge[B][A]=−1，如果 e d g e [ B ] [ C ] = 1 edge[B][C]=1 edge[B][C]=1那么就可以推出 e d g e [ A ] [ C ] = 1 edge[A][C]=1 edge[A][C]=1,进而推出所有人的比赛结果，最后计数
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <vector>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int INF = 0x3f3f3f3f;
const int MAXN = 1e6 + 100;
const double eps = 1e-6;
int Data[MAXN];
int edge[200][200];
void floyd(int n){
    for(int k=1;k<=n;k++){
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(edge[i][k] == edge[k][j] && edge[i][k] != INF){
                    edge[i][j] = edge[i][k];
                }
            }
        }
    }
}
int main(){
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    int n, m, u, v;
    cin >> n >> m;
    memset(edge, INF, sizeof edge);
    while(m--){
        cin >> u >> v;
        edge[u][v] = 1;
        edge[v][u] = -1;
    }
    floyd(n);
    int ans = 0;
    for(int i=1;i<=n;i++){
        int num = 0;
        for(int j=1;j<=n;j++){
            if(i == j) continue;
            if(edge[i][j] != INF) num++;
        }
        if(num == n - 1) ans++;
    }
    cout << ans;
    return 0;
}
Clarence Liu
关注
专栏目录
最短路习题
Jackzhan的博客
08-13 679
有限制最短路（枚举+最短路） 分层图最短路
解题报告：【kuangbin带你飞】专题四 最短路练习题
繁凡さん的博客
07-10 1029
最短路合集
最短路练习
.
09-29 353
目录 最短路练习 poj 2387 Til the Cows Come Home poj 2253 Frogger  poj 1797 Heavy Transportation poj 3268 Silver Cow Party poj 1860 Currency Exchange hdu 3790 最短路径问题 poj 2387 Til the Cows Come Home 题...
最短路习题题解-三连击p.s
weixin_30735391的博客
03-28 115
Telephone Lines 二分答案+最短路 Telephone Lines Solution: 钱的花费显然具有单调性,即花更多的钱得到的方案中,一定包含花费更少的方案。 所以可以二分答案，转化为判定性问题。 然后我们发现很简单了，只需每次check边权大于当前二分的钱的边的数量是不是小于等于K即可。 Code ↓ ： IL bool spfa() { RG int i,x,y; ...
最短路 Dijkstra Floyd Bellman-Ford SPFA模板及例题 （一次性搞定最短路类型的问题）...
weixin_33812433的博客
08-07 182
从城市A到城市B，有时候可以直达也可以途径其他城市到达，怎样选择最短的路径到达就是最短路问题。 分为单源最短路（所有点到某一特定点的最短路径）和多源最短路（任意两点间的最短路径）。根据边的正负也可以分为带负权边和不带负权边的最短路。 Dijkstra:用于解决不含负权边的单源最短路。基本思想：记S为已经找到到源点的最短路的点的集合，dis【i】表示顶点i到源...
最短路基础与习题
weixin_43870697的博客
07-23 1210
目录 前言 Floyd算法 Dijkstra算法 详解 模板 Spfa算法 详解 模板 例题 A.POJ-2387 Til the Cows Come Home B.POJ-2253 Frogger C.POJ-1797 Heavy Transportation D：POJ-3268 Silver Cow Party E:POJ-1860 Currency Exc...
电学中短路练习题.doc
10-08
综上所述，这些练习题涵盖了电路的基本概念、电路连接方式、电流方向、短路现象、电路元件的工作状态、电路安全以及电路图的解读等多个核心知识点。通过解决这些问题，学生可以提升对电学基础知识的理解和应用能力。
【图论】最短路问题大合集，五种算法刷爆最短路问题。
最新发布
m0_70875482的博客
10-22 836
思路：迭代n次，每次找到距离离起点最近的点，起点置为0，并且用距离最近的点更新其他点。题目：给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，所有边权均为正值。请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出 −1。输入格式：第一行包含整数 n 和 m。接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。输出格式：输出一个整数，表示 1 号点到 n 号点的最短距离。
最短路题单练习
qq_52280112的博客
08-05 308
思路：我们可以改变dijkstra的dis数组的含义，即所有点到点v的路径上的最小值，例如现在有一条路径为 u->v,我们可以用 dis[u] 和 len（u->v）的长度取最大，再用此时的得到的值，与dis[v]取最小。题目大意：N个点，M条边，每条边有权值。求一条1号点到N号点的路径，要求使得路径中的边权最小值最大。思路：这道题和上一道思路类似，我们可以改变dis数组的含义，在更新dis的过程中与上一道题相反即可。题目大意：求所有路径中的最长的边，在这些最长边中找到最小值并输出。.........
最短路习题集（hdu）
ljlhnick的博客
08-05 1361
下面把在杭电刷题的最短路的代码贴上 hdu 2544 点击打开链接 dijkstra算法 #include <iostream> #include <algorithm> #include <stdio.h> #include <string.h> #define N 200 #define Y 33333110 using names...
最短路专题练习
zhuml123的专栏
10-23 522
一、入门难度 1、HDU 2544（一级） 【题意】 给出n个顶点m条边，以及每条边的权值为w，求1到n的最短路 【思路】 裸题 2、HDU 2066 (一级) 【题意】 因为草儿的家在一个小镇上，没有火车经过，所以她只能去邻近的城市坐火车（好可怜啊~）。 【思路】 这道题其实一次Dijkstra就可以了，我们将草儿的家看做0，从草儿家到相邻镇的花费看做0，那么我们就只需要求草...
图论：洛谷 【图论】最短路练习 题单练习（除k短路外）
qq_62105443的博客
07-26 329
洛谷的最短路题单练习 旨在重新回顾图论这方面的知识
[kuangbin带你飞]专题四 最短路练习
fisty
01-28 1539
A - Til the Cows Come Home 最短路模板，从终点到起点，双向建边 /*********************************************** * Author: fisty * Created Time: 2015/1/28 20:55:21 * File Name : 4_A.cpp *************************
最短路经典例题 codevs 1557 热浪
cax1165
07-02 2864
codevs 1557 热浪 题目描述： 德克萨斯纯朴的民眾们这个夏天正在遭受巨大的热浪！！！他们的德克萨斯长角牛吃起来不错，可是他们并不是很擅长生產富含奶油的乳製品。Farmer John此时以先天下之忧而忧，后天下之乐而乐的精神，身先士卒地承担起向德克萨斯运送大量的营养冰凉的牛奶的重任，以减轻德克萨斯人忍受酷暑的痛苦。 FJ已经研究过可以把牛奶从威斯康星运送到德克萨斯州的路线。这
最短路习题（一）
微凉的博客
04-13 945
1.骑车比赛 测试输入： 5 6 1 2 2 2 3 3 2 5 5 3 4 2 3 5 1 4 5 1 测试输出： 6 裸题，dijkstra 代码如下： package _最短路习题; import java.util.Arrays; import java.util.Scanner; public class _汽车比赛 { static int n, m...
Dinic二分图匹配 || Luogu P3386
weixin_30652491的博客
06-01 310
题面：【模板】二分图匹配 思路：Dinic实现二分图匹配，要建一个超级源点（S）和超级汇点（T），分别定为N+M+1和N+M+2 然后S去和N中的数建正边和反边，正边权值为1，反边权值为0；M中的数去与T建正边和反边，正边权值为1。 N、M之间的数建图一样。 然后就去跑最大流。 注意：在Dinic函数中每次更新Cur的值时，要把S和T的Cur也更新了。 代码： 1 #...
取反和异或
ComingLiu的博客
12-22 7927
碰到了一个问题： #include <cstdio> #include <windows.h> using namespace std; int main(){ int x; printf("%x\n",~x^x); system("pause"); return 0; } 这段代码输出是多少？ 碰到这个问题我第一感觉，这难道不是乱码？ %d按...
ACM算法练习题单：最短路问题 & 总结
ccutyear的博客
12-27 2167
在练习完最短路问题后，我觉得有必要自己做一下小总结。我也顺便整理出了一部分的题单。
电力系统分析练习题详解
"电力系统分析练习题.pdf" 这篇资料是关于电力系统分析的练习题集，涵盖了多个关键知识点，包括电力系统的基本要求、变压器变比选择、电力系统中性点的运行方式、消弧线圈补偿方式、输电线路设计与参数计算等。下面...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Clarence Liu

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值