一 . 动态规划算法
适用于求解多阶段决策过程中的最优化问题，必须满足最优化原理、无后效性和重叠性。使用动态规划只需要多项式时间复杂度，因此它比回溯法、暴力法等要快许多。
- 划分阶段：
- 求解最短路径：
- 过程指标函数基本方程(和)：
- Javascript实现算法：
/** * 示例：s = { * 4:{s:{C1:{T:3},C2:{T:4}}}, * 3:{s:{B1:{C1:1,C2:4},B2:{C1:6,C2:3},B3:{C1:3,C2:3}}}, * 2:{s:{A1:{B1:7,B2:4,B3:6},A2:{B1:3,B2:2,B3:4},A3:{B1:4,B2:1,B3:5}}}, * 1:{s:{Q:{A1:2,A2:4,A3:3}}}, * } * * DynamicProgramming(4, s) * * 11: * Q->A2->B1->C1->T; * Q->A3->B1->C1->T; * Q->A3->B2->C2->T; * * @param int k 阶段数 * @param object s 阶段状态集 * @return string */ function DynamicProgramming(k, s) { let indicators = {},//过程指标函数集声明 k0 = k,//阶段数登记 f,//当前k子过程指标函数声明 v;//阶段指标函数声明 for( ; k > 0; k--) { f = {}; for(let i in s[k].s) { f[i] = {//当前k子过程函数在状态s = i时 optValue:0,//最优值 opt:[],//最佳决策 }; for(let j in s[k].s[i]) { v = indicators[k+1] ? indicators[k+1][j].optValue : 0; v = s[k].s[i][j] + v; if (!f[i].optValue || v < f[i].optValue) { f[i].optValue = v; f[i].opt = [j]; } else if (v == f[i].optValue) { f[i].opt.push(j); } } } indicators[k] = f; } return optPath();//输出最后结果 function optPath(k = 0, s = '', preEquivalentPath = '') {//k：阶段数，s：状态，preEquivalentPath：等价路径前缀 let results = '';//结果集初始化 if (k == 0) {//结果集包含最优值 for (let i in indicators[1]) { results += indicators[1][i].optValue + ':\n' + optPath(1, i); } } else if (k > k0) {//结果集包含最优路径终点 results = preEquivalentPath + s + ';\n'; } else {//结果集包含所有最优路径 preEquivalentPath += s + '->'; for (let i in indicators[k][s].opt) { results += optPath(k + 1, indicators[k][s].opt[i], preEquivalentPath); } } return results; } }
二. Floyd算法
Floyd算法又称为插点法，是利用动态规划思想求出它的每两点间的最短路径的算法。 Floyd算法时间复杂度为O(n^3)，空间复杂度为O(n^2)。
- 算法描述：把图用邻接矩阵G表示出来，如果Vi到Vj的边存在，则G[i,j]=该边的权，否则G[i,j]=无穷大；另外，如果Vi、Vj为同一点，则权为0。定义一个矩阵Path用来记录路径信息，Path[i,j]表示从Vi到Vj需要经过的点，初始时Path[i,j] = j。对于任一点Vk，取G[i,j] = min( G[i,j], G[i,k]+G[k,j] )，如果G[i,j]的值变小，则Path[i,j] = Path[i,k]
- 状态转移方程：
G[i,j] = min{G[i,k] + G[k,j], G[i,j]} Path[i,j] = Path[i,k] - 适用范围：
1. 适用于APSP(All Pairs Shortest Paths，多源最短路径) 2. 稠密图效果最佳 3. 边权可正可负
- Javascript实现算法：
/**
* 示例：五个端点按照图的顺序构成一条路经，其5x5邻接矩阵如下：
* g = [
* [0,100,1,100,100],
* [100,0,100,100,4],
* [1,100,0,2,100],
* [100,100,2,0,3],
* [100,4,100,3,0],
* ]
* Floyd(g)
*
* 0-1(1):0->1;
* 0-2(3):0->1->2;
* 0-3(6):0->1->2->3;
* 0-4(10):0->1->2->3->4;
* 1-0(1):1->0;
* 1-2(2):1->2;
* 1-3(5):1->2->3;
* 1-4(9):1->2->3->4;
* 2-0(3):2->1->0;
* 2-1(2):2->1;
* 2-3(3):2->3;
* 2-4(7):2->3->4;
* 3-0(6):3->2->1->0;
* 3-1(5):3->2->1;
* 3-2(3):3->2;
* 3-4(4):3->4;
* 4-0(10):4->3->2->1->0;
* 4-1(9):4->3->2->1;
* 4-2(7):4->3->2;
* 4-3(4):4->3;
*
* @param array g nxn邻接矩阵
* @return string
*/
function Floyd(g) {
let n = g.length,//获取端点的数目
paths = new Array(n);//最短路径初始化
for (let i = 0; i < n; i++) {
paths[i] = new Array(n);
for (let j = 0; j < n; j++) {
paths[i][j] = j;
}
}
for (let k = 0; k < n; k++) {//求邻接矩阵的最短路径距离及最短路径集
for (let i = 0; i < n; i++) {
for (let j = 0; j < n; j++) {
if (g[i][k] + g[k][j] < g[i][j]) {
g[i][j] = g[i][k] + g[k][j];
paths[i][j] = paths[i][k];
}
}
}
}
let optPaths = '',
post;
for (let i = 0; i < n; i++) {//获取最短路径集
for (let j = 0; j < n; j++) {
if (i == j) {
continue;
} else {
optPaths += i + '-' + j + '(' + g[i][j] + '):';
post = i;
while (post != j) {
optPaths += post + '->';
post = paths[post][j];
}
optPaths += j + ';\n';
}
}
}
return optPaths;
}将“求邻接矩阵的最短路径距离及最短路径集”部分代码改成：
for (let i = 0; i < n; i++) {//求邻接矩阵的最短路径距离及最短路径集 for (let j = 0; j < n; j++) { for (let k = 0; k < n; k++) { if (g[i][k] + g[k][j] < g[i][j]) { g[i][j] = g[i][k] + g[k][j]; paths[i][j] = paths[i][k]; } } } }
将出现意外结果如下：
0-1(100):0->1; 0-2(1):0->2; 0-3(3):0->2->3; 0-4(6):0->2->3->4; 1-0(100):1->0; 1-2(100):1->2; 1-3(7):1->4->3; 1-4(4):1->4; 2-0(1):2->0; 2-1(100):2->1; 2-3(2):2->3; 2-4(5):2->3->4; 3-0(3):3->2->0; 3-1(7):3->4->1; 3-2(2):3->2; 3-4(3):3->4; 4-0(6):4->3->2->0; 4-1(4):4->1; 4-2(5):4->3->2; 4-3(3):4->3;
三. Dijkstra算法
Dijkstra(迪杰斯特拉)算法是典型的单源最短路径算法，用于计算一个节点到其他所有节点的最短路径，主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止，该算法要求图中不存在负权边。
- 算法描述：
G = {V, E}，V0为源点 1. 初始时S = {V0}，U = V - S = {其余顶点}，同时S和U也维护各点Vi到V0的距离(下简称Vi的距离，V0的距离为0)。若不存在<V0,Vi>，则距离为无穷大；若存在<V0,Vi>，则Vi的距离为该边的权值 2. 从U中选取一个距离最小的Vk，加入到S中 3. U中余下顶点中若有以Vk作中间顶点，使得从V0到Vk再到Vi的距离之和小于U所标记的Vi的距离，则以前者重新标记U中Vi的距离 4. 重复步骤2、3，直到S中包含所有顶点 - 适用范围：
1. 单源(同一个源点) 2. 不存在负权边
- Javascript实现算法：
/**
* 示例：五个端点按照图的顺序构成一条路经，其5x5邻接矩阵如下：
* g = [
* [0,100,1,100,100],
* [100,0,100,100,4],
* [1,100,0,2,100],
* [100,100,2,0,3],
* [100,4,100,3,0],
* ]
* Dijkstra(g)
*
*
* @param array g nxn邻接矩阵
* @return string
*/
function Dijkstra(g, infinity = 100) {
let n = g.length,//获取顶点的数目
infinityPlus1 = infinity + 1,//端点从g[0]数组中删除标识
s = Array(n);//记录各端点相对于V0的最短路径值及前驱
for (let i = 0; i < n; i++) {
s[i] = [infinity, 0];
}
let mPath,
k;
for (let i = 0; i < n; i++) {//求解k点最短路径，并从g[0]中删除它
mPath = minPath();
k = mPath[0];
s[k][0] = mPath[1];
g[0][k] = infinityPlus1;//标识该端点从g[0]数组中删除
for (let j = 0; j < n; j++) {//查询并处理以k为前驱的j点
if (g[0][j] != infinityPlus1 && s[k][0] + g[k][j] < g[0][j]) {
g[0][j] = s[k][0] + g[k][j];
s[j][1] = k;
}
}
}
return optPaths();//返回最短路径集
function minPath() {//输出g[0]中的最小路径
let path = [infinity, infinity];
for (let i = 0; i < n; i++) {
if (g[0][i] < path[1]) {
path[0] = i;
path[1] = g[0][i];
}
}
return path;
}
function optPaths() {//输出最短路径集
let paths = '',
paths_i,
preNode;
for (let i = 1; i < n; i++) {
paths_i = '';
preNode = i;
while (preNode) {
paths_i = '->' + preNode + paths_i;
preNode = s[preNode][1];
}
paths_i = '0' + paths_i;
paths += '0->' + i + '(' + s[i][0] + '): ' + paths_i + ';\n';
}
return paths;
}
}
四. Bellman-Ford算法
Bellman-Ford算法能在更普遍的情况下（存在负权边）解决单源点最短路径问题。对于给定的带权（有向或无向）图 G=(V,E), 其源点为S，加权函数 w是 边集 E 的映射。对图G运行Bellman - Ford算法的结果是一个布尔值，表明图中是否存在着一个从源点S可达的负权回路。若不存在这样的回路，算法将给出从源点S到图G的任意顶点Vi的最短路径D[Vi]。
- 算法描述：
1. 将除源点S外的所有顶点的最短距离估计值 D[Vi]—>+∞, D[S]—>0 2. 反复对边集E中的每条边进行松弛操作，使得顶点集V中的每个顶点Vi的最短距离估计值逐步逼近其最短距离 3. 判断边集E中的每一条边的两个端点是否收敛。如果存在未收敛的顶点，则算法返回false，表明问题无解；否则算法返回true，并且从源点可达的顶点Vi的最短距离保存在D[Vi]中
- 适用范围：
1. 单源最短路径 2. 有向图和无向图 3. 边权可正可负 4. 差分约束系统
564
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
