Code Practice Journal | Day59-60_Graph09 最短路径（待更）

已于 2024-09-02 21:29:46 修改
阅读量307 收藏 2
点赞数 4
分类专栏： Practice 文章标签： 算法 c# 数据结构
于 2024-08-31 21:52:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Janniam/article/details/141752844
版权

1. Dijkstra

1.1 原理与步骤

步骤：

  1. 选取距离源点最近且未被访问过的节点
  2. 标记该节点为已访问
  3. 更新未访问节点到源点的距离
1.2 代码实现

以KamaCoder47题为例
题目：47. 参加科学大会（第六期模拟笔试） (kamacoder.com)

class Program
{
    public static void Main(string[] args)
    {
        //处理输入
        string[] dimensions = Console.ReadLine().Split();
        int n = int.Parse(dimensions[0]);
        int m = int.Parse(dimensions[1]);
        //  visited & minDist & graph
        bool[] visited = new bool[n + 1];
        int[] minDist = new int[n + 1];
        int[][] graph = new int[n + 1][];
        for (int i = 0; i <= n; i++)
        {
            graph[i] = new int[n + 1];
            for (int j = 0; j <= n; j++)
            {
                graph[i][j] = int.MaxValue;
            }
        }
        //  填充
        for (int i = 0; i <= n; i++)
        {
            visited[i] = false;
            if (i == 1) minDist[i] = 0;
            else minDist[i] = int.MaxValue;
        }
        for (int i = 0; i < m; i++)
        {
            string[] edges = Console.ReadLine().Split();
            int start = int.Parse(edges[0]);
            int end = int.Parse(edges[1]);
            int weight = int.Parse(edges[2]);
            graph[start][end] = weight;
        }
        //
        int result = Dj(graph, n, visited, minDist);
        Console.WriteLine(result);
    }

    public static int Dj(int[][] graph, int n, bool[] visited, int[] minDist)
    {
        for (int count = 1; count < n + 1; count++)
        {
            //find min node
            int mindist = int.MaxValue;
            int minnode = 0;
            for (int i = 1; i < n + 1; i++)
            {
                if (visited[i] == false)
                {
                    if (minDist[i] < mindist)
                    {
                        minnode = i;
                        mindist = minDist[i];
                    }
                }
            }
            //update visited
            visited[minnode] = true;
            //update minDist
            for (int i = 1; i < n + 1; i++)
            {
                if (graph[minnode][i] != int.MaxValue)
                {
                    minDist[i] = Math.Min(graph[minnode][i] + mindist, minDist[i]);
                }
            }
            Console.WriteLine(string.Join(" ", minDist));
        }

        return minDist[n] == int.MaxValue ? -1 : minDist[n];
    }
}
1.3 堆优化

1、使用 List<Edge>[] 表示图

Edge结构体

public struct Edge
{
    public int To;    // 邻接顶点
    public int Val;   // 边的权重

    public Edge(int to, int val)
    {
        To = to;
        Val = val;
    }
}

图的表示

List<Edge>[] graph = new List<Edge>[V + 1];
for (int i = 1; i <= V; i++)
{
    graph[i] = new List<Edge>();
}

2、输入处理

3、初始化

int[] minDist = new int[V + 1];
for (int i = 0; i <= V; i++)
{
    minDist[i] = int.MaxValue;
}
minDist[start] = 0;

bool[] visited = new bool[V + 1];

PriorityQueue<int, int> pq = new PriorityQueue<int, int>();
pq.Enqueue(start, 0); // 起点入队，距离为0

4、算法主循环

while (pq.Count > 0)
{
    // 从优先队列中取出距离最小的节点
    pq.TryDequeue(out int currentNode, out int currentDist);

    // 如果已经访问过，跳过
    if (visited[currentNode])
        continue;

    // 标记为已访问
    visited[currentNode] = true;

    // 遍历所有邻接点
    foreach (var edge in graph[currentNode])
    {
        int neighbor = edge.To;
        int weight = edge.Val;

        // 如果未访问且可以通过当前节点更新最短距离
        if (!visited[neighbor] && currentDist + weight < minDist[neighbor])
        {
            minDist[neighbor] = currentDist + weight;
            pq.Enqueue(neighbor, minDist[neighbor]);
        }
    }
}

