2023/5/25个人总结

昨天的最小生成树，需要的一个算法忘提了---克鲁斯卡尔算法。

贪心思想：优先选择权值小的边加入到最小树中，并保证不形成环（用并查集判断）。

P1991 无线通讯网

先构建最小生成树，最后给树中组成权值最大边的站点安装电话即可，相当于删去s-1条大边，剩下的最大边就是答案。代码如下：

#include <iostream>
#include<cstring>
using namespace std;
#include<algorithm>
#include<cmath>
#include <iomanip>

int pre[505];   //并查集

int find(int f) {  
	if (pre[f] == f || pre[f] == 0)return pre[f] = f;
	else return pre[f] = find(pre[f]);
}

typedef struct {  //存储坐标的结点
	int x, y;
}xb;

typedef struct {  //存放边的信息
	int x, y;   //顶点
	double d;   //长度
}eg;
 
xb a[505];      
eg e[250005];
double d[505];   //存放选取出来的最小生成树的边
bool cmp(eg a, eg b) {
	return a.d < b.d;
}

int main() {
	ios::sync_with_stdio(0);

	int s, p;
	cin >> s >> p;
	for (int i = 1; i <= p; i++) {
		cin >> a[i].x >> a[i].y;
	}
	int k = 0;
	for (int i = 1; i <= p - 1; i++) {   //遍历，把可能的每一条边都存储到e数组中
		for (int j = i + 1; j <= p; j++) {
			if (i != j) {
				e[k].x = i;
				e[k].y = j;
				e[k].d = sqrt((a[i].x - a[j].x) * (a[i].x - a[j].x) + (a[i].y - a[j].y) * (a[i].y - a[j].y));
				k++;
			}
		}
	}
	sort(e, e + k, cmp);     //按边长从小到大排序，优先选择长度小的
	int l = 0;
	for (int i = 0; i < k; i++) {
		int f1 = find(e[i].x);
		int f2 = find(e[i].y);
		if (f1 != f2) {
			pre[f2] = f1;
			d[l++] = e[i].d;
		}
	}
	double sum = d[l - 1 - (s - 1)];  
	cout << fixed << setprecision(2) << sum;

	return 0;
}

P2872 [USACO07DEC]Building Roads S

在已有若干条边的情况下，选边构建最小生成树(也可以把给定的边的长度视为0),唯一坑的地方就是计算两点之间的距离时的精度非常重要。

#include <iostream>
#include<cstring>
using namespace std;

//P2872 [USACO07DEC]Building Roads S
#include<cmath>
#include<algorithm>
#include<iomanip>

typedef struct {
	int x, y;
}bb;
bb b[1005];
typedef struct {
	int x, y;
	double d;
}aa;
aa e[1000005];

int pre[1005];

int find(int f) {  
	if (pre[f] == f || pre[f] == 0)return pre[f] = f;
	else return pre[f] = find(pre[f]);
}

bool cmp(aa a, aa b) {
	return a.d < b.d;
}

int main() {
	ios::sync_with_stdio(false);
	int n, m;
	cin >> n >> m;
	int ans = 0;
	for (int i = 1; i <= n; i++) {
		cin >> b[i].x >> b[i].y;
	}
	int k = 0;
	for (int i = 0; i < m; i++) {
		int x, y;
		cin >> x >> y;
		x = find(x);
		y = find(y);
		if (x != y) {
			pre[y] = x;
			ans++;
		}
	}
	
	for (int i = 1; i <= n; i++) {
		for (int j = i + 1; j <= n; j++) {
			e[k].x = i;
			e[k].y = j;
			e[k].d = (double)sqrt((double)(b[i].x - b[j].x) * (b[i].x - b[j].x) + (double)(b[i].y - b[j].y) * (b[i].y - b[j].y));
			k++;
		}
	}
	sort(e, e + k, cmp);

	
	double sum = 0;
	for (int i = 0; i < k; i++) {
		int f1 = find(e[i].x);
		int f2 = find(e[i].y);
		if (f1 != f2) {
			pre[f2] = f1;
			sum += e[i].d;
			ans++;
		}
		if (ans == n - 1)break;
	}
	cout << fixed << setprecision(2) << sum;
	return 0;
}

单源最短路径

dijkstra算法：其中图用链式前向星存储，模板如下：

const int MAX = 1e5 + 5;
const int MAXN = 5e5 + 5;
#define inf 2147483647
int n, m, s;
long long dist[MAX];  //存放起点到各点的最短路径
int visited[MAX];    //标记该点是否访问
struct Edge {
    int to, weight, next;
}edges[MAXN];   
int head[MAX];  //hrad[i]表示以i为起点的最后一条边

int cnt;
void init()//初始化
{
    for (int i = 0; i <= n; i++) head[i] = -1;
    cnt = 0;
}
void add_edges(int u, int v, int w)//加边，u起点，v终点，w边权
{
    edges[cnt].to = v; //终点
    edges[cnt].weight = w; //权值
    edges[cnt].next = head[u];//以u为起点上一条边的编号，也就是与这个边起点相同的上一条边的编号
    head[u] = cnt++;//更新以u为起点上一条边的编号
}

