问题描述:
> 给定一个有向带权图 `G=(V,E)`,其中每条边的权是一个非负实数。另外,给定 `V` 中的一个顶点,称为源点。现在要计算从源点到所有其它各个顶点的最短路径长度,这里的路径长度是指路径上经过的所有边上的权值之和。
----
**Dijkstra算法思想:** 按各个顶点与源点之间路径长度的递增次序,生成源点到各个顶点的最短路径的方法,即先求出长度最短的一条路径,再参照它求出长度次短的一条路径,依此类推,直到从源点到其它各个顶点的最短路径全部求出为止。
----
**算法设计**:
- 源点u 。集合S中的顶点到源点的最短路径的长度已经确定,集合V-S中所包含的顶点到源点的最短路径的长度待定。
- 特殊路径:从源点出发只经过S中的点到达V-S中的点的路径。
- 贪心策略:选择特殊路径长度最短的路径,将其相连的V-S中的顶点加入到集合S中。
**求解步骤:**
- 步骤1:设计合适的数据结构。带权邻接矩阵C,即如果< u, x >E,令 `C[u][x]=<u, x >` 的权值,否则,`C[u][x]=无穷`;采用数组dist来记录从源点到其它顶点的最短路径长度;采用数组p来记录最短路径;
- 步骤2:初始化。令集合S={u},对于集合V-S中的所有顶点x,设置`dist[x]=C[u][x]` ;如果顶点i与源点相邻,设置 `p[i]=u` ,否则 `p[i]=-1`;
- 步骤3:在集合V-S中依照贪心策略来寻找使得dist[x]具有最小值的顶点t,t就是集合V-S中距离源点u最近的顶点。
- 步骤4:将顶点t加入集合S中,同时更新集合V-S;
- 步骤5:如果集合V-S为空,算法结束;否则,转步骤6;
- 步骤6:对集合V-S中的所有与顶点t相邻的顶点x,如果`dist[x]>dist[t]+C[t][x]`,则`dist[x]=dist[t]+C[t][x]`并设置`p[x]=t`。转步骤3。
----
```java
public class Dijkstra {
private static final int N = Integer.MAX_VALUE;
private static final int[][] Graph = {
{0, 1, 5, N, N, N, N, N, N},
{1, 0, 3, 7, 5, N, N, N, N},
{5, 3, 0, N, 1, 7, N, N, N},
{N, 7, N, 0, 2, N, 3, N, N},
{N, 5, 1, 2, 0, 3, 6, 9, N},
{N, N, 7, N, 3, 0, N, 5, N},
{N, N, N, 3, 6, N, 0, 2, 7},
{N, N, N, N, 9, 5, 2, 0, 4},
{N, N, N, N, N, N, 7, 4, 0}};
public static void main(String[] args) {
dijkstra(0, Graph);
}
/**
* Dijkstra最短路径。 即图中"节点vs"到其它各个节点的最短路径。
*
* @param vs 起始节点
* @param Graph 图
*/
public static void dijkstra(int vs, int[][] Graph) {
int NUM = Graph[0].length;
// 前驱节点数组
int[] prenode = new int[NUM];
// 最短距离数组
int[] mindist = new int[NUM];
// 该节点是否已经找到最短路径
boolean[] find = new boolean[NUM];
int vnear = 0;
for (int i = 0; i < mindist.length; i++) {
prenode[i] = i;
mindist[i] = Graph[vs][i];
find[i] = false;
}
find[vs] = true;
for (int v = 1; v < Graph.length; v++) {
// 每次循环求得距离vs最近的节点vnear和最短距离min
int min = N;
for (int j = 0; j < Graph.length; j++) {
if (!find[j] && mindist[j] < min) {
min = mindist[j];
vnear = j;
}
}
find[vnear] = true;
// 根据vnear修正vs到其他所有节点的前驱节点及距离
for (int k = 0; k < Graph.length; k++) {
if (!find[k] && (min + Graph[vnear][k]) < mindist[k]) {
prenode[k] = vnear;
mindist[k] = min + Graph[vnear][k];
}
}
}
for (int i = 0; i < NUM; i++) {
System.out.println("v" + vs + "...v" + prenode[i] + "->v" + i + ", s=" + mindist[i]);
}
}
}
```
----
- 1 设计接口
- 1.1 容器接口Container
- 1.2 背包接口Bag
- 1.3 栈接口Stack
- 1.4 队列接口Queue
- 1.5 Union-Find算法接口UF
- 2 实现接口
- 2.1 结点类Node
- 2.2 数组迭代器ArrayIterator
- 2.3 链表迭代器ListIterator
- 2.4 背包(Bag)的实现
- 2.4.1 能动态调整数组大小的Bag
- 2.4.2 链式Bag的实现
- 2.5 栈(Stack)的实现
- 2.5.1 能动态调整数组大小的Stack
- 2.5.2 链式Stack的实现
- 2.6 队列(Queue)的实现
- 2.6.1 能动态调整数组大小的Queue
- 2.6.2 链式Queue的实现
- 2.7 Union-Find算法的实现
- 2.7.1 DefaultUF
- 2.7.2 QuickFindUF
- 2.7.3 QuickUnionUF
- 2.7.4 WeightedQuickUnionUF
- 2.8 测试
- 2.8.1 测试Stack
- 2.8.2 测试Union-Find
- 3 排序算法
- 3.1 定义排序工具的类结构
- 3.2 选择排序
- 3.3 插入排序
- 3.4 希尔排序
- 3.5 归并排序
- 3.5.1 归并排序的合并方法
- 3.5.2 自顶向下的归并排序
- 3.5.3 自底向上的归并排序
- 3.6 快速排序
- 3.6.1 常规快速排序
- 3.6.2 排序前先洗牌
- 3.6.3 快速排序的改进方法-小数据量转成插入排序
- 3.6.4 快速排序的改进方法-三向切分
- 3.7 堆排序
- 3.8 最终的排序工具
- 4 搜索
- 4.1 二分搜索(binarySearch)
- 4.2 优先队列(MaxPriorityQueue)
- 4.3 二叉查找树(BST)
- 4.4 红黑二叉查找树(RedBlackBST)
- 4.5 B-树(BTree)
- 5 图
- 5.1 无向图(Graph)
- 5.2 有向图(Digraph)
- 6 贪心
- Dijkstra算法-单元最短路径
- 7 动态规划
- 7.1 最长公共子序列问题
- 7.2 0-1背包问题
- 7.3 加工顺序问题
- 8 搜索法
- 8.1 图的着色问题
- 8.2 深度优先搜索
- 8.3 回溯法
- 8.3.1 回溯法的算法框架
- 8.3.2 子集树
- 8.3.3 排列树
- 8.3.4 满m叉树(组合树)
- 8.4 广度优先搜索
- 8.5 分支限界法
- 9 随机化算法
- 9.1 数值随机化算法
- 9.2 蒙特卡罗算法
- 9.3 拉斯维加斯算法
- 9.4 舍伍德算法
- 10 数论算法
- 10.1 Stein求最大公约数
- 10.2 矩阵求斐波那切数列
- LeetCode刷题笔记