5、输出

完整代码：

namespace DijkstraAlgorithm
{
    // 定义一个结构体来表示带权重的边
    public struct Edge
    {
        public int To;    // 邻接顶点
        public int Val;   // 边的权重

        public Edge(int to, int val)
        {
            To = to;
            Val = val;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            // 读取顶点数V和边数E
            string[] firstLine = Console.ReadLine().Split();
            int V = int.Parse(firstLine[0]);
            int E = int.Parse(firstLine[1]);

            // 初始化邻接表
            List<Edge>[] graph = new List<Edge>[V + 1];
            for (int i = 1; i <= V; i++)
            {
                graph[i] = new List<Edge>();
            }

            // 读取所有边的信息
            for (int i = 0; i < E; i++)
            {
                string[] edgeInput = Console.ReadLine().Split();
                int p1 = int.Parse(edgeInput[0]);
                int p2 = int.Parse(edgeInput[1]);
                int val = int.Parse(edgeInput[2]);

                // 添加边到邻接表（无向图需要双向添加）
                graph[p1].Add(new Edge(p2, val));
                graph[p2].Add(new Edge(p1, val));
            }

            int start = 1;  // 起点
            int end = V;    // 终点

            // 存储从源点到每个节点的最短距离
            int[] minDist = new int[V + 1];
            for (int i = 0; i <= V; i++)
            {
                minDist[i] = int.MaxValue;
            }
            minDist[start] = 0;

            // 记录顶点是否被访问过
            bool[] visited = new bool[V + 1];

            // 优先队列中存放节点，优先级是源点到该节点的距离
            // 使用C#内置的PriorityQueue，参数为元素类型和优先级类型
            PriorityQueue<int, int> pq = new PriorityQueue<int, int>();
            pq.Enqueue(start, 0); // 起点入队，距离为0

            while (pq.Count > 0)
            {
                // 从优先队列中取出距离最小的节点
                pq.TryDequeue(out int currentNode, out int currentDist);

                // 如果已经访问过，跳过
                if (visited[currentNode])
                    continue;

                // 标记为已访问
                visited[currentNode] = true;

                // 遍历所有邻接点
                foreach (var edge in graph[currentNode])
                {
                    int neighbor = edge.To;
                    int weight = edge.Val;

                    // 如果未访问且可以通过当前节点更新最短距离
                    if (!visited[neighbor] && currentDist + weight < minDist[neighbor])
                    {
                        minDist[neighbor] = currentDist + weight;
                        pq.Enqueue(neighbor, minDist[neighbor]);
                    }
                }
            }

            // 输出结果
            if (minDist[end] == int.MaxValue)
                Console.WriteLine(-1); // 不能到达终点
            else
                Console.WriteLine(minDist[end]); // 到达终点的最短路径
        }
    }
}

2. Bellman_ford

2.1 原理与步骤
2.2 代码实现

以KamaCoder 94题为例
题目：94. 城市间货物运输 I (kamacoder.com)

class Program
{
    public static void Main(string[] args)
    {
        //处理输入
        string[] dimensions = Console.ReadLine().Split();
        int n = int.Parse(dimensions[0]);
        int m = int.Parse(dimensions[1]);
        //minDist
        int[] minDist = new int[n + 1];
        for (int i = 0; i <= n; i++)
        {
            minDist[i] = i == 1 ? 0 : int.MaxValue;
        }
        //edges
        int[][] edges = new int[m][];
        for (int i = 0; i < m; i++)
        {
            edges[i] = new int[3];
            string[] edge = Console.ReadLine().Split();
            edges[i][0] = int.Parse(edge[0]);
            edges[i][1] = int.Parse(edge[1]);
            edges[i][2] = int.Parse(edge[2]);
        }

        //BF
        if (BF(edges, minDist, n - 1))
        {
            Console.WriteLine(minDist[n]);
        }
        else
        {
            Console.WriteLine("unconnected");
        }
    }

