Dijkstra算法C#实现及其布线运用

最新推荐文章于 2024-01-21 23:48:44 发布
最新推荐文章于 2024-01-21 23:48:44 发布
阅读量179 收藏
点赞数
文章标签： c#
原文链接：http://www.cnblogs.com/xiaoyajiang/p/5950249.html
版权

大家好，我是小鸭酱，博客地址为：http://www.cnblogs.com/xiaoyajiang

以下是空调布线对Dijkstra算法的运用，采用C#实现。

问题：室内机多台，室外机一台。寻找室内机到室外机的最短路径

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Collections;
using System.Windows;
 
namespace shortestPath
{
    class Program
    {
        const double INF = 429496729;//无路径时的权值
        //--------------------------------------------------------------------------------*
        //函数名： Dijkstra                                                                 　　　　           *
        //功  能： 找出室内机组和室外机的最短路径（室内机室外机均指投影到最近的墙上的点）*
        //参  数： cost   ： List<List<double>>类型                                                     *
        //        n:   int型   所有不重合节点个数，也是cost矩阵的阶                                     *
        //        v:   int型   室内机的标号                                                    　　　      　  *
        //        terminals:   List<int>型  许多室外机的标号                         　　　　         *
        //返  回：List<List<int>>类型  每行均为 每个室内机 → 室外机的路径                        *
        //作  者：小鸭酱的书签                                                                   　　　　　　　*
        //时  间：2016年3月28日                                                         　　　　　　　     *
        //修改时间：                                                                      　　　　　　　　　   *
        //---------------------------------------------------------------------------------*
        static List<List<int>> Dijkstra(List<List<double>> cost, int n, int v, List<int> terminals)
        {
            List<List<int>> allRoutes = new List<List<int>>();//保存所有路径
 
            List<double> dist = new List<double>();
            List<int> s = new List<int>();
            List<int> path = new List<int>();
            double mindis;
            int i, j, u, pre;
            for (i = 0; i < n; i++)
            {
                dist.Add(cost[v][i]);
                s.Add(0);
 
                if (cost[v][i] < INF)
                    path.Add(v);
                else
                    path.Add(-1);
            }
 
            s[v] = 1; //室外机编号v放入s中
            path[v] = 0;
            //循环直到所有顶点的最短路径都求出
            for (i = 0; i < n; i++)
            {
                mindis = INF;
                u = -1;
                for (j = 0; j < n; j++) //选取不在s中且具有最小距离的顶点u
                {
                    if (s[j] == 0 && dist[j] < mindis)
                    {
                        u = j;
                        mindis = dist[j];
                    }
                }
 
                if (u != -1) //找到最小距离的顶点u
                {
                    s[u] = 1; //顶点u加入s中
                    for (j = 0; j < n; j++) //修改不在s中的顶点距离
                    {
                        if (s[j] == 0)
                        {
                            if (cost[u][j] < INF && dist[u] + cost[u][j] < dist[j])
                            {
                                dist[j] = dist[u] + cost[u][j];//修改源点到vj的距离
                                path[j] = u;//保存当前最短路径中的前一个顶点编号
                            }
                        }
                    }
                }
            }
 
            //从室内机到室外机的最短路径
            int index = 0;
            for (i = 0; i < n; i++)
            {
                if (i != v)
                {
                    if (s[i] == 1)
                    {
                        List<int> route = new List<int>();
                        pre = i;
                        while (pre != v) //直到求解到初始顶点
                        {
                            if (index < terminals.Count())
                            {
                                if (terminals[index] == i)
                                {
                                    route.Add(pre);
                                }
                            }
                            pre = path[pre];
                        }
                        if (index < terminals.Count())
                        {
                            if (terminals[index] == i)
                            {
                                route.Add(pre);
                            }
                        }
                        if (index < terminals.Count())
                        {
                            if (terminals[index] == i)
                            {
                                allRoutes.Add(route);
                                index++;
                                if (index == terminals.Count())
                                    return allRoutes;
                            }
                        }
                    }
                }
            }
            return allRoutes;
        }
        static void Main(string[] args)  // test
        {
            List<List<double>> cost = new List<List<double>>();
            List<double> l1 = new List<double>() {INF,5,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,1,INF,INF};//1
            List<double> l2 = new List<double>() {5,INF,INF,INF,INF,2,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,4,INF};//1
            List<double> l3 = new List<double>() {INF,INF,INF,5,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,1,2};//1
            List<double> l4 = new List<double>() {INF,INF,5,INF,INF,INF,INF,INF,INF,5,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF};//1
            List<double> l5 = new List<double>() {INF,INF,INF,INF,INF,5,INF,INF,INF,INF,INF,INF,INF,INF,10,INF,INF,INF,INF,INF,INF,1,INF,INF};//1
            List<double> l6 = new List<double>() {INF,2,INF,INF,5,INF,3,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF};//1
            List<double> l7 = new List<double>() {INF,INF,INF,INF,INF,3,INF,5,INF,INF,2,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF};//1
            List<double> l8 = new List<double>() {INF,INF,INF,INF,INF,INF,5,INF,5,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,3};//1
            List<double> l9 = new List<double>() {INF,INF,INF,INF,INF,INF,INF,3,INF,2,INF,INF,2,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF};//1
            List<double> l10 = new List<double>() {INF,INF,INF,5,INF,INF,INF,INF,2,INF,INF,INF,INF,2,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF};//1
            List<double> l11 = new List<double>() {INF,INF,INF,INF,INF,INF,2,INF,INF,INF,INF,4,INF,INF,INF,5,INF,INF,INF,INF,INF,INF,INF,INF};//1
            List<double> l12 = new List<double>() {INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,4,INF,4,INF,INF,INF,5,INF,INF,INF,INF,INF,INF,INF};//1
            List<double> l13 = new List<double>() {INF,INF,INF,INF,INF,INF,INF,INF,2,INF,INF,4,INF,2,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF};//1
            List<double> l14 = new List<double>() {INF,INF,INF,INF,INF,INF,INF,INF,INF,2,INF,INF,2,INF,INF,INF,INF,5,INF,INF,INF,INF,INF,INF};//1
            List<double> l15 = new List<double>() {INF,INF,INF,INF,10,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,2,INF,INF,INF};//1
            List<double> l16 = new List<double>() {INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,5,INF,INF,INF,INF,INF,4,INF,INF,INF,3,INF,INF,INF};//1
            List<double> l17 = new List<double>() {INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,5,INF,INF,INF,4,INF,6,INF,2,INF,INF,INF,INF};//1
            List<double> l18 = new List<double>() {INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,5,INF,INF,6,INF,INF,INF,INF,INF,INF,INF};//1
            List<double> l19 = new List<double>() {INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,8,2,INF,INF,INF};//1
            List<double> l20 = new List<double>() {INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,2,INF,8,INF,INF,INF,INF,INF};//1
            List<double> l21 = new List<double>() {INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,2,3,INF,INF,2,INF,INF,INF,INF,INF};//1
            List<double> l22 = new List<double>() {1,INF,INF,INF,1,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF};//1
            List<double> l23 = new List<double>() {INF,4,1,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF};//1
            List<double> l24 = new List<double>() {INF,INF,2,INF,INF,INF,INF,3,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF,INF};//1
            cost.Add(l1);
            cost.Add(l2);
            cost.Add(l3);
            cost.Add(l4);
            cost.Add(l5);
            cost.Add(l6);
            cost.Add(l7);
            cost.Add(l8);
            cost.Add(l9);
            cost.Add(l10);
            cost.Add(l11);
            cost.Add(l12);
            cost.Add(l13);
            cost.Add(l14);
            cost.Add(l15);
            cost.Add(l16);
            cost.Add(l17);
            cost.Add(l18);
            cost.Add(l19);
            cost.Add(l20);
            cost.Add(l21);
            cost.Add(l22);
            cost.Add(l23);
            cost.Add(l24);
 
            List<int> terminals = new List<int>(){22,23};
 
 
            int v = 21;
 
            List<List<int>> result = new List<List<int>>();
 
        result = Dijkstra(cost, 24, v, terminals);
        }
    }
}

