代码随想录第六十二天

最新推荐文章于 2025-04-07 15:52:16 发布

嘻嘻啰啰

最新推荐文章于 2025-04-07 15:52:16 发布

阅读量1.2k

点赞数 35

分类专栏：算法学习文章标签：算法数据结构图论 c语言

本文链接：https://blog.youkuaiyun.com/2301_80630236/article/details/144503421

版权

算法学习专栏收录该内容

53 篇文章

订阅专栏

Floyd算法

多源最短路径：在一个图中，求出任意两个顶点之间的最短路径长度。求多个起点到多个终点的多条最短路径。

Floyd 算法对边的权值正负没有要求，都可以处理。

Floyd-Warshall 算法,其基本思想是:

对于任意两点 i 和 j 之间的最短路径,要么是直接相连,要么经过其他中间点 k
通过三重循环,枚举所有可能的中间点 k,不断更新 i 到 j 的最短距离

97.小明逛公园

题目描述

小明喜欢去公园散步，公园内布置了许多的景点，相互之间通过小路连接，小明希望在观看景点的同时，能够节省体力，走最短的路径。

给定一个公园景点图，图中有 N 个景点（编号为 1 到 N），以及 M 条双向道路连接着这些景点。每条道路上行走的距离都是已知的。

小明有 Q 个观景计划，每个计划都有一个起点 start 和一个终点 end，表示他想从景点 start 前往景点 end。由于小明希望节省体力，他想知道每个观景计划中从起点到终点的最短路径长度。请你帮助小明计算出每个观景计划的最短路径长度。

输入描述

第一行包含两个整数 N, M, 分别表示景点的数量和道路的数量。

接下来的 M 行，每行包含三个整数 u, v, w，表示景点 u 和景点 v 之间有一条长度为 w 的双向道路。

接下里的一行包含一个整数 Q，表示观景计划的数量。

接下来的 Q 行，每行包含两个整数 start, end，表示一个观景计划的起点和终点。

输出描述

对于每个观景计划，输出一行表示从起点到终点的最短路径长度。如果两个景点之间不存在路径，则输出 -1。

输入示例

输出示例

4
-1

提示信息

从 2 到 3 的路径长度为 4，3 到 4 之间并没有道路。

1 <= N, M, Q <= 1000.

1 <= w <= 10000.

思路：

这道题我们用Floyd算法解决最短路径问题，使用了一个三维数组来存储状态。我们先把所有点对之间的距离初始化为一个很大的值表示不连通，然后读入实际的边的信息，因为是无向图所以要同时设置两个方向的距离。之后把每个点到自己的距离设为0，然后开始核心的Floyd算法：逐个考虑每个可能的中转点k，对于任意两点i和j，判断是直接从i到j的距离更短，还是经过中转点k（即从i到k再从k到j）的总距离更短，选择较短的那个更新距离。三维数组的第三维k表示当前允许经过的节点编号范围是1到k，这样不仅记录了最终的最短路径，还保存了所有的中间状态。最后查询时，如果两点间的距离还是初始的大值就说明不连通，输出-1，否则输出最短距离。

解答：

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#define MAX 100005
int main()
{
    int n,m,u,v,w;
    scanf("%d %d",&n,&m);
    int*** grid = malloc(sizeof(int**)*(n+1));
    for(int i = 0;i <= n;i++)
    {
        grid[i] = malloc(sizeof(int*)*(n+1));
        for(int j = 0;j <= n;j++)
        {
            grid[i][j] = malloc(sizeof(int)*(n+1));
            for(int k = 0;k <= n;k++)
            {
                grid[i][j][k] = MAX;
            }
        }
    }
    for(int i = 0;i < m;i++)
    {
        scanf("%d %d %d",&u,&v,&w);
        grid[u][v][0] = w;
        grid[v][u][0] = w;
    }
    for(int i = 1; i <= n; i++) {
        grid[i][i][0] = 0;
    }
    for(int k = 1;k <= n;k++)
    {
        for(int j = 1;j <= n;j++)
        {
            for(int i = 1;i <= n;i++)
            {
                if (grid[i][k][k-1] != MAX && grid[k][j][k-1] != MAX) {
                    grid[i][j][k] = fmin(grid[i][j][k-1], grid[i][k][k-1] + grid[k][j][k-1]);
                } else {
                    grid[i][j][k] = grid[i][j][k-1];
                }
            }
        }
    }
    
    int start,end;
    int q;
    scanf("%d",&q);
    for(int i = 0;i < q;i++)
    {
        scanf("%d %d\n",&start,&end);
        if(grid[start][end][n] == MAX)
        {
            printf("-1\n");
        }
        else
        {
            printf("%d\n",grid[start][end][n]);
        }
    }
}