void dijkstra() {
    for (int i = 1; i <= n; dist[i++] = inf);  
    dist[s] = 0;                  // s为源点
    for (int i = 1; i <= n; i++) {
        long long node = 0, lowest = inf;   //inf 为预设最大值
        for (int j = 1; j <= n; ++j) {
            if (!visited[j] && dist[j] < lowest) {
                lowest = dist[j];
                node = j;
            }
        }                          //找到当前距离最小的节点
        visited[node] = 1;
        for (int e = head[node]; e != -1; e = edges[e].next) {
            int v = edges[e].to, w = edges[e].weight;
            if (!visited[v] && dist[node] + w < dist[v]) {
                dist[v] = dist[node] + w;
            }
        }
    }
}

P3371 【模板】单源最短路径（弱化版）

板子题，代码如下：

#include<iostream>
using namespace std;
const int MAX = 1e5 + 5;
const int MAXN = 5e5 + 5;
#define inf 2147483647
int n, m, s;
long long dist[MAX];
int visited[MAX];
int pre[MAX];
struct Edge {
    int to, weight, next;
}edges[MAXN];
int head[MAX];

int cnt;
void init()//初始化
{
    for (int i = 0; i <= n; i++) head[i] = -1;
    cnt = 0;
}
void add_edges(int u, int v, int w)//加边，u起点，v终点，w边权
{
    edges[cnt].to = v; //终点
    edges[cnt].weight = w; //权值
    edges[cnt].next = head[u];//以u为起点上一条边的编号，也就是与这个边起点相同的上一条边的编号
    head[u] = cnt++;//更新以u为起点上一条边的编号
}

void dijkstra() {
    for (int i = 1; i <= n; dist[i++] = inf);
    dist[s] = 0;                  // s为源点， t为目标点。
    for (int i = 1; i <= n; i++) {
        long long node = 0, lowest = inf;   //inf 为预设最大值
        for (int j = 1; j <= n; ++j) {
            if (!visited[j] && dist[j] < lowest) {
                lowest = dist[j];
                node = j;
            }
        }                          //找到当前距离最小的节点
        visited[node] = 1;
        for (int e = head[node]; e != -1; e = edges[e].next) {
            int v = edges[e].to, w = edges[e].weight;
            if (!visited[v] && dist[node] + w < dist[v]) {
                dist[v] = dist[node] + w;
                pre[v] = e;           //修改当前距离
            }
        }
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin >> n >> m >> s;
    int u, v, w;
    init();
    for (int i = 0; i < m; i++) {      
        cin >> u >> v >> w;
        add_edges(u, v, w);
    }
    dijkstra();
    for (int i = 1; i <= n; i++)cout << dist[i] << ' ';

    return 0;

}

P1629 邮递员送信

 题目大意:求1到各个节点的最短路径和各个节点到1的最短路径的总和。
 先从1到各个节点用dijkstra算法，再各个节点到1通过反向建边，再用一次dijkstra。

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;

//P1629 邮递员送信
const int MAX = 1e5 + 5;
struct Edge {   
	int to, w, next;  //终点，权值，上一个
}edge[MAX],edge1[MAX];
int head[1005];  //head[i]表示以i为起点的最后一条边
int head1[1005];
int dist[1005];   //dist[i]从1到i的最短时间
int dist1[1005];   //i到1
int visited[1005]; //visited[i]判断i是否访问
int visited1[1005]; 
int n, m;
int cnt;
void init() {
	for (int i = 0; i <= n; i++)head1[i] = head[i] = -1;
	cnt = 0;
}
void add_edge(int u, int v, int w) {
	edge[cnt].to = v;
	edge[cnt].w = w;
	edge[cnt].next = head[u];
	edge1[cnt].to = u;
	edge1[cnt].w = w;
	edge1[cnt].next = head1[v];
	head1[v] = cnt;
	head[u] = cnt++;
}

void dijkstra() {
	for (int i = 1; i <= n; i++)dist[i] = MAX;
	dist[1] = 0;
	for (int i = 1; i <= n; i++) {
		int node = 0, lowest = MAX;
		for (int j = 1; j <= n; j++) {
			if (!visited[j] && dist[j] < lowest) {
				lowest = dist[j];
				node = j;
			}
		}
		visited[node] = 1;
		for (int e = head[node]; e != -1; e = edge[e].next) {
			int v = edge[e].to, w = edge[e].w;
			if (!visited[v] && dist[v] > dist[node] + w) {
				dist[v] = dist[node] + w;
			}
		}
	}
}

void dijkstra1() {
	for (int i = 1; i <= n; i++)dist1[i] = MAX;
	dist1[1] = 0;
	for (int i = 1; i <= n; i++) {
		int node = 0, lowest = MAX;
		for (int j = 1; j <= n; j++) {
			if (!visited1[j] && dist1[j] < lowest) {
				lowest = dist1[j];
				node = j;
			}
		}
		visited1[node] = 1;
		for (int e = head1[node]; e != -1; e = edge1[e].next) {
			int v = edge1[e].to, w = edge1[e].w;
			if (!visited1[v] && dist1[v] > dist1[node] + w) {
				dist1[v] = dist1[node] + w;
			}
		}
	}
}

int main() {
	ios::sync_with_stdio(false);
	cin >> n >> m;
	int u, v, w;
	init();
	for (int i = 0; i < m; i++) {
		cin >> u >> v >> w;
		add_edge(u, v, w);
		//add_edge(v + n, u + n, w);
	}
	dijkstra();
	dijkstra1();
	long long sum = 0;
	for (int i = 2; i <= n; i++)sum += dist[i] + dist1[i];
	
	cout << sum;
	return 0;
}

还有一个优化版的dijkstra算法，下次再写。。