1.
注意的是多行读取，
单源最短路径优化版本：
- 由邻接矩阵变成了邻接表，
然后每次寻找距离最小的边就不用循环一个二维矩阵了，
在邻接表中的边中找就行了。 - 每次找最小的边，用了优先队列，这样时间就变成了logn而不是双重for循环。
普通版本：
代码：
#include<iostream>
using namespace std;
const int Maxn = 1e2;
// 图的邻接矩阵，
int edges[Maxn][Maxn]; //初始为0,0表示不可达
int dis[Maxn] ; // 表示源点到其他顶点的最短距离
int main() {
int n, m, s;
cin >> n >> m >> s;
for (int i = 1; i <= n; i++) {
dis[i] = Maxn;
for (int j = 1; j <= n; j++) {
edges[i][j] = 0;
}
}
dis[s] = 0;
int v1, v2, e;
for (int i = 0; i < m; i++) {
cin >> v1 >> v2 >> e;
edges[v1][v2] = e; // 给边赋初值
if (v1 == s) {
dis[v2] = e;
}
}
int vis[Maxn] = {0}; // 记录源点到其他顶点的最短距离是否已经计算出来
vis[s] = 1;
for (int i = 1; i < n; i++) {
// 每一次找距离源点距离最小的顶点
int minn = 1e9, minIndex = -1;
for (int j = 1; j <= n; j++) {
if (vis[j] == 0 && dis[j] < minn) {
minn = dis[j];
minIndex = j;
}
}
// 将这个顶点加入顶点集合
vis[minIndex] = 1;
// 更新其余顶点的dis值
for (int j = 1; j <= n; j++) {
if (vis[j] == 0 && edges[minIndex][j] > 0) {
dis[j] = min(dis[j], minn + edges[minIndex][j]);
}
}
}
for (int i = 1; i <= n; i++) {
cout << dis[i] << " ";
}
return 0;
}
优化版本：
代码：
#include<iostream>
#include<vector>
#include<queue>
using namespace std;
const int maxN = 2e5 + 7;
typedef struct Edge {
int to;
int weight;
bool operator<(const Edge &a) const {
return weight > a.weight; // 使得优先队列中距离短的先出来
}
} Edge;
// 用二维数组来表示图的邻接表
// vector<vector<int>> adjList;
vector<Edge> adjList[maxN]; // 因为一开始要指定有几个顶点，所以要用数组，vector不用指定大小，一条边一条边加就行了
int dist[maxN]; // 距离初始化最大
int vis[maxN];
void dijkstra(int s) {
priority_queue<Edge> queue; // 优先队列，保存源点到其他点的距离，注意保存的不是边
// 初始化源点到源点距离是0
dist[s] = 0;
// vis[s] = 1; 这个要等在优先队列里面出来之后再标记
queue.push(Edge{s, 0}); // 源点加入优先队列
while (!queue.empty()) {
Edge e = queue.top(); // 距离最短的出队
queue.pop();
// 找到这个边的端点
int u = e.to;
if (vis[u]) {
continue;
}
vis[u] = 1;
// 更新与u相连的点
for (int i = 0; i < adjList[u].size(); i++) {
int v = adjList[u][i].to;
int newDis = dist[u] + adjList[u][i].weight;
if (newDis < dist[v]) {
dist[v] = newDis;
// 将更新过的点以及源点到它的距离加到队列中，
// 即使之前这个点已经在队列中也没有问题，因为更新的数更小，在取的时候新的小的值会被先取出来
queue.push(Edge{v, dist[v]});
}
}
}
}
int main() {
int n, m, s;
cin >> n >> m >> s;
// 输入边
for (int i = 0; i < m; i++) {
int v1, v2, w;
cin >> v1 >> v2 >> w;
adjList[v1].push_back(Edge{v2, w});
}
// dist赋初值为最大，下标从1开始的
fill(dist + 1, dist + n + 1, 1e9+1); //数据最大必须要超过这个，不然太小就有数据通过不了QAQ
dijkstra(s);
for (int i = 1; i <= n; i++) {
cout << dist[i] << " ";
}
cout << endl;
return 0;
}
旅行商问题：
视频讲解：https://www.bilibili.com/video/BV1ne411i7gG/?spm_id_from=333.337.search-card.all.click
博客：https://blog.csdn.net/qq_39559641/article/details/101209534
思路：
是旅行商问题，但是差别是它最后不用返回到起点，所以最后当集合为空的时候表示已经经历过了所有的点；
旅行商最后集合为空表示这个点直达起点。
还有就是用一个int32位来表示状态，
怎么判断城市i（从0开始）在集合中：1<<i & status ,i左移与status相与得出结果
从集合中删除城市i: 1<<i ^ status ,i左移与status异或得出结果
代码：
#include<iostream>
#include <cmath>
using namespace std;
const int maxN = 2e5 + 7;
int n; //n个点
double pos[16][2]; // 每个点的横纵坐标，可能会有小数
//int dp[i][V] ; 保存顶点i到集合s最后回到起始点的最小距离
double d[16][1 << 16]; // 备忘录式的动态规划，保存dp结果，最多有16个点，子集有2^16个
// 计算第i个点与第j个点之间的直线距离
double dist(int i, int j) {
double dx = pos[i][0] - pos[j][0];
double dy = pos[i][1] - pos[j][1];
return sqrt(dx * dx + dy * dy);
}
// 计算从start开始经过集合vSet，（最后不回到起始顶点）的最小距离
// 用一个4子节的vSet，共32位，来表示集合
// 判断点i是否在集合中 (1>>i)&vSet==0表示不在，(1>>i)&!=0表示在
double dp(int start, int vSet) {
//如果这个数据以前计算过，就直接返回
if (d[start][vSet] != -1) {
return d[start][vSet];
}
//如果这个数据没计算过，开始计算
if (vSet == 0) { // 集合为空表示已经到达最后一个点，距离为0
d[start][vSet] = 0;
//如果最后还要回到起点，那么集合为空时，就表示直达起点：d[start][vSet] = dist(start,0);
} else { //集合不空，遍历集合中每一个顶点
double minNum = 2e9;
for (int i = 0; i <= n; i++) {
// 如果点i在集合中，将它取出来
if ((1 << i & vSet) != 0) { // 这里要加括号，因为!=优先级比较高，会先计算它
int newSet = vSet ^ (1 << i); // 将 i点（从0开始）从集合中删除，用异或
minNum = min(minNum, dist(start, i) + dp(i, newSet));
}
}
d[start][vSet] = minNum;
}
return d[start][vSet];
}
int main() {
cin >> n;
// 初始化坐标0点
pos[0][0] = 0;
pos[0][1] = 0;
// 输入n个点
for (int i = 1; i <= n; i++) {
cin >> pos[i][0] >> pos[i][1];
}
// //给二维数组赋初值
for (int i = 0; i <= n; i++) {
for (int j = 0; j < (1 << 16); j++) {
d[i][j] = -1;
}
}
// 初始集合是111110，表示dp[0,{1,2,3,4}]，从0开始到集合的距离
int set = (1 << (n + 1)) - 2;
printf("%.2lf\n", dp(0, set));
return 0;
}
暴力方法是枚举每个元素，判断是否是鞍点
方法二：是用两个数组分别保存每一行的最大元素所在列，与每一列最小元素所在行
代码：
#include<iostream>
using namespace std;
int main() {
// 暴力方法是枚举每个元素，判断是否是鞍点
// 方法二：是用两个数组分别保存每一行的最大元素所在列，与每一列最小元素所在行
int maxCol[5], minRow[5];
int a[5][5];
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
cin >> a[i][j];
}
}
for (int i = 0; i < 5; i++) {
// 找每一行最大的元素 所在的列
int maxc = 0;
for (int j = 1; j < 5; j++) {
if (a[i][j] > a[i][maxc]) {
maxc = j;
}
}
maxCol[i] = maxc;
}
for (int i = 0; i < 5; i++) {
// 找每一列最小的元素 所在的行
int minr = 0;
for (int j = 1; j < 5; j++) {
if (a[j][i] < a[minr][i]) {
minr = j;
}
}
minRow[i] = minr;
}
bool flag = false;
// 对于每一行最大的元素，判断它是否是所在列中的最小值
for (int i = 0; i < 5; i++) {
int column = maxCol[i];
if (i == minRow[column]) {
cout << i + 1 << " " << column + 1 << " " << a[i][column] << endl;
flag = true;
}
}
if (!flag) {
cout << "not found" << endl;
}
return 0;
}
可以先输出n，判断是否为0，然后进入循环
也可以while(true),然后输入n，如果为0，就break跳出循环
代码：
#include<iostream>
#include <algorithm>
using namespace std;
// 重写比较函数
bool cmp(const int &a, const int &b) {
return abs(a) > abs(b);
}
int main() {
int a[100] = {0};
while (true) {
int n;
cin >> n;
if (n == 0) {
break;
}
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n, cmp);
for (int i = 0; i < n; i++) {
cout << a[i] << " ";
}
cout << endl;
}
return 0;
}
注意多组输入是怎么结束的
代码:
#include<iostream>
#include <algorithm>
using namespace std;
int main() {
int m, n;
while (cin >> m >> n) { //多组输入，按住ctrl+D取消输入
bool flag = false;
for (int i = m; i <= n; i++) {
int a = i / 100;
int b = i / 10 % 10;
int c = i % 10;
if (i == a * a * a + b * b * b + c * c * c) {
cout << i << " ";
flag = true;
}
}
if (!flag) {
cout << "no" << endl;
}
cout << endl;
}
return 0;
}
如果是合并石头，求合并石头的最小代价，那么就是动态规划，用三层for循环来做，但是这个是求胶水代价，等于两个石头的乘积而不是和。
代码：
#include<iostream>
#include <algorithm>
using namespace std;
int main() {
int n;
cin >> n;
if (n == 1) {
return 0;
}
long sum;
cin >> sum; //第一个石头的重量
long long cost = 0;
int num;
// 从第二个石头开始合并
for (int i = 1; i < n; i++) {
cin >> num;
cost += sum * num;
sum += num;
}
cout << cost << endl;
return 0;
}
要注意在查找的时候压缩路径，把路径经过的节点摘下来，直接指向根节点。
在合并的时候，尽可能把高度小的合并到高度大的上去。
代码：
#include<iostream>
#include <algorithm>
using namespace std;
const int maxN = 1e4 + 1;
int vset[maxN];
// 找到元素x所在并查集的根节点，并加上路径压缩：所经过的路径上的节点的父亲都指向根
int find(int x) {
int tmp = x;
// 先找根
while (x != vset[x]) {
x = vset[x];
}
// 压缩路径
while (tmp != x) {
int f = vset[tmp];
vset[tmp] = x;
tmp = f;
}
return x;
}
// 合并两个元素
void unionSet(int x, int y) {
int f1 = find(x);
int f2 = find(y);
if (f1 == f2) {
return;
}
if (f1 > f2) { // 将数字小的合并到数字大的中去
vset[f2] = f1;
} else {
vset[f1] = f2;
}
}
void f(int z, int x, int y) {
if (z == 1) {
unionSet(x, y);
return;
}
int f1 = find(x);
int f2 = find(y);
if (f1 == f2) {
cout << "Y" << endl;
} else {
cout << "N" << endl;
}
}
int main() {
int n, m;
cin >> n >> m;
// 对并查集进行初始化
for (int i = 0; i <= n; i++) {
vset[i] = i; // 父亲是自己，说明是并查集的树根
}
for (int i = 0; i < m; i++) {
int z, x, y;
cin >> z >> x >> y;
f(z, x, y);
}
return 0;
}
1231
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
