代码随想录算法训练营第62天| 图论 Floyd算法 A*算法

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.小明逛公园

题目链接：97.小明逛公园

思路：动态规划 当前从节点 i 到节点 j 的最短距离，有可能是经过某个中转节点得到的。最短路径可能是经过节点1-k中的节点，每次增加一个节点进行考虑，将中转节点有k的情况加入考虑之后节点i到节点j的距离

代码：

#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.骑士的攻击

题目链接：127.骑士的攻击

#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;
}