1. 图的深度优先遍历
深度优先遍历用递归+记忆化
网格结构的 DFS 与二叉树的 DFS 最大的不同之处在于，遍历中可能遇到遍历过的结点。这是因为，网格结构本质上是一个「图」，我们可以把每个格子看成图中的结点，每个结点有向上下左右的四条边。在图中遍历时，自然可能遇到重复遍历结点。
这时候，DFS 可能会不停地「兜圈子」，永远停不下来，如下图所示：
如何避免这样的重复遍历呢？答案是标记已经遍历过的格子。以岛屿问题为例，我们需要在所有值为 1 的陆地格子上做 DFS 遍历。每走过一个陆地格子，就把格子的值改为 2，这样当我们遇到 2 的时候，就知道这是遍历过的格子了。也就是说，每个格子可能取三个值：
0 ------ 海洋格子
1 ------ 陆地格子（未遍历过）
2 ------ 陆地格子（已遍历过）
java
void dfs(int[][] grid, int r, int c) {
// 判断 base case
if (!inArea(grid, r, c)) {
return;
}
// 如果这个格子不是岛屿，直接返回
if (grid[r][c] != 1) {
return;
}
grid[r][c] = 2; // 将格子标记为「已遍历过」
// 访问上、下、左、右四个相邻结点
dfs(grid, r - 1, c);
dfs(grid, r + 1, c);
dfs(grid, r, c - 1);
dfs(grid, r, c + 1);
}
// 判断坐标 (r, c) 是否在网格中
boolean inArea(int[][] grid, int r, int c) {
return 0 <= r && r < grid.length
&& 0 <= c && c < grid[0].length;
}经典例题是leet200，130
2. BFS广度优先遍历也叫拓扑排序
广度优先遍历用队列和邻接表
算法流程：
1、在开始排序前，扫描对应的存储空间（使用邻接表），将入度为 000 的结点放入队列。
2、只要队列非空，就从队首取出入度为 000 的结点，将这个结点输出到结果集中，并且将这个结点的所有邻接结点（它指向的结点）的入度减 111，在减 111 以后，如果这个被减 111 的结点的入度为 000 ，就继续入队。
3、当队列为空的时候，检查结果集中的顶点个数是否和课程数相等即可。
（思考这里为什么要使用队列？如果不用队列，还可以怎么做，会比用队列的效果差还是更好？）
在代码具体实现的时候，除了保存入度为 000 的队列，我们还需要两个辅助的数据结构：
1、邻接表：通过结点的索引，我们能够得到这个结点的后继结点；
2、入度数组：通过结点的索引，我们能够得到指向这个结点的结点个数。
这个两个数据结构在遍历题目给出的邻边以后就可以很方便地得到。
java
//返回的是拓扑排序结果,numNode表示节点，side表示边的集合
//side为[[1,0],[2,0],[3,1],[3,2]]，边1->0，2->0,3->1,3->2
public int[] BFS(int numNode,int[][] side){
//1.初始化邻接表
HashSet<Integer>[] adj=new HashSet[numNode];
for(int i=0;i<numNode;i++){
adj[i]=new HashSet<>();
}
//通过边来构建入度数组和邻接表
int[] inDegree=new int[numNode];
for(int[] p:side){
adj[p[0]].add(p[1]);
inDegree[p[1]]++;
}
//在队列中存入入度为0的节点
Queue<Integer> queue=new LinkedList<>();
for(int i=0;i<numNode;i++){
if(inDegree[i]==0) {
queue.offer(i);
}
}
//构建输出的数组
int res=new int[numNode];
int count=0;
while(!queue.isEmpty()){
//弹出当前入度为0的点
Integer head=queue.poll();
res[count]=head;
count++;
//对该点所连接的其他点进行入度减一，之后进行判断入度是否为0
Set<Integer> successors=adj[head];
for(Integer nextNode:successors){
inDegree[nextNode]--;
//检测该节点的入度是否为0
if(inDegree[nextNode]==0){
queue.offer(nextNode);
}
}
}
//判断结果集中元素个数能否等于全部节点数目
if(count==numNode){
return res;
}
//此时有向图中存在环，不能够进行拓扑排序
return new int[0];
}经典题目：Leet207
广度优先遍历/拓扑遍历
3. 弗洛伊德（Floyd）算法：求最短路径
弗洛伊德算法作为求最短路径的经典算法，其算法实现相比迪杰斯特拉等算法是非常优雅的，可读性和理解都非常好。
基本思想：
弗洛伊德算法定义了两个二维矩阵：
矩阵D记录顶点间的最小路径
例如D[0][3]= 10，说明顶点0 到 3 的最短路径为10；
矩阵P记录顶点间最小路径中的中转点
例如P[0][3]= 1 说明，0 到 3的最短路径轨迹为：0 -> 1 -> 3。
它通过3重循环，k为中转点，v为起点，w为终点，循环比较D[v][w] 和 D[v][k] + D[k][w] 最小值，如果D[v][k] + D[k][w] 为更小值，则把D[v][k] + D[k][w] 覆盖保存在D[v][w]中。伪代码
- 初始化距离矩阵
dist，将节点间的直接距离填入矩阵中。 - 对于每一个中间节点
k：- 对于每一对节点
(i, j)：- 更新
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])
- 更新
- 对于每一对节点
下面是Floyd算法的java代码
java
import java.util.Arrays;
public class FloydWarshall {
final static int INF = 99999; // 用于表示两节点间不可达
public void floydWarshall(int graph[][]) {
int V = graph.length;
int dist[][] = new int[V][V];
// 初始化距离矩阵
for (int i = 0; i < V; i++) {
for (int j = 0; j < V; j++) {
dist[i][j] = graph[i][j];
}
}
// 更新距离矩阵
for (int k = 0; k < V; k++) {
for (int i = 0; i < V; i++) {
for (int j = 0; j < V; j++) {
if (dist[i][k] + dist[k][j] < dist[i][j]) {
dist[i][j] = dist[i][k] + dist[k][j];
}
}
}
}
// 打印最终的距离矩阵
printSolution(dist);
}
void printSolution(int dist[][]) {
System.out.println("Following matrix shows the shortest distances between every pair of vertices:");
for (int i = 0; i < dist.length; i++) {
for (int j = 0; j < dist.length; j++) {
if (dist[i][j] == INF) {
System.out.print("INF ");
} else {
System.out.print(dist[i][j] + " ");
}
}
System.out.println();
}
}
public static void main(String[] args) {
/* 输入图的邻接矩阵，INF表示两节点间不可达 */
int graph[][] = {
{ 0, 5, INF, 10 },
{ INF, 0, 3, INF },
{ INF, INF, 0, 1 },
{ INF, INF, INF, 0 }
};
FloydWarshall a = new FloydWarshall();
a.floydWarshall(graph);
}
}4. 迪杰斯特拉(Dijkstra)算法求最小路径
Dijkstra 算法的基础知识
- Dijkstra 算法从指定的节点（源节点）出发，寻找它与图中所有其它节点之间的最短路径。
- Dijkstra 算法会记录当前已知的最短路径，并在寻找到更短的路径时更新。
- 一旦找到源节点与其他节点之间的最短路径，那个节点会被标记为"已访问"并添加到路径中。
- 重复寻找过程，直到图中所有节点都已经添加到路径中。这样，就可以得到从源节点出发访问所有其他节点的最短路径方案。
必要条件
Dijkstra 只能用在权重为正的图中，因为计算过程中需要将边的权重相加来寻找最短路径。
如果图中有负权重的边，这个算法就无法正常工作。一旦一个节点被标记为"已访问"，当前访问它的路径就被标记为访问它的最短路径。如果存在负权重，则可能在之后的计算中得到总权重更小的路径，从而影响之前的结果（译注：即可能出现多绕路反而路线更短的情况，不合实际）。
🔸 总结
- 图可以用来建模对象、人或实体之间的连接。它有两个关键要素：节点和边，节点表示对象，边表示对象之间的连接。
- Dijkstra 算法能够寻找出图中指定节点（"源节点"）到所有其他节点的最短路径。
- Dijkstra 算法利用边的权重来做计算，寻找源节点到所有其他节点的总距离最短（总权重最小）的路径。
java代码实现如下：
java
import java.util.*;
class DijkstraAlgorithm {
class Edge {
int target, weight;
Edge(int target, int weight) {
this.target = target;
this.weight = weight;
}
}
public void dijkstra(int graph[][], int src) {
int V = graph.length;
int[] dist = new int[V];
boolean[] sptSet = new boolean[V];
// 初始化所有距离为无穷大，并将所有节点标记为未访问
Arrays.fill(dist, Integer.MAX_VALUE);
dist[src] = 0;
// 优先队列用于选择具有最小距离的未访问节点
PriorityQueue<Integer> pq = new PriorityQueue<>(Comparator.comparingInt(node -> dist[node]));
pq.add(src);
while (!pq.isEmpty()) {
int u = pq.poll();
if (sptSet[u]) continue;
sptSet[u] = true;
for (int v = 0; v < V; v++) {
if (!sptSet[v] && graph[u][v] != 0 && dist[u] != Integer.MAX_VALUE && dist[u] + graph[u][v] < dist[v]) {
dist[v] = dist[u] + graph[u][v];
pq.add(v);
}
}
}
printSolution(dist);
}
void printSolution(int dist[]) {
System.out.println("Vertex \t\t Distance from Source");
for (int i = 0; i < dist.length; i++) {
System.out.println(i + " \t\t " + dist[i]);
}
}
public static void main(String[] args) {
/* 输入图的邻接矩阵 */
int graph[][] = new int[][] {
{ 0, 10, 0, 0, 0, 0 },
{ 10, 0, 5, 0, 0, 15 },
{ 0, 5, 0, 20, 0, 0 },
{ 0, 0, 20, 0, 10, 0 },
{ 0, 0, 0, 10, 0, 5 },
{ 0, 15, 0, 0, 5, 0 }
};
DijkstraAlgorithm t = new DijkstraAlgorithm();
t.dijkstra(graph, 0);
}
}