✅作者简介：大家好我是烫嘴的辛拉面，大家可以叫我拉面。
📜个人主页: 烫嘴的辛拉面的博客
📕系列专栏： 经典算法习题集
🌞为大🔥推荐一款刷题神器哦👉 点击跳转进入网站
前言：我将在专栏 经典算法习题集持续更新，整理牛客网经典算法的习题练习，如果感兴趣请关注专栏。牛客网除了算法题单之外还有其他热门的各种提单，应有尽有，大家快刷起来吧点击跳转进入牛客网
目录
✏️图论
✒️AB13 【模板】拓扑排序
题目描述
描述
给定一个包含nnn个点mmm条边的有向无环图，求出该图的拓扑序。若图的拓扑序不唯一，输出任意合法的拓扑序即可。若该图不能拓扑排序，输出−1-1−1。
输入描述：
第一行输入两个整数n,mn,mn,m ( 1≤n,m≤2⋅1051\le n,m \le 2\cdot 10^51≤n,m≤2⋅105)，表示点的个数和边的条数。
接下来的mmm行，每行输入两个整数ui,viu_i,v_iui,vi (1≤u,v≤n1\le u,v \le n1≤u,v≤n)，表示uiu_iui到viv_ivi之间有一条有向边。
输出描述：
若图存在拓扑序，输出一行nnn个整数，表示拓扑序。否则输出−1-1−1。
示例1
输入： 5 4
1 2
2 3
3 4
4 5
输出：1 2 3 4 5
解题思路
代码实现（Java）
import java.io.*;
import java.util.*;
public class Main {
/**
* 拓扑序
*/
static List<Integer> ans = new ArrayList<>();
public static void main(String[] args) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out));
String[] line = reader.readLine().split(" ");
// 存储点的出度集合
List<List<Integer>> graph = new ArrayList<>();
// 点数
int n = Integer.parseInt(line[0]);
// 边数
int m = Integer.parseInt(line[1]);
// 存储点的入度数
int[] inDegree = new int[n];
// 初始化点
for (int i = 0; i < n; i++) {
// 此处由于点的出度可能有多个,则使用list初始化
graph.add(new ArrayList<>());
}
for (int i = 0; i < m; i++) {
line = reader.readLine().split(" ");
// 边的起始点
int u = Integer.parseInt(line[0]);
// 边的结束点
int v = Integer.parseInt(line[1]);
// v点入度+1
inDegree[v - 1]++;
// u点增加出度,指向v点
graph.get(u - 1).add(v - 1);
}
boolean flag = topologicalSort(graph, inDegree);
if (flag) {
// 是有向无环图,输出拓扑排序
for (int i = 0; i < ans.size(); i++) {
writer.write(String.valueOf(ans.get(i)));
if (i != n - 1) {
writer.write(" ");
}
}
} else {
writer.write("-1");
}
writer.flush();
writer.close();
}
public static boolean topologicalSort(List<List<Integer>> graph, int[] inDegree) {
int num = 0;
Deque<Integer> deque = new ArrayDeque<>();
for (int i = 0; i < inDegree.length; i++) {
// 先找入度为0的点,放入队列
if (inDegree[i] == 0) {
deque.offer(i);
}
}
while (!deque.isEmpty()) {
int u = deque.poll();
// 入度为0的点为起始点
ans.add(u + 1);
for (int i = 0; i < graph.get(u).size(); i++) {
// 获取入度为0的点的出度点
int v = graph.get(u).get(i);
// 这个点的入度减1
inDegree[v]--;
// 寻找下一个入度为0的点
if (inDegree[v] == 0) {
deque.offer(v);
}
}
graph.get(u).clear();
num++;
}
// 若此时输出的结点数不等于有向图中的顶点数，则说明有向图中存在回路，否则输出的顶点的顺序即为一个拓扑序列
return num == inDegree.length;
}
}
✒️AB14 最小生成树
题目描述
描述
一个有 n 户人家的村庄，有 m 条路相互连接着。村里现在要修路，每条路都有一个成本价格，现在请你帮忙计算下，最少需要花费多少钱，就能让这 n 户人家连接起来。
costcostcost 为一个二维数组，每个元素是一个长度为 3 的一维数组 aaa ， a[0]a[0]a[0] 和 a[1]a[1]a[1] 表示村庄 a[0]a[0]a[0] 和村庄 a[1]a[1]a[1] 有一条路，修这条路的成本价格为 a[2]a[2]a[2] 。
每户之间可能有多条道路连接，但不可能自己与自己相连。
数据范围: 1≤n≤5×1031 \le n \le 5 \times 10^31≤n≤5×103 ， 1≤m≤5×1051 \le m \le 5 \times 10^5 1≤m≤5×105 ， 1≤a[2]≤1041 \le a[2] \le 10^4 1≤a[2]≤104
进阶： 时间复杂度 O(n+mlogm)O(n+mlogm)O(n+mlogm) ， 空间复杂度 O(n)O(n)O(n)
示例1
输入：3,3,[[1,3,3],[1,2,1],[2,3,1]]
返回值：2
示例2
输入：2,1,[[1,2,1]]
返回值：1
解题思路
最小生成树，我们可以连通的点看成是同一个并查集，利用并查集的思想来逐渐加边使所有节点连在一起。同时，最小生成树需要用kruskal算法的贪心思想，先对邻接表按照边权递增排序，然后从最小的边开始遍历，检查边的两边是否在同一个并查集中，如果在则不加这条边，如果不在则将这条边加入总边权，同时设置二者属于同一个并查集。
图解
代码实现(Java)
public int miniSpanningTree (int n, int m, int[][] cost) {
// write code here
Arrays.sort(cost,(c1,c2) -> {
return c1[2] - c2[2];
});
UnionFind uf = new UnionFind(n + 1);
int minCost = 0 ;
for(int[] edge : cost) {
if(uf.find(edge[0]) != uf.find(edge[1])) {
minCost += edge[2];
uf.union(edge[0],edge[1]);
}
}
return minCost;
}
class UnionFind {
int[] parent;
public UnionFind(int nums) {
parent = new int[nums];
for(int i = 0 ; i< nums; i++) {
parent[i] = i;
}
}
public int find(int x) {
if(parent[x] != x) {
parent[x] = find(parent[x]);
}
return parent[x];
}
public void union(int x, int y) {
parent[find(x)] = find(y);
}
}
✒️AB15 【模板】单源最短路2
题目描述
描述
给你一个无向图，图中包含 5000 个点 m 个边，任意两个点之间的距离是 w ，无重边或自环。请求出1号点到n号点的最短距离。
注意：图中可能存在孤立点，即存在点与任意点都没有边相连
如果1号点不能到达n号点，输出-1.
第一行两个整数n和m，表示图的点和边数。
接下来m行，每行三个整数u，v, w，表示u到v有一条无向边, 长度为w。
输入描述：
第一行两个整数n和m，表示图的点和边数。
接下来m行，每行三个整数u，v, w，表示u到v有一条无向边, 长度为w。
1≤n≤50001\le n \le 50001≤n≤5000 1≤m≤500001 \le m \le 500001≤m≤50000 1≤w≤100001 \le w \le 100001≤w≤10000
输出描述：
输出一行，表示1到n的最短路，如不存在，输出-1.
示例1
输入：4 4
1 2 3
2 4 7
3 4 5
3 1 3
输出：8
示例2
输入：4 3
1 2 5
2 3 3
3 1 3
输出：-1
说明：
1号点不能到4号点。
解题思路
首先看题目，发现是单源最短路，脑子里面蹦出来几个可行的算法~~~
1.dijstra
完美做出，但条件是不能有负权边，堆优化以后复杂度是O(mlogn)。
2.bellman-ford
主要用于有负权边的情况，理论复杂度是O(nm)，但队列优化以后往往远小于这个复杂度。
3.floyd
多源最短路算法，这里也拿过来一块学了，复杂度是O(n3)O(n3)，所以不应该用多元最短路算法floyd去求高效率的单源最短路。
图解
代码实现(Java)
import java.util.*;
public class Main {
public static final int N = 50000 * 10000 + 1;
static int[][] edges = new int[5001][5001];
static int[] length = new int[5001];
static boolean[] visited = new boolean[5001];
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int n = input.nextInt();
int m = input.nextInt();
int start;
int end;
int weight;
for (int[] ints : edges) {
Arrays.fill(ints, N);
}
for (int i = 0; i < m; i++) {
start = input.nextInt();
end = input.nextInt();
weight = input.nextInt();
edges[start][end] = weight;
edges[end][start] = weight;
}
//定义数组表示到1号点到所有点的距离，默认除了到自己是0外，到其他点的距离都是N
Arrays.fill(length, N);
length[1] = 0;
visited[1] = true;
updateWay(1);
for (int i = 1; i < 5001; i++) {
start = getStart();
if (start == n) {
System.out.println(length[start]);
break;
}
if (start != 0) {
updateWay(start);
}
}
if (!visited[n]) {
System.out.println(-1);
}
}
public static int getStart() {
int min = N;
int start = 0;
for (int i = 1; i < 5001; i++) {
if (!visited[i]) {
//如果这个点还没设为已访问
if (length[i] < min) {
//如果这个点的路径已被更新且更小
start = i;
min = length[i];
}
}
}
visited[start] = true;
//System.out.println("目前可到达的未访问点，" +start+ "距离最近");
return start;
}
//遍历边集，找出各个与start直接相连的未访问点，将距离更新,并将其设为已访问
public static void updateWay(int start) {
for (int i = 1; i < 5001; i++) {
if (!visited[i]) {
if (length[i] > length[start] + edges[start][i]) {
//System.out.printf("%d与%d相连，距离从%d更新为%d\n",start,i,length[i],length[start] + edges[start][i]);
length[i] = length[start] + edges[start][i];
}
}
}
}
}
839
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