    public static bool BF(int[][] edges, int[] minDist, int n)
    {
        bool isUpdate = true;
        int count = 1;
        while (count <= n && isUpdate == true)
        {
            count++;
            isUpdate = false;

            for (int i = 0; i < edges.Length; i++)
            {
                int start = edges[i][0];
                int end = edges[i][1];
                int weight = edges[i][2];
                if (minDist[start] != int.MaxValue)
                {
                    int dist = minDist[start] + weight;
                    if (dist < minDist[end])
                    {
                        minDist[end] = dist;
                        isUpdate = true;
                    }
                }
            }
        }

        return !isUpdate;
    }
}
2.3 队列优化
class Edge
{
    public int To { get; set; }
    public int Weight { get; set; }

    public Edge(int to, int weight)
    {
        To = to;
        Weight = weight;
    }
}

class Program
{
    public static void Main(string[] args)
    {
        string[] input = Console.ReadLine().Split();
        int n = int.Parse(input[0]);
        int m = int.Parse(input[1]);

        List<Edge>[] graph = new List<Edge>[n + 1];
        for (int i = 1; i <= n; i++)
        {
            graph[i] = new List<Edge>();
        }

        bool[] isInQueue = new bool[n + 1];

        for (int i = 0; i < m; i++)
        {
            string[] edgeInput = Console.ReadLine().Split();
            int p1 = int.Parse(edgeInput[0]);
            int p2 = int.Parse(edgeInput[1]);
            int val = int.Parse(edgeInput[2]);

            graph[p1].Add(new Edge(p2, val));
        }

        int start = 1; // 起点
        int end = n;   // 终点

        int[] minDist = new int[n + 1];
        for (int i = 1; i <= n; i++)
        {
            minDist[i] = int.MaxValue;
        }
        minDist[start] = 0;

        Queue<int> queue = new Queue<int>();
        queue.Enqueue(start);
        isInQueue[start] = true;

        while (queue.Count > 0)
        {
            int node = queue.Dequeue();
            isInQueue[node] = false;

            foreach (var edge in graph[node])
            {
                int from = node;
                int to = edge.To;
                int weight = edge.Weight;

                if (minDist[to] > minDist[from] + weight)
                {
                    minDist[to] = minDist[from] + weight;
                    if (!isInQueue[to])
                    {
                        queue.Enqueue(to);
                        isInQueue[to] = true;
                    }
                }
            }
        }

        if (minDist[end] == int.MaxValue)
        {
            Console.WriteLine("unconnected");
        }
        else
        {
            Console.WriteLine(minDist[end]);
        }
    }
}
2.4 应用场景

3. Floyd

3.1 原理与步骤

动态规划

1、动规数组

grid[ i ][ j ][ k ]：节点 i 到节点 j ，以[ 1 ... k]为中间节点的最短距离

2、递推公式

case1：经过节点 k：grid[ i ][ j ][ k ] = grid[ i ][ k ][ k-1] + grid[ k ][ j ][ k-1 ]
case2：不经过节点 k：grid[ i ][ j ][ k ] = grid[ i ][ j ][ k-1]
取最小值

3、初始化

对于图中存在的每一条双向边，其距离为边的两节点无中间节点的最短距离，即grid[ i ][ j ][ 0 ] = m
对于图中不存在边的两个节点，其距离被初始化为整数最大值，即grid[ i ][ j ][ 0 ] = int.MaxValue

4、遍历顺序

由遍历公式可以看出，遍历顺序应该为 k 值从小到大，而对 i 和 j 无固定要求

3.2 代码实现

以KamaCoder 97题为例
题目：97. 小明逛公园 (kamacoder.com)

