Floyd算法：
先前的dijkstra算法和Bellman_ford算法求的是单源最短路径。意思就是只能有一个起点。而Floyd算法求的是多元最短路径，意思就是可以求多个源点到多个终点的多条最短路径。并且Floyd算法对于边权值的正负没有要求。其核心思想是动态规划，首先按照动规五部曲，第一个是明确dp数组及其下标下标的含义。dp[i][j][k]意思是从节点 i 到节点 j 考虑节点1-k为中转节点时所能求得的最短路径，接着是确认递推公式，节点 i 到节点 j 考虑节点1-k为中转节点时所能求得的最短路径有两种方式有两种可能，第一种是从节点 i 到节点 j 的最短路径不过节点 k ，另一种是从节点 i 到节点 j 的最短路径经过节点 k 。这样遍历三维数组即可。
卡码网：97.小明逛公园
思路：动态规划 当前从节点 i 到节点 j 的最短距离，有可能是经过某个中转节点得到的。最短路径可能是经过节点1-k中的节点，每次增加一个节点进行考虑，将中转节点有k的情况加入考虑之后节点i到节点j的距离
代码：
cpp
#include<iostream>
#include<vector>
#include<list>
#include <climits>
using namespace std;
int main(){
int n, m, p1, p2, val;
cin >> n >> m;
vector<vector<vector<int>>> grid(n+1, vector<vector<int>>(n+1, vector<int>(n+1, 10005)));
for(int i=0; i<m; i++){
cin >> p1 >> p2 >> val;
//因为是双向图所以两个方向都要赋值
grid[p1][p2][0] = val;
grid[p2][p1][0] = val;
}
for(int i=0; i<=n; i++) grid[i][i][0]=0;
//确定dp数组及其下标含义 从 i 到 j 以 1-k 为中转节点所得到的最短路径
//两种情况 最短路径要么经过节点k 要么不经过节点k
//确定递推公式 grid[i][j][k] = max(grid[i][j][k-1], grid[i][k][k-1] + grid[k][j][k-1])
//由于要知道上一层考虑节点k的所有情况 所以把k放在最外面
//然后在考虑在k的影响下 从不同的 i 到不同的 j 所得到的最短路径
for(int k=1; k<=n; k++){
for(int i=1; i<=n; i++){
for(int j=1; j<=n; j++){
grid[i][j][k] = min(grid[i][j][k-1], (grid[i][k][k-1] + grid[k][j][k-1]));
}
}
}
int z, start, end;
cin >> z;
while(z>0){
cin >> start >> end;
if(grid[start][end][n] ==10005) cout<<-1<<endl;
else cout<<grid[start][end][n]<<endl;
z--;
}
return 0;
}A*算法：
目的是寻找在特定规则下从某起点到目标节点所需的最小步数。在常规的广度优先遍历中，由于便利的方向取决于队列中元素的排列顺序，所以搜索的形状是一圈一圈搜的，很容易超时，而且时间效率低。A*算法则是朝着终点的方向进行遍历。Astar是一种广搜的改良版，有的Astar是dijkstra的改良版。无权图用广搜，有权图优先考虑dijkstra。Astar的关键在于启发式函数，BFS是漫无目的地一圈一圈搜索，而Astar是有方向性的搜索。启发式函数要影响的就是队列里元素的排序，起点到终点的距离 = 起点到该节点的距离 + 该节点到终点的距离。使用优先级队列可以让每次的队头元素都存储的是距离最近的点。
卡码网：127.骑士的攻击
cpp
#include<iostream>
#include<queue>
#include<string.h>
using namespace std;
int moves[1001][1001];
//骑士可以移动的所有方向
int dir[8][2] = {-2,-1,-2,1,-1,2,1,2,2,1,2,-1,1,-2,-1,-2};
int b1, b2;
struct Knight{
int x,y;
int g,h,f;
//排序 把小的放在前面
bool operator < (const Knight & k) const {
return k.f < f;
}
};
priority_queue<Knight> que;
int Heuristic(const Knight &k){
return (k.x-b1)*(k.x-b1) + (k.y-b2) * (k.y-b2);
}
void astar(const Knight &k){
Knight cur, next;
que.push(k);
while(!que.empty()){
cur = que.top();
que.pop();
if(cur.x==b1 && cur.y==b2) break;//当目前到达的节点是终点之后break
for(int i=0; i<8; i++){
next.x = cur.x + dir[i][0];
next.y = cur.y + dir[i][1];
if(next.x<1||next.x>1000||next.y<1||next.y>1000) continue;
if(!moves[next.x][next.y]){
moves[next.x][next.y] = moves[cur.x][cur.y] + 1;
next.g = cur.g + 5;
next.h = Heuristic(next);
next.f = next.g + next.h;
que.push(next);
}
}
}
}
int main(){
int n, a1, a2;
cin >> n;
while (n--){
cin >> a1 >> a2 >> b1 >>b2;
memset(moves, 0, sizeof(moves));
Knight start;
start.x = a1;
start.y = a2;
start.g = 0;
start.h = Heuristic(start);
start.f = start.g + start.h;
astar(start);
while(!que.empty())que.pop();
cout << moves[b1][b2] << endl;
}
return 0;
}