引言
今天刷题刷的是单源最短路问题，也就是图论中的搜索的问题，这个问题还是非常常考的，其实模板只要背熟了，理解到位了，剩下的主要是建图和一些细节的问题，除了背模板理解原理，再就是多刷题、多见题了，加油！
一、热浪
标签：单源最短路
思路：
s
p
f
a
spfa
spfa算法，可参考博客最短路问题，这种单源最短路问题，只要图建好了，起点和终点规定了，就没啥难的了，就是模板。
题目描述：
德克萨斯纯朴的民众们这个夏天正在遭受巨大的热浪！！！
他们的德克萨斯长角牛吃起来不错，可是它们并不是很擅长生产富含奶油的乳制品。
农夫John此时身先士卒地承担起向德克萨斯运送大量的营养冰凉的牛奶的重任，以减轻德克萨斯人忍受酷暑的痛苦。
John已经研究过可以把牛奶从威斯康星运送到德克萨斯州的路线。
这些路线包括起始点和终点一共有 T 个城镇，为了方便标号为 1 到 T。
除了起点和终点外的每个城镇都由 双向道路 连向至少两个其它的城镇。
每条道路有一个通过费用（包括油费，过路费等等）。
给定一个地图，包含 C 条直接连接 2 个城镇的道路。
每条道路由道路的起点 Rs，终点 Re 和花费 Ci 组成。
求从起始的城镇 Ts 到终点的城镇 Te 最小的总费用。
输入格式
第一行: 4 个由空格隔开的整数: T,C,Ts,Te;
第 2 到第 C+1 行: 第 i+1 行描述第 i 条道路，包含 3 个由空格隔开的整数: Rs,Re,Ci。
输出格式
一个单独的整数表示从 Ts 到 Te 的最小总费用。
数据保证至少存在一条道路。
数据范围
1≤T≤2500,1≤C≤6200,1≤Ts,Te,Rs,Re≤T,1≤Ci≤1000
输入样例：
7 11 5 4
2 4 2
1 4 3
7 2 2
3 4 3
5 7 5
7 3 3
6 1 1
6 3 4
2 4 3
5 6 3
7 2 1
输出样例：
7
示例代码：
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int,int> PII;
const int N = 3000, M = 7000 * 2, INF = 0x3f3f3f3f;
int n, m, S, E;
int h[N], e[M], w[M], ne[M], idx;
int dist[N];
bool st[N];
void add(int a, int b, int c)
{
e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}
int spfa()
{
memset(dist, 0x3f, sizeof dist);
dist[S] = 0;
st[S] = true;
queue<int> q;
q.push(S);
while(q.size())
{
int t = q.front(); q.pop();
st[t] = false;
for(int i = h[t]; i != -1; i = ne[i])
{
int j = e[i];
if(dist[j] > dist[t] + w[i])
{
dist[j] = dist[t] + w[i];
if(!st[j])
{
st[j] = true;
q.push(j);
}
}
}
}
if(dist[E] == INF) return -1;
else return dist[E];
}
int main()
{
ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
memset(h, -1, sizeof h);
cin >> n >> m >> S >> E;
while(m--)
{
int a, b, c;
cin >> a >> b >> c;
add(a,b,c);
add(b,a,c);
}
cout << spfa() << endl;
return 0;
}
二、信使
标签：单源最短路
思路：就是求从第一个哨所，到全部的哨所所需花费的最短时间，
s
p
f
a
spfa
spfa 本就是就最短路的，然后到达全部哨所也就是到某一个哨所的最长时间，遍历一下即可。
题目描述：
战争时期，前线有 n 个哨所，每个哨所可能会与其他若干个哨所之间有通信联系。
信使负责在哨所之间传递信息，当然，这是要花费一定时间的（以天为单位）。
指挥部设在第一个哨所。
当指挥部下达一个命令后，指挥部就派出若干个信使向与指挥部相连的哨所送信。
当一个哨所接到信后，这个哨所内的信使们也以同样的方式向其他哨所送信。信在一个哨所内停留的时间可以忽略不计。
直至所有 n 个哨所全部接到命令后，送信才算成功。
因为准备充足，每个哨所内都安排了足够的信使（如果一个哨所与其他 k 个哨所有通信联系的话，这个哨所内至少会备 k 个信使）。
现在总指挥请你编一个程序，计算出完成整个送信过程最短需要多少时间。
输入格式
第 1 行有两个整数 n 和 m，中间用 1 个空格隔开，分别表示有 n 个哨所和 m 条通信线路。
第 2 至 m+1 行：每行三个整数 i、j、k，中间用 1 个空格隔开，表示第 i 个和第 j 个哨所之间存在 双向 通信线路，且这条线路要花费 k 天。
输出格式
一个整数，表示完成整个送信过程的最短时间。
如果不是所有的哨所都能收到信，就输出-1。
数据范围
1≤n≤100,1≤m≤200,1≤k≤1000
输入样例：
4 4
1 2 4
2 3 7
2 4 1
3 4 6
输出样例：
11
示例代码：
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int,int> PII;
const int N = 200, M = 300, INF = 0x3f3f3f3f;
int n, m;
int h[N], e[M], w[M], ne[M], idx;
int dist[N];
bool st[N];
void add(int a, int b, int c)
{
e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}
int spfa()
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
st[1] = true;
queue<int> q;
q.push(1);
while(q.size())
{
int t = q.front(); q.pop();
st[t] = false;
for(int i = h[t]; i != -1; i = ne[i])
{
int j = e[i];
if(dist[j] > dist[t] + w[i])
{
dist[j] = dist[t] + w[i];
if(!st[j])
{
st[j] = true;
q.push(j);
}
}
}
}
int res = 0;
for(int i = 1; i <= n; ++i)
{
if(dist[i] == INF) return -1;
res = max(res, dist[i]);
}
return res;
}
int main()
{
ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
memset(h, -1, sizeof h);
cin >> n >> m;
while(m--)
{
int a, b, c;
cin >> a >> b >> c;
add(a,b,c);
add(b,a,c);
}
cout << spfa() << endl;
return 0;
}
三、香甜的黄油
标签：单源最短路
思路：本来以为是超级源点问题，结果发现即使有了超级源点也不行，因为没有确定那个牧场是在哪。一看题解，原来是直接找从每个点到奶牛所在的牧场路程和的最小值，暴力枚举每个点就行了。数据范围也允许。
题目描述：
农夫John发现了做出全威斯康辛州最甜的黄油的方法：糖。
把糖放在一片牧场上，他知道 N 只奶牛会过来舔它，这样就能做出能卖好价钱的超甜黄油。
当然，他将付出额外的费用在奶牛上。
农夫John很狡猾，就像以前的巴甫洛夫，他知道他可以训练这些奶牛，让它们在听到铃声时去一个特定的牧场。
他打算将糖放在那里然后下午发出铃声，以至他可以在晚上挤奶。
农夫John知道每只奶牛都在各自喜欢的牧场（一个牧场不一定只有一头牛）。
给出各头牛在的牧场和牧场间的路线，找出使所有牛到达的路程和最短的牧场（他将把糖放在那）。
数据保证至少存在一个牧场和所有牛所在的牧场连通。
输入格式
第一行: 三个数：奶牛数 N，牧场数 P，牧场间道路数 C。
第二行到第 N+1 行: 1 到 N 头奶牛所在的牧场号。
第 N+2 行到第 N+C+1 行：每行有三个数：相连的牧场A、B，两牧场间距 D，当然，连接是双向的。
输出格式
共一行，输出奶牛必须行走的最小的距离和。
数据范围
1≤N≤500,2≤P≤800,1≤C≤1450,1≤D≤255
输入样例：
3 4 5
2
3
4
1 2 1
1 3 5
2 3 7
2 4 3
3 4 5
输出样例：
8
示例代码：
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int,int> PII;
const int N = 1000, M = 5000, INF = 0x3f3f3f3f;
int n, m, k;
int h[N], e[M], w[M], ne[M], idx;
int dist[N];
bool st[N];
int id[N]; // 第i号牧场有几头牛
void add(int a, int b, int c)
{
e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}
int spfa(int S)
{
memset(dist, 0x3f, sizeof dist);
dist[S] = 0;
st[S] = true;
queue<int> q;
q.push(S);
while(q.size())
{
int t = q.front(); q.pop();
st[t] = false;
for(int i = h[t]; i != -1; i = ne[i])
{
int j = e[i];
if(dist[j] > dist[t] + w[i])
{
dist[j] = dist[t] + w[i];
if(!st[j])
{
st[j] = true;
q.push(j);
}
}
}
}
int res = 0;
for(int i = 0; i < k; ++i)
{
int j = id[i];
if(dist[j] == INF) return INF;
else res += dist[j];
}
return res;
}
int main()
{
ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
memset(h, -1, sizeof h);
cin >> k >> n >> m;
for(int i = 0; i < k; ++i) cin >> id[i];
while(m--)
{
int a, b, c;
cin >> a >> b >> c;
add(a,b,c), add(b,a,c);
}
int res = INT_MAX;
for(int i = 1; i <= n; ++i) res = min(res, spfa(i));
cout << res << endl;
return 0;
}
四、最小花费
标签：单源最短路
思路：这道题其实可以看成找汇率最大的那一条路就行了，只要把
s
p
f
a
spfa
spfa 算法中的判断条件改一下，把原来的
d
i
s
t
[
j
]
>
.
.
.
dist[j] > ...
dist[j]>... 改为
d
i
s
t
[
j
]
<
.
.
.
dist[j] < ...
dist[j]<... ，因为如果从原点出发最后到终点，肯定是找变化率最大的那条路，这样一改小的就会被大的更新，最后在转换一下就行，详情见代码。
题目描述：
在 n 个人中，某些人的银行账号之间可以互相转账。
这些人之间转账的手续费各不相同。
给定这些人之间转账时需要从转账金额里扣除百分之几的手续费，请问 A 最少需要多少钱使得转账后 B 收到 100 元。
输入格式
第一行输入两个正整数 n,m，分别表示总人数和可以互相转账的人的对数。
以下 m 行每行输入三个正整数 x,y,z，表示标号为 x 的人和标号为 y 的人之间互相转账需要扣除 z% 的手续费 ( z<100
)。
最后一行输入两个正整数 A,B。
数据保证 A 与 B 之间可以直接或间接地转账。
输出格式
输出 A 使得 B 到账 100 元最少需要的总费用。
精确到小数点后 8 位。
数据范围
1≤n≤2000,m≤105
输入样例：
3 3
1 2 1
2 3 2
1 3 3
1 3
输出样例：
103.07153164
示例代码：
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<double,int> PII;
const int N = 2010, M = 1e5+10, INF = 0x3f3f3f3f;
int n, m, S, E;
int h[N], e[M], w[M], ne[M], idx;
double dist[N];
bool st[N];
void add(int a, int b, int c)
{
e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}
double dijkstra()
{
dist[S] = 1;
priority_queue<PII> heap;
heap.push({1,S});
while(heap.size())
{
auto t = heap.top(); heap.pop();
double v = t.first;
int p = t.second;
if(st[p]) continue;
st[p] = true;
for(int i = h[p]; i != -1; i = ne[i])
{
int j = e[i];
if(dist[j] < dist[p] * (1.0 - w[i]/100.0))
{
dist[j] = dist[p] * (1.0 - w[i]/100.0);
heap.push({dist[j],j});
}
}
}
return dist[E];
}
int main()
{
ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
memset(h, -1, sizeof h);
cin >> n >> m;
while(m--)
{
int a, b, c;
cin >> a >> b >> c;
add(a,b,c), add(b,a,c);
}
cin >> S >> E;
printf("%.8lf\n", 100.0 / dijkstra());
return 0;
}
五、最优乘车
标签：单源最短路
思路：我们可以让一条路线上的每一个站点都和之后的站点连边（如下图），权值置为一，这样换站的次数就是乘车的次数减一，可以
b
s
f
bsf
bsf 或者任意一个最短路模板都可以。这里能用
b
f
s
bfs
bfs 是因为所有边的权值都是一样的。
题目描述：
H 城是一个旅游胜地，每年都有成千上万的人前来观光。
为方便游客，巴士公司在各个旅游景点及宾馆，饭店等地都设置了巴士站并开通了一些单程巴士线路。
每条单程巴士线路从某个巴士站出发，依次途经若干个巴士站，最终到达终点巴士站。
一名旅客最近到 H 城旅游，他很想去 S 公园游玩，但如果从他所在的饭店没有一路巴士可以直接到达 S 公园，则他可能要先乘
某一路巴士坐几站，再下来换乘同一站台的另一路巴士，这样换乘几次后到达 S 公园。
现在用整数 1,2,…N 给 H 城的所有的巴士站编号，约定这名旅客所在饭店的巴士站编号为 1，S 公园巴士站的编号为 N。
写一个程序，帮助这名旅客寻找一个最优乘车方案，使他在从饭店乘车到 S 公园的过程中换乘的次数最少。
输入格式
第一行有两个数字 M 和 N，表示开通了 M 条单程巴士线路，总共有 N 个车站。
从第二行到第 M+1 行依次给出了第 1 条到第 M 条巴士线路的信息，其中第 i+1 行给出的是第 i 条巴士线路的信息，从左至右按
运行顺序依次给出了该线路上的所有站号，相邻两个站号之间用一个空格隔开。
输出格式
共一行，如果无法乘巴士从饭店到达 S 公园，则输出 NO，否则输出最少换乘次数，换乘次数为 0 表示不需换车即可到达。
数据范围
1≤M≤100,2≤N≤500
输入样例：
3 7
6 7
4 7 3 6
2 1 3 5
输出样例：
2
示例代码：
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int,int> PII;
const int N = 510, M = N * N;
int n, m;
int h[N], e[M], w[M], ne[M], idx;
int dist[N];
bool st[N];
string line;
void add(int a, int b, int c)
{
e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}
int bfs()
{
memset(dist, -1, sizeof dist);
dist[1] = 0;
st[1] = true;
queue<int> q;
q.push(1);
while(q.size())
{
int t = q.front(); q.pop();
for(int i = h[t]; i != -1; i = ne[i])
{
int j = e[i];
if(st[j]) continue;
dist[j] = dist[t] + 1;
st[j] = true;
q.push(j);
}
}
return dist[n];
}
int main()
{
ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
memset(h, -1, sizeof h);
cin >> m >> n;
getline(cin, line);
while(m--)
{
getline(cin, line);
stringstream ssin(line);
int a = 0, b = 0, c = 0;
vector<int> step;
while(ssin >> a) step.push_back(a);
// for(int x: step) cout << x << " ";
// cout << endl;
for(int i = 0; i < step.size(); ++i)
{
for(int j = i + 1; j < step.size(); ++j)
{
add(step[i], step[j], 1);
}
}
// cout << endl;
}
int t = bfs();
if(t == -1) puts("NO");
else cout << t - 1 << endl;
return 0;
}
六、昂贵的聘礼
标签：单源最短路
思路：该问题可以抽象成如下所示的图，我们把自己看作源点，
1
1
1 号点看做汇点，路径就是需要付的聘礼，求最少的钱，也就是最短路问题。关于等级，我们可以从
[
l
e
v
e
l
[
1
]
−
m
,
l
e
v
e
l
[
1
]
+
m
]
[level[1] - m, level[1] + m]
[level[1]−m,level[1]+m] 中枚举所有的长度为
m
m
m 的区间，求出最小值即可。
题目描述：
年轻的探险家来到了一个印第安部落里。
在那里他和酋长的女儿相爱了，于是便向酋长去求亲。
酋长要他用 10000 个金币作为聘礼才答应把女儿嫁给他。
探险家拿不出这么多金币，便请求酋长降低要求。
酋长说：”嗯，如果你能够替我弄到大祭司的皮袄，我可以只要 8000 金币。如果你能够弄来他的水晶球，那么只要5000 金币就行了。”
探险家就跑到大祭司那里，向他要求皮袄或水晶球，大祭司要他用金币来换，或者替他弄来其他的东西，他可以降低价格。
探险家于是又跑到其他地方，其他人也提出了类似的要求，或者直接用金币换，或者找到其他东西就可以降低价格。
不过探险家没必要用多样东西去换一样东西，因为不会得到更低的价格。
探险家现在很需要你的帮忙，让他用最少的金币娶到自己的心上人。
另外他要告诉你的是，在这个部落里，等级观念十分森严。
地位差距超过一定限制的两个人之间不会进行任何形式的直接接触，包括交易。
他是一个外来人，所以可以不受这些限制。
但是如果他和某个地位较低的人进行了交易，地位较高的的人不会再和他交易，他们认为这样等于是间接接触，反过来也一样。
因此你需要在考虑所有的情况以后给他提供一个最好的方案。
为了方便起见，我们把所有的物品从 1 开始进行编号，酋长的允诺也看作一个物品，并且编号总是 1。
每个物品都有对应的价格 P，主人的地位等级 L，以及一系列的替代品 Ti 和该替代品所对应的”优惠” Vi。
如果两人地位等级差距超过了 M，就不能”间接交易”。
你必须根据这些数据来计算出探险家最少需要多少金币才能娶到酋长的女儿。
输入格式
输入第一行是两个整数 M，N，依次表示地位等级差距限制和物品的总数。
接下来按照编号从小到大依次给出了 N 个物品的描述。
每个物品的描述开头是三个非负整数 P、L、X，依次表示该物品的价格、主人的地位等级和替代品总数。
接下来 X 行每行包括两个整数 T 和 V，分别表示替代品的编号和”优惠价格”。
输出格式
输出最少需要的金币数。
数据范围
1≤N≤100,1≤P≤10000,1≤L,M≤N,0≤X<N
输入样例：
1 4
10000 3 2
2 8000
3 5000
1000 2 1
4 200
3000 2 1
4 200
50 2 0
输出样例：
5250
示例代码：
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int,int> PII;
const int N = 110, M = N * N, INF = 0x3f3f3f3f;
int n, m;
int h[N], e[M], w[M], ne[M], idx;
int dist[N], level[N];
bool st[N];
void add(int a, int b, int c)
{
e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}
int spfa(int down, int up)
{
memset(dist, 0x3f, sizeof dist);
memset(st, 0, sizeof 0);
dist[0] = 0;
st[0] = true;
queue<int> q;
q.push(0);
while(q.size())
{
int t = q.front(); q.pop();
st[t] = false;
for(int i = h[t]; i != -1; i = ne[i])
{
int j = e[i];
if(dist[j] > dist[t] + w[i] && level[j] >= down && level[j] <= up)
{
dist[j] = dist[t] + w[i];
if(!st[j])
{
st[j] = true;
q.push(j);
}
}
}
}
return dist[1];
}
int main()
{
ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
memset(h, -1, sizeof h);
cin >> m >> n;
for(int i = 1; i <= n; ++i)
{
int price, cnt;
cin >> price >> level[i] >> cnt;
add(0, i, price);
while(cnt--)
{
int id, cost;
cin >> id >> cost;
add(id, i, cost);
}
}
int res = INF;
for(int i = level[1] - m; i <= level[1]; ++i) res = min(res, spfa(i, i+m));
cout << res << endl;
return 0;
}
936
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