class Program
{
    public static void Main(string[] args)
    {
        //处理输入&初始化
        string[] dimensions = Console.ReadLine().Split();
        int v = int.Parse(dimensions[0]);
        int e = int.Parse(dimensions[1]);
        int[,,] grid = new int[v + 1, v + 1, v + 1];
        for (int i = 0; i <= v; i++)
        {
            for (int j = 0; j <= v; j++)
            {
                for (int k = 0; k <= v; k++)
                {
                    grid[i, j, k] = int.MaxValue;
                }
            }
        }
        for (int i = 0; i < e; i++)
        {
            string[] edge = Console.ReadLine().Split();
            int n1 = int.Parse(edge[0]);
            int n2 = int.Parse(edge[1]);
            int w = int.Parse(edge[2]);
            grid[n1, n2, 0] = w;
            grid[n2, n1, 0] = w;
        }
        //输出列表
        int count = int.Parse(Console.ReadLine());
        int[][] outresult = new int[count][];
        for (int i = 0; i < count; i++)
        {
            outresult[i] = new int[2];
            string[] nodes = Console.ReadLine().Split();
            outresult[i][0] = int.Parse(nodes[0]);
            outresult[i][1] = int.Parse(nodes[1]);
        }

        //递推
        for (int k = 1; k <= v; k++)
        {
            for (int i = 1; i <= v; i++)
            {
                for (int j = 1; j <= v; j++)
                {
                    int c1, c2;
                    if (grid[i, k, k - 1] != int.MaxValue && grid[k, j, k - 1] != int.MaxValue) c1 = grid[i, k, k - 1] + grid[k, j, k - 1];
                    else c1 = int.MaxValue;
                    c2 = grid[i, j, k - 1];
                    grid[i, j, k] = Math.Min(c1, c2);
                }
            }
        }

        //输出
        for (int i = 0; i < count; i++)
        {
            int result = grid[outresult[i][0], outresult[i][1], v];
            Console.WriteLine(result == int.MaxValue ? -1 : result);
        }
    }
}

4. A*

4.1 原理与步骤
4.2 代码实现

5. 总结

ふふ_
关注
专栏目录
ts12_Multi-step Forecast_sktime_bold_Linear Regress_sMAPE MASE_warn_plotly acf vlines_season_summary
Linli522362242的专栏
01-12 1737
Linear_Elastic Net_Ridge_Huber_Lasso Regression_ForecastingHorizon_Deseasonalizer_Detrender_NaiveForecaster_ make_reduction _TransformedTargetForecaster_test_heteroskedasticity_test_serial_correlation_bse(std err)_SARIMAX
Code Practice Journal | Day51__Graph02
Janniam的博客
08-23 409
岛屿数量；岛屿最大面积
Code Practice Journal | Day53_Graph04
Janniam的博客
08-25 386
【代码】Code Practice Journal | Day53_Graph04。
Code Practice Journal | Day 56_Graph06
Janniam的博客
08-28 230
并查集
Code Practice Journal | Day52_Graph03
Janniam的博客
08-24 325
【代码】Code Practice Journal | Day52_Graph03。
Code Practice Journal | Day58_Graph08 Topological Sorting
Janniam的博客
08-30 223
在一个有向无环图(DAG)中，根据节点的依赖关系，对所有的节点进行线性排序的算法。以KamaCoder 117.软体构建。拓扑排序的结果不一定是唯一的。
Code Practice Journal | Day57_Graph07 Minimum Spanning Tree
Janniam的博客
08-29 314
给定的图中选择一些边，使边连接图中所有节点但不成环，形成的子图即为生成树。不在：此边加入生成树，并合并两个节点所在连通分量。从队列中选择权重最小的边，并检查这条边是否连接了一个未访问的节点。是：将该节点标记为已访问，加入已访问节点集合。所有可能的生成树中，权重和最小的生成树即为最小生成树。依次选择边，检查边的两个节点是否在统一连通分量中。已访问节点集合到未访问节点集合的最短距离。使用并查集来管理连接节点并检查是否成环。将所有连接到已访问节点集合的边加入队列。选择一个起始节点，标记为已访问。
全日制英国硕士词汇篇V1.3（持续更新）
热门推荐
欢迎！欢迎来到17号城市！
03-05 6万+
下面的所有词汇与例句都是在英国留学期间， 学到的、听到的、见到的，都来自英语母语使用者，其中包括： 学校、同学、教授、教职人员、以及生活中形形色色的人， 这篇文章有助于还没去英国的同学提前掌握一些高频词汇， 以便于在日后的留学生活中更加游刃有余， 对于高频词汇一定要掌握它们的听说读写，形成肌肉记忆。
LLMs：《Building LLM applications for production构建用于生产的LLM应用程序》翻译与解读
近期请国内外头部出版社可尽快私信博主！——心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，谦虚，自律，反思，成长，还算是比较正能量的博主，公益免费传播……内心特别想在AI界做出一些可以推进历史进程影响力的东西(兴趣使然，有点小情怀，也有点使命感呀)…
05-25 3505
​ LLMs：《Building LLM applications for production构建用于生产的LLM应用程序》翻译与解读 LLMs：构建用于生产的LLM应用程序的挑战与案例经验总结——prompt工程面临的挑战(自然语言的模糊性/成本和延迟/提示VS微调VS替代方案/向前和向后兼容性)、任务组合性(多个任务组成的应用/ 代理-工具-控制流)、有前景的应用案例(AI助手、聊天机器人、编程与游戏、提速学习、交互数据【不适合大量数据分析】、搜索和推荐、销售)之详细攻略
Relational inductive biases, deep learning, and graph networks（关系归纳偏差、深度学习和图形网络）
weixin_41697507的博客
07-15 5009
Relational inductive biases, deep learning, and graph networks Peter W. Battaglia1, Jessica B. Hamrick1, Victor Bapst1, Alvaro Sanchez-Gonzalez1, Vinicius Zambaldi1, Mateusz Malinowski1, Andrea Tacche...
人工智能--学术会议排名
Tsingke
12-15 5306
----人工智能领域的学术会议排名--- TitleAcronymRank International Conference on Composite Materials A International Con...
测试集(2)-words
马如林的IT博客
11-26 5万+
 aa.ma.mabandonabandonabattoirabilityabilityableableabnormalabnormalaboardaboardaboutaboutaboveaboveabracadabraabroadabroadabsenceabsenceabsentabsent
