单源最短路径

单源最短路径问题

I 用贪心算法求解

贪心算法是一种经典的算法，通常以自顶向下的方式进行，以迭代的方式作出相继的贪心选择，每作一次贪心选择就将所求问题简化为规模更小的子问题。一般具有2个重要的性质：贪心选择性质和最优子结构性质。

一、问题描述与分析

单源最短路径问题是一个经典问题，给定带权有向图G =(V,E)，其中每条边的权是非负实数。另外，还给定V中的一个顶点，称为源。现在要计算从源到所有其他各顶点的最短路长度。这里路的长度是指路上各边权之和。这个问题通常称为单源最短路径问题。

分析过程：运用Dijkstra算法来解决单源最短路径问题。

具备贪心选择性质

具有最优子结构性质

计算复杂性

二、算法设计（或算法步骤）

用贪心算法解单源最短路径问题：

1.算法思想：

设置顶点集合S并不断地作贪心选择来扩充这个集合。一个顶点属于集合S当且仅当从源到该顶点的最短路径长度已知。初始时，S中仅含有源。设u是G的某一个顶点，把从源到u且中间只经过S中顶点的路称为从源到u的特殊路径，并用数组dist记录当前每个顶点所对应的最短特殊路径长度。Dijkstra算法每次从V-S中取出具有最短特殊路长度的顶点u，将u添加到S中，同时对数组dist作必要的修改。一旦S包含了所有V中顶点，dist就记录了从源到所有其他顶点之间的最短路径长度。

2.算法步骤：

(1) 用带权的邻接矩阵c来表示带权有向图, c[i][j]表示弧上的权值. 若∉V,则置c[i][j]为∞。设S为已知最短路径的终点的集合,它的初始状态为空集。

从源点v到图上其余各点vi的当前最短路径长度的初值为：dist[i]=c[v][i] vi∈V。

(2) 选择vj, 使得dist[j]=Min{dist[i] | vi∈V-S}，vj就是长度最短的最短路径的终点。令

S=SU{j}。

的当前最短路径长度:

(3) 修改从v到集合V-S上任一顶点v

k

如果dist[j]+c[j][k]< dist[k] 则修改dist[K]= dist[j]+c[j][k]

(4) 重复操作(2),(3)共n-1次.

三、算法实现

#include

#include

using namespace std;

#define MAX 1000000 //充当"无穷大"

#define LEN sizeof(struct V_sub_S)

#define N 5

#define NULL 0

int s; //输入的源点

int D[N]; //记录最短路径

int S[N]; //最短距离已确定的顶点集

const int G[N][N] = { {0, 10, MAX, 30, 100},

{MAX, 0, 50, MAX, MAX},

{MAX, MAX, 0, MAX, 10},

{MAX, MAX, 20, 0, 60},

{MAX, MAX, MAX, MAX, 0} };

typedef struct V_sub_S //V-S链表

{

int num;

struct V_sub_S *next;

};

struct V_sub_S *create()

{

struct V_sub_S *head, *p1, *p2;

int n = 0;

head = NULL;

p1 = (V_sub_S *)malloc(LEN);

p1->num = s;

head = p1;

for(int i = 0; i < N+1; i ++)

{

if(i != s)

{

++ n;

if(n == 1)

head = p1;

else

p2->next = p1;

p2 = p1;

p1 = (V_sub_S *)malloc(LEN);

p1->num = i;

p1->next = NULL;

}

}

free(p1);

return head;

}

struct V_sub_S *DelMin(V_sub_S *head, int i) //删除链表中值为i 的结点{

V_sub_S *p1, *p2;

p1 = head;

while(i != p1->num && p1->next !=NULL)

{

p2 = p1;

p1 = p1->next;

}

p2->next = p1->next;

return head;

}

void Dijkstra(V_sub_S *head, int s)

{

struct V_sub_S *p;

int min;

S[0] = s;

for(int i = 0; i < N; i ++)

{

D[i] = G[s][i];

}

for(i = 1; i < N; i ++)

{

p = head->next;

min = p->num;

while(p->next != NULL)