转载于:https://www.cnblogs.com/xiaoyajiang/p/5950249.html

weixin_30492047
关注
基于C# Dijkstra 算法实现的（WinForm）最短路径规划【100012021】
04-25
本程序为 C#语言编写的窗体应用程序(DijkstraForRoutePlanning.exe)，其中包含了一个类库(Dijkstra.dll),若干控件和相应的文件操作以实现目标功能。 本小组项目基于 Dijkstra 算法，以武汉大学范围（文理学部，工学部，信息学部）为例，设计两种模式—地名输入模式和自由选点模式，并根据输入地名或选择点位自动规划出起点与终点间的最短路径在地图上予以显示，同时显示路径转点和总距离。数据源来自 OpenStreetMap,经过 Arcmap 处理。
最短路径—Dijkstra算法（C#）
潇逗
10-19 1万+
前言 ： 因为之前刚写过最小生成树算法，刚开始看到Dijkstra算法的时候，因为要求各点到源点的最短距离，会想着直接从最小生成树的也是每找到最短的距离点加进来，但是后面仔细想了下，又翻了下定义，得到 最短路径是一个图中2个点的最短距离。 最小生成树是连接所有的点的路径最短，但是不一定是任意两点的距离最小，例如： 最小生成树是：A->B->C AC距离是2+2=...
Dijkstra (迪杰斯特拉)算法c#实现方法
l3070937534的博客
05-03 1646
Dijkstra(迪杰斯特拉)算法是典型的单源最短路径算法，用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。Dijkstra算法是很有代表性的最短路径算法 算法思想： 设G=(V,E)是一个带权有向图，把图中顶点集合V分成两组， 第一组为已求出最短路径的顶点集合（用S表示，初始时S中只有一个源点，以后每求得一条最短路径 , 就将加入到集合S中，直到全部顶点都加入到S中，算法就结束了）， 第二组为其余未确定最短路径的顶点集合（用U表示），按最短路径长
基于C#实现Dijkstra算法
神仙别闹的自留地
11-24 984
或许在生活中，经常会碰到针对某一个问题，在众多的限制条件下，如何去寻找一个最优解？可能大家想到了很多诸如“线性规划”，“动态规划”这些经典策略，当然有的问题我们可以用贪心来寻求整体最优解，在图论中一个典型的贪心法求最优解的例子就莫过于“最短路径”的问题。
（迪杰斯特拉）Dijkstra算法详细讲解（转载）
ACM-ICPC 现役(铜牌) Codeforces Rating: 2172
10-02 3299
迪杰斯特拉(Dijkstra)算法是典型最短路径算法，用于计算一个节点到其他节点的最短路径。 它的主要特点是以起始点为中心向外层层扩展(广度优先搜索思想)，直到扩展到终点为止 基本思想 通过Dijkstra计算图G中的最短路径时，需要指定起点s(即从顶点s开始计算)。 此外，引进两个集合S和U。S的作用是记录已求出最短路径的顶点(以及相应的最短路径长度)，而U则是记录还未求出最短路径的顶点(以及该顶点到起点s的距离)。 初始时，S中只有起点s；U中是除s之外的顶点，并且U中顶点的路径是”起点s到该顶点的路
C#实现最短路径Dijkstra算法
03-10
在这个C#实现的项目中，我们将探讨如何在Visual Studio 2010环境下，通过控制台应用程序来实现Dijkstra算法。 Dijkstra算法的基本思想是使用贪心策略，每次选择当前未访问节点中距离起点最近的一个，并更新与它相邻...
Dijkstra算法Java实现示例
最新发布
05-02
以下是Java语言实现Dijkstra算法的一个简单示例，这个示例假设你有一个图的邻接矩阵表示，并且所有边的权重都是正数。 代码定义了一个DijkstraExample类，其中包含了Dijkstra算法的实现。dijkstra方法接受一个图的...
C# 实现 Dijkstra 算法
AnBig_Data的博客
09-17 177
然后，我们遍历该节点的所有邻居节点，并更新它们的最短距离。如果通过当前节点到达邻居节点的路径比之前记录的最短路径更短，则更新最短距离。最后，如果邻居节点不在最短路径集合中，则将其加入优先队列。该方法接受一个表示图的字典和起点节点作为输入，并返回一个存储最短路径距离的字典。字典来存储起点到每个节点的当前最短距离，初始时将起点的距离设置为 0，其他节点的距离设置为无穷大。然后，我们遍历最短路径字典，并输出每个节点及其最短距离。Dijkstra 算法的基本思想是利用贪心策略逐步确定起点到其他节点的最短路径。
C#道路放线计算程序
10-27
利用C#编写的道路放线计算程序，内附测试数据与计算结果。
使用C#实现Dijkstra算法求解最短路径
TechPr的博客
08-13 325
本文提供了使用C#语言实现Dijkstra算法的完整代码，并给出一个使用示例，希望可以对读者理解和应用该算法有所帮助。（6）对于所有与u相邻的节点v，如果D[u]+weight(u,v)
实验十一 电路布线问题
popoywei的博客
03-25 1065
与该扩展结点相邻并可达的方格成为可行结点被加入到活结点队列中，并且将这些方格标记为1，即从起始方格a到这些方格的距离为1。接着，从活结点队列中取出队首结点作为下一个扩展结点，并将与当前扩展结点相邻且未标记过的方格标记为2，并存入活结点队列。对于具体的问题实例，很难预测限界剪枝法的大规模的组合问题在合理的时间内求解。然而，对于具体的问题实例，很难预测限界剪枝法的搜索行为，无法预先判断哪些输入实例可以在合理的时间内求解，哪些输入实例不能在合理的时间内求解。在最坏的情况下，限界剪枝法的时间复杂度是指数阶。
c#Dijkstra(狄克斯特拉）算法实现
D_Sniper的博客
04-14 3124
Dijkstra Dijkstra算法概念 笔者认为Dijkstra 其算法本质广度优先搜索（BFS）。其算法思想为设置两个集合S和T，集合S中存放已找到的最短路径的节点，集合T中存放尚未找到的最短路径的节点。初始状态下，S中只包含源点，然后从集合T中遍历找到源点路径长度（权值）最小的节点U加入到集合S中，T中去除该节点。集合S中每加入一个节点，集合T中各节点的新的最短路径为原来...
GIS算法——C#迪杰斯特拉算法
qq_64733841的博客
12-23 521
【代码】GIS算法——C#迪杰斯特拉算法。
Dijkstra算法详解
a745092253的博客
01-21 6588
此时，S={D(0)}, U={A(∞),B(∞),C(3),E(4),F(∞),G(∞)}。此时，S={D(0),C(3),E(4),F(6)}, U={A(22),B(13),G(12)}。此时，S={D(0),C(3),E(4),F(6),G(12)}, U={A(22),B(13)}。此时，S={D(0),C(3),E(4)}, U={A(∞),B(13),F(6),G(12)}。此时，S={D(0),C(3)}, U={A(∞),B(13),E(4),F(9),G(∞)}。：将顶点D加入到S中。
算法分析 | 分支限界算法设计之布线问题 C语言版
kndjg的博客
04-06 3039
算法分析 | 分支限界算法设计之布线问题 C语言版 不墨迹，直接上代码 声明：凡代码问题，欢迎在评论区沟通。承蒙指正，一起成长！
【论文阅读及复现】（1998）无网格线探索布线算法 + Python代码实现
热门推荐
知不足而奋进，望远山而前行
10-17 2万+
三、多层无网格线探索算法 无网格线探索法同样可以推广至多层印制电路板布线。 为改善布线结果，对连线路径进行的优化分别在三个层次上进行： （1） 对单层无网格探索的局部路径优化； （2） 对多层布线路径的全局优化； （3） 整板布线完成后，对各线网路径的整体优化．
C# 最短路径问题——Dijkstra（二叉堆优化）
Gatongone的博客
09-08 1442
Description 平面上有n个点(N<=100)，每个点的坐标均在-10000~10000之间。其中的一些点之间有连线。若有连线，则表示可从一个点到达另一个点，即两点间有通路，通路的距离为两点直线的距离。现在的任务是找出从一点到另一点之间的最短路径。 Input 输入文件short.in，共有n+m+3行，其中： 第一行为一个整数n。 第2行到第n+1行（共n行），每行的两个整数x和y，描述一个点的坐标(以一个空格隔开)。 第n+2行为一个整数m，表示图中的连线个数。 此后的m行，每行描述一条连
C#实现Dijkstra最短路径算法（含完整源代码）
2301_79365003的博客
08-13 347
在Dijkstra方法中，我们定义了三个数组：visited用于标记节点是否已被遍历，dist用于记录节点到起点的最短距离，prev用于记录前驱节点。在每次遍历中，找到当前未被访问的距离最小的节点u，标记节点u已被访问，并更新与节点u相邻的节点v的距离和前驱节点。Dijkstra算法的核心思想是：按照边的权重从小到大依次添加到已知的最短路径上，直到找到目标节点或者所有节点都被遍历完成。在此过程中，需要维护一个距离数组，记录当前节点到起点的最短距离，以及一个前驱数组，记录当前节点的前一个节点。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值