What to account for when accounting for algorithms
weixin_42786150的博客
02-28 1687
What to account for when accounting for algorithms
【C++算法】8.双指针_四数之和
hlyd520的博客
10-04 620
后面的步骤类似，就不多赘述了。解法一：排序+暴力枚举+利用。双指针遇到合适的数继续往后走。解法二：排序+双指针。不满足循环条件，跳出。
打卡第四天 P1081 [NOIP2012 提高组] 开车旅行
hjxxlsx的博客
10-06 452
【代码】打卡第四天 P1081 [NOIP2012 提高组] 开车旅行。
数组综合应用（下标计数）C++
hjxxlsx的博客
10-08 957
HJ小学信息学社团每个同学都有且仅有一个数字编号（1~1000），现在帅气的吴老师准备举办n个学习项目，信息学社团的每个同学都参加项目且可以参加多个项目。,9共 9个数分成三组，分别组成三个三位数，且使这三个三位数的比例是 A:B:C，试求出所有满足条件的三个三位数，若无解，输出。n，表示参战的士兵数，1<=n<=1000000，第二行为n个整数，表示每位士兵的战功值（战功值<=1000000）。50、80、50、30分，则80分的士兵为第一名，50分的两名士兵均为第二名，30分的士兵为第四名。
代码随想录算法训练营Day28 | 39. 组合总和、40.组合总和Ⅱ、131.分割回文串
jiabao0520的博客
10-08 1315
训练营第28天：39. 组合总和、40.组合总和Ⅱ、131.分割回文串
c语言练习题2(字符串和函数的使用)
最新发布
m0_74859128的博客
10-10 295
回文函数用于判断一个给定的字符串是否为回文。输入是一个字符数组（字符串），输出是一个布尔值，表示该字符串是否为回文。编写一个 C 语言程序，计算两个整数在二进制表示中有多少位不同。2. 比较这两个整数在二进制表示中的每一位（共32位）是否不同。1. 提示用户输入两个整数。3. 统计不同的位的数量。4. 输出不同的位数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值