A* 算法

Astar 是一种广搜的改良版。

如果是无权图（边的权值都是1）那就用广搜，代码简洁，时间效率和 dijkstra 差不多（具体要取决于图的稠密）

如果是有权图（边有不同的权值），优先考虑 dijkstra。

而 Astar 关键在于启发式函数，也就是影响广搜或者 dijkstra 从容器（队列）里取元素的优先顺序。

常见的启发函数

曼哈顿距离: |x1-x2| + |y1-y2|
欧几里得距离: √((x1-x2)² + (y1-y2)²)
切比雪夫距离: max(|x1-x2|, |y1-y2|)

127.骑士的攻击

题目描述

在象棋中，马和象的移动规则分别是“马走日”和“象走田”。现给定骑士的起始坐标和目标坐标，要求根据骑士的移动规则，计算从起点到达目标点所需的最短步数。

棋盘大小 1000 x 1000（棋盘的 x 和 y 坐标均在 [1, 1000] 区间内，包含边界）

输入描述

第一行包含一个整数 n，表示测试用例的数量，1 <= n <= 100。

接下来的 n 行，每行包含四个整数 a1, a2, b1, b2，分别表示骑士的起始位置 (a1, a2) 和目标位置 (b1, b2)。

输出描述

输出共 n 行，每行输出一个整数，表示骑士从起点到目标点的最短路径长度。

输入示例

输出示例

提示信息

骑士移动规则如图，红色是起始位置，黄色是骑士可以走的地方。

思路：

这是一个在1000×1000棋盘上找马从起点到终点最少步数的问题。马走日字形状，可以往8个方向跳，要么先走一格再走两格，要么先走两格再走一格。因为棋盘太大，用普通的广度优先搜索可能会遍历太多无用的位置，所以这里用了A算法来指导搜索方向。A算法的做法是每次都选择最有希望的位置继续探索，这个"最有希望"是通过两个值来衡量的：一个是已经走的步数乘以5（称为g值），另一个是当前位置到终点的直线距离的平方（称为h值）。g值加上h值就是总的预计代价f值，每次都选择f值最小的位置继续探索，这样搜索就会倾向于朝着终点的方向进行。我们用一个数组记录访问过的位置避免重复访问，用优先队列存储待访问的位置以方便获取f值最小的位置。当找到终点时，记录的步数就是所需的最少步数。

解答：

#include <stdio.h>
#include <string.h>

#define MAXN 1000001
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;

typedef struct {
    int x, y;
    int g, h, f;
} Knight;

Knight queue[MAXN];
int front, rear;

void initQueue() {
    front = rear = 0;
}

void push(Knight k) {
    int i = rear;
    while(i > front && queue[i-1].f > k.f) {
        queue[i] = queue[i-1];
        i--;
    }
    queue[i] = k;
    rear++;
}

Knight pop() {
    return queue[front++];
}

int isEmpty() {
    return front == rear;
}

int Heuristic(Knight k) {
    return (k.x - b1) * (k.x - b1) + (k.y - b2) * (k.y - b2);
}

void astar(Knight k)
{
    Knight cur, next;
    initQueue();
    push(k);
    
    while(!isEmpty())
    {
        cur = pop();
        if(cur.x == b1 && cur.y == b2)
            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;
                push(next);
            }
        }
    }
}

int main()
{
    int n, a1, a2;
    scanf("%d", &n);
    while (n--) {
        scanf("%d %d %d %d", &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);
        printf("%d\n", moves[b1][b2]);
    }
    return 0;
}