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

以下是空调布线对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);

}

}

}

时间: 2024-10-12 11:02:15

Dijkstra算法C#实现及其布线运用的相关文章

畅通project续HDU杭电1874【dijkstra算法 || SPFA】

http://acm.hdu.edu.cn/showproblem.php?pid=1874 Problem Description 某省自从实行了非常多年的畅通project计划后.最终修建了非常多路.只是路多了也不好,每次要从一个城镇到还有一个城镇时,都有很多种道路方案能够选择,而某些方案要比还有一些方案行走的距离要短非常多.这让行人非常困扰. 如今,已知起点和终点,请你计算出要从起点到终点.最短须要行走多少距离. Input 本题目包括多组数据.请处理到文件结束. 每组数据第一行包括两个正

ACM: HDU 2544 最短路-Dijkstra算法

HDU 2544最短路 Time Limit:1000MS     Memory Limit:32768KB     64bit IO Format:%I64d & %I64u Description 在每年的校赛里,所有进入决赛的同学都会获得一件很漂亮的t-shirt.但是每当我们的工作人员把上百件的衣服从商店运回到赛场的时候,却是非常累的!所以现在他们想要寻找最短的从商店到赛场的路线,你可以帮助他们吗? Input 输入包括多组数据.每组数据第一行是两个整数N.M(N<=100,M<

ACM: HDU 3790 最短路径问题-Dijkstra算法

HDU 3790 最短路径问题 Time Limit:1000MS     Memory Limit:32768KB     64bit IO Format:%I64d & %I64u Description 给你n个点,m条无向边,每条边都有长度d和花费p,给你起点s终点t,要求输出起点到终点的最短距离及其花费,如果最短距离有多条路线,则输出花费最少的. Input 输入n,m,点的编号是1~n,然后是m行,每行4个数 a,b,d,p,表示a和b之间有一条边,且其长度为d,花费为p.最后一行是

邻接表实现Dijkstra算法以及DFS与BFS算法

//============================================================================ // Name : ListDijkstra.cpp // Author : fffff // Version : // Copyright : Your copyright notice // Description : Hello World in C++, Ansi-style //==========================

Dijkstra算法(求解单源最短路)详解 + 变形 之 poj 1860 Currency Exchange

/* 求解单源最短路问题:Dijkstra算法(该图所有边的权值非负) 关键(贪心): (1)找到最短距离已经确定的节点,从它出发更新与其相邻节点的最短距离: (2)此后不再关心(1)中“最短距离已经确定的节点”. 时间复杂度(大概的分析,不准确): “找到最短距离已经确定的节点” => O(|V|) "从它出发更新与其相邻节点的最短距离" => 邻接矩阵:O(|V|),邻接表:O(|E|) 需要循环以上两个步骤V次,所以时间复杂度:O(V^2) 即:在|E|较小的情况下,

Dijkstra 算法

最短路径算法的基础知识,参见 http://blog.csdn.net/pacosonswjtu/article/details/49894021 Dijkstra算法 涉及到的 优先队列的操作实现(该优先队列的数据类型不是 int , 而是 Distance),详情参见http://blog.csdn.net/pacosonswjtu/article/details/49923389 [1]Dijkstra 算法相关 1.1)贪婪算法一般分阶段去求解一个问题, 在每个阶段它都把当前出现的当做是

51nod-迷宫问题(Dijkstra算法)

Dijkstra算法 你来到一个迷宫前.该迷宫由若干个房间组成,每个房间都有一个得分,第一次进入这个房间,你就可以得到这个分数.还有若干双向道路连结这些房间,你沿着这些道路从一个房间走到另外一个房间需要一些时间.游戏规定了你的起点和终点房间,你首要目标是从起点尽快到达终点,在满足首要目标的前提下,使得你的得分总和尽可能大.现在问题来了,给定房间.道路.分数.起点和终点等全部信息,你能计算在尽快离开迷宫的前提下,你的最大得分是多少么? Dijkstra算法是一个经典的算法--他是荷兰计算机科学家D

Dijkstra算法

Dijkstra算法是一个经典的算法--他是荷兰计算机科学家Dijkstra于1959年提出的单源图最短路径算法.也是一个经典的贪心算法.所谓单源图 是规定一个起点的图,我们的最短路径都是从这个起点出发计算的.算法的适用范围是一个无向(或者有向图),全部边权都是非负数. 算法描写叙述: 节点集合V = {}空集合,距离初始化. 节点编号0..n – 1, 起点编号0≤ s < n. 距离数组 起点 d[s] = 0 其它 d[i] = ∞, 0 ≤ i < n,  i ≠ s. 循环n次 找到

算法描述》关于SPFA和Dijkstra算法的两三事

本来我是想把这两个算法分开写描述的,但是SPFA其实就是Dijkstra的稀疏图优化,所以其实代码差不多,所以就放在一起写了. 因为SPFA是Dijkstra的优化,所以我想来讲讲Dijkstra. 什么是Dijkstra Dijkstra是一种求单源最短路的基础算法,时间复杂度在不加堆优化的情况下是o(n^2)的,加了堆优化就能简化到o(nlogn),而且算法稳定性很强(从这点上来说比SPFA好多了,具体怎么好下面再讲),基础思路如下: 首先,把所有点到源的距离设为最大,然后把源加入队列,接着