单源最短路的建图方式
- 单源最短路的建图方式
- AcWing 1129. 热浪
- AcWing 1128. 信使
- AcWing 1127. 香甜的黄油
- AcWing 1126. 最小花费
- AcWing 920. 最优乘车
- AcWing 903. 昂贵的聘礼
单源最短路的建图方式
AcWing 1129. 热浪
#include <iostream>
#include <cstring>
using namespace std;
const int N = 2500 + 10, M = 6200 * 2 + 10;
int q[N], dist[N];
bool st[N];
int e[M], h[N], w[M], ne[M], idx;//理解链表存储图的本质，h只需要开N，与节点数相同
int n, m, S, T;
void add (int a, int b, int c)
{
e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}
void spfa()
{
memset(st, 0, sizeof st);
memset(dist, 0x3f, sizeof dist);
dist[S] = 0;//S是起点，起点到自己的距离为0
int hh = 0, tt = 1;//默认S先占一个位置，因此tt要从1开始，同时这也满足进入while循环的条件hh！=tt
q[0] = S;
st[S] = true;
while (hh != tt)//循环队列不是<= 而是！
{
int t = q[hh ++ ];
if (hh == N) hh = 0;
st[t] = false;
for (int i = h[t]; ~i; i = ne[i])
{
int j = e[i];
if (dist[j] > dist[t] + w[i])
{
dist[j] = dist[t] + w[i];
if (!st[j])
{
q[tt ++ ] = j;
if (tt == N) tt = 0;//循环队列，st数组的存在队列里面最多存储N个点，一个点可能多次入队，
//我们不知道大概这个队列应该开多大，同时为了节省空间我们用循环队列
st[j] = true;
}
}
}
}
}
int main ()
{
cin >> n >> m >> S >> T;
memset(h, -1, sizeof h);//这个不能放在spfa里面，必须在add之前就初始化好h数组。。之前傻逼了
for (int i = 0; i < m; i ++ )
{
int a, b, c;
cin >> a >> b >> c;
add(a, b, c), add(b, a, c);
}
spfa();
cout << dist[T];
return 0;
}
AcWing 1128. 信使
#include <iostream>
#include <cstring>
using namespace std;
const int N = 110, INF = 0x3f3f3f3f;
int n, m;
int d[N][N];
int main()
{
cin >> n >> m;
memset(d, 0x3f, sizeof d);
for (int i = 1; i <= n; i ++ ) d[i][i] = 0;//初始化，每个点作为源点到他自己的距离为0
for (int i = 0; i < m; i ++ )
{
int a, b, c;
cin >> a >> b >> c;
d[a][b] = d[b][a] = min(d[a][b], c);//最短路问题有重边，取最短的即可
}
for (int k = 1; k <= n; k ++ )
for (int i = 1; i <= n; i ++ )
for (int j = 1; j <= n; j ++ )
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);//floyd本质是动态规划，划分子集的时候可以以最后到达j前的最后一个点是k来划分，k这一维可以省略
int ans = 0;
for (int i = 1; i <= n; i ++ )
if (d[1][i] == INF)
{
ans = -1;
break;
}
else ans = max(ans, d[1][i]);//不是ans += d[1][i]，因为最远的的i点都送到了，其他的点也肯定送到了，题目说了信使送信是扩散的
cout << ans;
return 0;
}
AcWing 1127. 香甜的黄油
建图 找出一个牧场，它到其他牧场的距离之和最小
//建图 找出一个牧场，它到其他牧场的距离之和最小
#include <iostream>
#include <cstring>
using namespace std;
const int N = 800 + 10, M = 1450 * 2 + 10, INF = 0x3f3f3f3f;
int n, p, m;
int id[510];
int e[M], w[M], ne[M], h[N], idx;//这里定义的时候按照牧场数定义，本质求的还是牧场之间的最短路，奶牛只不过和牧场之间有一些映射关系罢了
int q[N], st[N];//st一般如果只有一组测试数据不用多次初始化
int dist[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 start)
{
memset(dist, 0x3f, sizeof dist);
int hh = 0, tt = 1;
q[0] = start, dist[start] = 0, st[start] = true;
while (hh != tt)
{
int t = q[hh ++ ];
st[t] = false;
if (hh == N) hh = 0;
for (int i = h[t]; ~i; i = ne[i])
{
int j = e[i];
if (dist[j] > dist[t] + w[i])
{
dist[j] = dist[t] + w[i];
if (!st[j])
{
q[tt ++ ] = j;
if (tt == N) tt = 0;
st[j] = true;
}
}
}
}
int ans = 0;
// for (int i = 0; i < n; i ++ )
// ans += dist[id[i]];
for (int i = 0; i < n; i ++ )
{
int j = id[i];
if (dist[j] == INF) return INF;//不知道为啥非要这么特判，题目也没说有的不可达
ans += dist[j];
}
return ans;
}
int main ()
{
cin >> n >> p >> m;
for (int i = 0; i < n; i ++ ) cin >> id[i];
memset(h, -1, sizeof h);
for (int i = 0; i < m; i ++ )
{
int a, b, c;
cin >> a >> b >> c;
add(a, b, c), add(b, a, c);
}
int ans = INF;
//因为牧场的编号是从1开始的，所以遍历要从1开始而不是0
for (int i = 1; i <= p; i ++ ) ans = min(ans, spfa(i));
cout << ans;
return 0;
}
AcWing 1126. 最小花费
我是这么理解的，djsktra是一个贪心的思想，加法里面不能加负数我就不说了
求乘法最大值的时候为什么边权必须0-1，因为在乘法最大值里面有一个边权大于1的话那不就等价于求加法最小值的时候有一个边权为负数的么，dj是贪心的思想，每次出队的时候必须都是最值不能在改变了，而乘法最大值中边权大于1会破坏这个贪心的思路。
一开始建图没想到是无向图debug了好久，甚至以为是double精度问题
#include <iostream>
#include <cstring>
using namespace std;
const int N = 2010;//用邻接表存储图的时候不需要定义边的条数，有重边的情况下根据题意去最大值或最小值即可
bool st[N];
double dist[N];
double g[N][N];
int n, m, S, T;
void dijkstra()
{
dist[S] = 1;
//st[S] = true;不能把源点先变为true，因为我们还需要源点去更新源点周围的点
//n个点，在边权满足条件的情况下，每个点都要遍历一次，因此需要遍历n次
for (int i = 1; i <= n; i ++ )//for (int i = 0; i < n; i ++ ) 循环n次就行了，下标从1和0开始都可以，但是下面的for涉及下标了，看题意是下标从0还是1开始
{
int t = -1; //j是具体的点的下标，题目说了 下标>=1
for (int j = 1; j <= n; j ++ )//贪心：找到当前没确定的点 且 离源点最近的点
{
if (!st[j] && (t == -1 || dist[t] < dist[j]))
t = j;
}
st[t] = true;
for (int j = 1; j <= n; j ++ )
{
dist[j] = max(dist[j], dist[t] * g[t][j]);//动态规划，用距离源点最近的点去更新其他点到源点的距离
}
}
}
int main ()
{
cin >> n >> m;
for (int i = 0; i < m; i ++ )
{
int a, b, c;
cin >> a >> b >> c;
g[a][b] = g[b][a] = max(g[a][b], (100.0 - c) / 100);
//g[a][b] = max(g[a][b], (double)(100.0 - c) / 100);
//double z = (100.0 - c) / 100;
//g[a][b] = g[b][a] = max(g[a][b], z);
}
cin >> S >> T;
dijkstra();
printf("%.8lf\n", 100 / dist[T]);
return 0;
}
AcWing 920. 最优乘车
这题的输入输出挺恶心的，对了，输入小于10万就可以用cin
getline
sstream
将一辆车可以到达的所有站点之间连接都连接一条边，那就是要cn2条边具体我描述的不太好，可以去看这题的视频讲解。
#include <iostream>
#include <cstring>
#include <sstream>
#include <cstdio>
using namespace std;
const int N = 510, INF = 0x3f3f3f3f;
bool g[N][N];
int stop[N];
int q[N], dist[N];
int n, m;
void bfs ()
{
memset(dist, 0x3f, sizeof dist);
int hh = 0, tt = 0;
q[0] = 1;
dist[1] = 0;//dist记录的是从源点到该点需要乘坐多少次大巴，从1号点到1号点在只需要乘坐0次大巴
while (hh <= tt)
{
int t = q[hh ++ ];
for (int i = 1; i <= n ; i ++ )//公交站牌的下标是从1开始的不是0
{
if (g[t][i] && dist[i] > dist[t] + 1)
{
dist[i] = dist[t] + 1;
q[++ tt] = i;
}
}
}
}
int main ()
{
cin >> m >> n;//这题是先输入m,在输入n比较恶心
string line;
getline(cin, line);//将第一行的换行接受掉
while (m -- )
{
getline(cin, line);//相比于cin，这是读一整行可以读取到空格换行等
stringstream ssin(line);//把字符串转化为int
int cnt = 0, p;
while (ssin >> p) stop[cnt ++ ] = p;
for (int i = 0; i < cnt; i ++ )
for (int j = i + 1; j < cnt; j ++ )
g[stop[i]][stop[j]] = true;
}
bfs();
if (dist[n] == INF) puts("NO");
else cout << max(dist[n] - 1, 0);//题目要输出的是换乘次数 如果换乘次数为0，则dist[n] - 1 = -1(因为只用一辆车到达目的地的换乘次数是0，但是乘坐的不同大巴种类为1)
//,但题目要输出的是0 ，因此要特判一下
return 0;
}
AcWing 903. 昂贵的聘礼
w数组很精髓，level数组很牛逼，虚拟源点结合w数组更nb，同时注意dijkstra里面的for循环下标的含义，到底是控制循环次数，还是真正映射的是下标
#include <iostream>
#include <cstring>
using namespace std;
const int N = 110, INF = 0x3f3f3f3f;
bool st[N];
int w[N][N], dist[N], level[N];
int m, n;
int dijkstra(int down, int up)
{
memset(dist, 0x3f, sizeof dist);
memset(st, 0, sizeof st);//不知道这里为什么会wa，明明其实一般如果没有多组数据不需要这个初始化，全局的st默认就是false
//st[0] = true;经常犯这个错，因为我们需要用源点来更新它周围的点到它的距离，dj其实就是dfs，只不过权值不是1罢了
dist[0] = 0;
for (int i = 1; i <= n + 1; i ++ )//多了一个虚拟源点，因此要循环n + 1次才能确定n+1件物品到源点的最短距离，x加上虚拟源点一共有n + 1个物品，x
{ //dj贪心的思想就是每次循环都可以确定一个节点到源点的最短距离，再用这个节点去更新它到其他点的距离
int t = -1;
for (int j = 0; j <= n; j ++ )//这里遍历的时候遍历的是编号，而不是保证次数，题目编号下标从1开始，但是我们虚拟源点的下标是0
if (!st[j] && (t == -1 || dist[t] > dist[j]))
t = j;
st[t] = true;
for (int j = 1; j <= n; j ++ )
{
if (level[j] >= down && level[j] <= up) dist[j] = min(dist[j], dist[t] + w[t][j]);//dp的思想
}
}
return dist[1];
}
int main()
{
cin >> m >> n;
memset(w, 0x3f, sizeof w);
for (int i = 1; i <= n; i ++ )w[i][i] = 0; //用第i个物品换第i个物品需要额外＋0元
for (int i = 1; i <= n; i ++ )
{
int price, cnt;
cin >> price >> level[i] >> cnt;
w[0][i] = min(price, w[0][i]);//可以不用min，但以防万一么 虽然我不知道为什么要取min题目没说会输入重复数据，但这个意思就是什么物品都不带换第i个物品需要它自身原来的价格
while (cnt -- )
{
int id, cost;
cin >> id >> cost;
//w[id][i] = cost;
w[id][i] = min(w[id][i], cost);// 可以不用min，但以防万一么 用序号为id的物品换物品i需要＋cost元
}
}
int res = INF;
//最终需要换的物品为物品1，因此我们以物品1为基底，遍历“图"可以到达的节点（即可以使用的物品有哪些）
for (int i = level[1] - m; i <= level[1]; i ++ ) res = min(res, dijkstra(i, i + m));
cout << res << endl;
return 0;
}
