最短路径课程设计
① C++课程设计 dijkstra算法 并行最短路径
Dijkstra算法的思想是DP +贪婪。
每次寻找最近的点，扩大和更新的状态
为（i = 1; <N; + +）/ /扩展N-1
{
T =无穷内大;
K = 1;
为（J = 1，J <N，J + +）/ /这里容是为了找到最近的点，D最小< （/（[J]）&&（D [J] T [K]））
{
吨= D [J];
K =?
}
[K] = 1 ;/ / k点加入的S
（J = 1，J <N，J + +）
（（！ [J]）&&（D [J]>的D [k] + W [K] [J]））/ /更新状态......基于动态规划
{
D [J] =的D [k] + W [K] [J];
P [J] = K;
}
>}
不知道LZ在哪里目前还不清楚
② 最短路径：拯救007课程设计
#include <iostream.h>
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
//#include "Deque.h"
//#include "error.h"
#define ISLAND_DIAMETER 15 /* 小岛的直径 */
#define LAKE_BOUNDARY_X 50 /* 小岛到湖边的距离，在x轴上 */
#define LAKE_BOUNDARY_Y 50 /* 小岛到湖边的距离，在y轴上 */
#define INFINITY 10000 /* 可以跳的步数的最大值 */
typedef unsigned int Vertex;
typedef double Distance;
typedef struct GraphNodeRecord{
int X; /* x轴坐标 */
int Y; /* y轴坐标 */
unsigned int Step; /*跳至该点的步数 */
Vertex Path; /*记录上一个点 */
} GraphNode;
typedef GraphNode *Graph;
Graph GraphNew(int NodeNum);
void GraphDelete(Graph G);
/* 判断007是否能从起始处跳至该点(x, y) */
int CheckForStart(int x, int y, Distance d);
/* 判断007是否能从该点跳至河岸 */
int CheckForEnd(int x, int y, Distance d);
/* 判断007是否能从点i跳至点j */
int CheckForConnect(Graph g, Vertex i, Vertex j, Distance d);
typedef unsigned int ElemType; /* 在本程序中ElemType指定为int */
/* 链表形式 */
typedef struct NodeRecord{
ElemType Element;
struct NodeRecord *Next; /* 指向下一个node */
} *Node;
typedef struct DequeRecord{
Node Front, Rear; /* 分别指向Deque的前后两个点 */
} *Deque;
Deque DequeNew();
void DequeDelete(Deque D);
void DequeClear(Deque D);
int IsEmpty(Deque D);
void Push(ElemType X, Deque D);
ElemType Pop(Deque D);
void Inject(ElemType X, Deque D);
#define CHECK(X) if(NULL == (X))Error("Out of space!!!")
void Error(const char *msg);
void Warning(const char *msg);
/******创建新的Graph******/
Graph GraphNew(int NodeNum)
{
Graph G;
int i;
if(NodeNum <= 0)return NULL;
G =(GraphNodeRecord *) malloc(NodeNum * sizeof(GraphNode)); /* 分配空间 */
CHECK(G);
for(i = 0; i < NodeNum; i++) /* 初始化 */
{
G[i].X = 0;
G[i].Y = 0;
G[i].Step = INFINITY;
G[i].Path = 0;
}
return G;
}
/******删除一个Graph)******/
void GraphDelete(Graph G)
{
if(G)free(G);
}
/*******判断007是否能从起始处跳至该点(x, y)，步长是d******/
int CheckForStart(int x, int y, Distance d)
{
double t;
t = (ISLAND_DIAMETER + (d * 2.0));
return (x*x + y*y) <= t*t/4.0;
/* x^2 + y^2 <= (ISLAND_DIAMETER/2.0 + d)^2 */
}
/*******判断007是否能从该点跳至河岸，步长是d******/
int CheckForEnd(int x, int y, Distance d)
{
if(x < 0)x = -x; /* 取x的绝对值 */
if(y < 0)y = -y; /* 取y的绝对值 */
return (d >= LAKE_BOUNDARY_X - x) /* 由于湖是个正方形，只需检查这两个距离*/
|| (d >= LAKE_BOUNDARY_Y - y);
}
/*******判断007是否能从点i跳至点j，步长是d******/
int CheckForConnect(Graph g, Vertex i, Vertex j, Distance d)
{
int x, y;
x = g[i].X - g[j].X;
y = g[i].Y - g[j].Y;
return x*x + y*y <= d*d;
}
/******创建新的Deque******/
Deque DequeNew()
{
Deque D;
D =(DequeRecord *) malloc(sizeof(struct DequeRecord));
CHECK(D);
D->Front = D->Rear =(NodeRecord *) malloc(sizeof(struct NodeRecord)); /* 空的头 */
CHECK(D->Front);
D->Front->Element = 0; /* 初始化 */
D->Rear->Next = NULL;
return D;
}
/******删除Deque******/
void DequeDelete(Deque D)
{
if(D)
{
while(D->Front)
{
D->Rear = D->Front->Next;
free(D->Front);
D->Front = D->Rear;
}
free(D);
}
}
/******DequeClear删除所有的节点除了头节点******/
void DequeClear(Deque D)
{
if(D)
{
while(D->Front->Next) /* 删除第一个节点 */
{
D->Rear = D->Front->Next->Next;
free(D->Front->Next);
D->Front->Next = D->Rear;
}
D->Rear = D->Front;
}
}
/******判断Deque是否为空******/
int IsEmpty(Deque D)
{
return D->Front == D->Rear;
}
/******将X元素压占到D中******/
void Push(ElemType X, Deque D)
{
Node NewNode;
NewNode =(NodeRecord *) malloc(sizeof(struct NodeRecord)); /* 建立新的节点 */
CHECK(NewNode);
NewNode->Element = X;
NewNode->Next = D->Front->Next;
if(D->Front == D->Rear) /* 如果D为空 */
D->Rear = NewNode;
D->Front->Next = NewNode; /* 压栈 */
}
/******将第一个元素出栈******/
ElemType Pop(Deque D)
{
Node Temp;
ElemType Item;
if(D->Front == D->Rear)
{
Error("Deque is empty");
return 0;
}
else
{
Temp = D->Front->Next; /* 得到第一个元素 */
D->Front->Next = Temp->Next; /* 重置第一个元素 */
if(Temp == D->Rear) /* 如果只有一个元素 */
D->Rear = D->Front; /* 将D置空 */
Item = Temp->Element;
free(Temp);
return Item;
}
}
/******插入元素X至D末尾******/
void Inject(ElemType X, Deque D)
{
Node NewNode;
NewNode =(NodeRecord *) malloc(sizeof(struct NodeRecord)); /* 创建新节点 */
CHECK(NewNode);
NewNode->Element = X;
NewNode->Next = NULL;
D->Rear->Next = NewNode;
D->Rear = NewNode;
}
/******打印错误信息，并退出程序******/
void Error(const char *msg)
{
if(NULL != msg)
fprintf(stderr,"%s\n",msg);
exit(-1);
}
/******打印警告信息，但并不退出程序******/
void Warning(const char *msg)
{
if(NULL != msg)
fprintf(stderr,"%s\n",msg);
}
;
/******读入一个case返回一个Graph，*Bank 记录最短到达河岸的路径******/
Graph read_case(FILE *InFile, int num, Vertex* Bank, Deque D)
{
Graph G = NULL;
Distance JamesJump;
Vertex V;
int x, y;
int i, Times;
*Bank = 0;
fscanf(InFile, "%lf", &JamesJump);
if(CheckForEnd(0, 0, JamesJump + ISLAND_DIAMETER/2.0))
{
for(i = 0; i < (num << 1); i++) /*一步便跳出的情况 */
fscanf(InFile, "%d", &x);
*Bank = 1;
}
else if(num > 0) /* 007必须经过鳄鱼头上的情况 */
{
num += 2;
G = GraphNew(num);
for(i = 2; i < num; i++) /* 第三个node开始是鳄鱼 */
{
fscanf(InFile, "%d", &x);
fscanf(InFile, "%d", &y);
G[i].X = x;
G[i].Y = y;
if(CheckForStart(x, y, JamesJump)) /*判断是否能跳上该点*/
{
G[i].Path = 1; /*007可以跳到 */
G[i].Step = 1; /* 一步 */
if(CheckForEnd(x, y, JamesJump)) /* 判断该点是否能跳出 */
{
*Bank = i; /* 007可以跳出 */
Times = (num - i - 1) << 1;
for(i = 0; i < Times; i++) /* 不必检验其他鳄鱼 */
fscanf(InFile, "%d", &y);
DequeClear(D);
break;
}
else
Inject(i, D); /* 插入该点，并开始下一个检测 */
}
}
while(!IsEmpty(D)) /*只经过一个鳄鱼无法跳出，必须还要跳到其它鳄鱼的情况 */
{
V = Pop(D);
for(i = 2; i < num; i++) /* 从这只鳄鱼跳到其他各个鳄鱼 */
{
if((G[i].Step > G[V].Step + 1)
&& CheckForConnect(G, V, i, JamesJump))
{
G[i].Path = V;
G[i].Step = G[V].Step + 1;
if((G[i].Step < G[*Bank].Step)
&& CheckForEnd(G[i].X, G[i].Y, JamesJump))
*Bank = i;
else
Inject(i, D);
}
}
}
}
return G;
}
/******写出结果，即最短路径******/
void write_result(FILE *OutFile, Vertex Bank, Graph G, Deque D)
{
unsigned int Times, i;
Vertex V;
switch(Bank){
case 0: /* 007无法跳出 */
fprintf(OutFile, "%d\n", -1);
break;
case 1: /* 007可以直接跳出 */
fprintf(OutFile, "%d\n", 1);
break;
default:
Times = G[Bank].Step + 1; /* 跳的步数 */
while(Bank != 1) /* 跟踪路径 */
{
Push(Bank, D);
Bank = G[Bank].Path;
}
fprintf(OutFile, "%d\n", Times); /* 输出 */
for(i = 1; i < Times; i++)
{
V = Pop(D);
fprintf(OutFile, "%d ", G[V].X);
fprintf(OutFile, "%d\n", G[V].Y);
}
}
}
int main(int argc, char *argv[])
{
FILE *in, *out;
Deque D;
int VertexNum;
Graph G = NULL;
Vertex Bank = 0;
in = fopen("input.txt", "r");
if(NULL == in)
{
fprintf(stderr, "Can not open input.txt");
exit(-1);
}
out = fopen("output.txt", "w");
if(NULL == out)
{
fprintf(stderr, "Can not open output.txt");
fclose(in);
exit(-1);
}
D = DequeNew();
while((EOF != fscanf(in, "%d", &VertexNum)) && (0 <= VertexNum))
{
G = read_case(in, VertexNum, &Bank, D); /* 读文件直到结尾 */
write_result(out, Bank, G, D);
if(G)
GraphDelete(G);
}
fclose(in);
fclose(out);
DequeDelete(D);
return 0;
}
这是你那个网址里的代码调试通过了，也得到了如例子里的结果。你自己试试吧。
要说明的是请把input.txt和程序放在里一文件夹下再运行程序
③ 软件课程设计：图论里面关于最短路径的算法，详细代码。 [email protected]
可以凭借Baihi通知我你的题目
有空能完成你无法解决的题目
如果你有相近的要求也能告诉我
ES:\\
交易提醒:预付定金有风险
交易提醒:勿轻信用户名中的联系方式
④ 数据结构课程设计作业:求任意两点的最短路径问题,写个完整的程序..急求啊...小弟上学期没学好..解决加分谢
一：
#include "stdafx.h"
#include <limits>
#include <iostream>
#include <fstream>
using namespace std;
const int MAXINT = numeric_limits<int>::max();
template <class Type>
void Dijkstra(int n, int v, Type dist[], int prev[], Type** c)
{
bool *s = new bool[n+1];
int i, j;
for(i = 1; i <=n; i++)
{
dist[i] = c[v][i];
if(c[v][i]!=MAXINT)
prev[i] = v;
else prev[i] =0;
s[i] = false;
}
s[v] = true;
dist[v] = 0;
prev[v] = 0;
for(i = 1; i< n; i++)
{
int u = v;
int temp = MAXINT;
for( j = 1; j<=n; j++)
if(!s[j]&&dist[j]<temp)
{
u = j;
temp = dist[j];
}
s[u] = true;
for(j=1; j<=n; j++)
{
if((!s[j])&&c[u][j]<MAXINT)
{
if((dist[u]+c[u][j])<dist[j])
{
dist[j] = dist[u] + c[u][j];
prev[j] = u;
}
}
}
}
delete [] s;
}
void djpath(int m, int v, int prev[])
{
int i = m ,j =1;
while(i!=0)
{
if (j == 1)
{
cout<< i;
j = 0;
}
else
cout<< "-" << i;
i = prev[i];
}
cout<<endl;
}
int _tmain(int argc, _TCHAR* argv[])
{
cout<<"最大整数:"<<MAXINT<<endl;
int prev[6], dist[6];
int i,j,n;
int** myc;
FILE *fp;
fp=fopen("data.txt", "r");
fscanf(fp,"%d", &n);
myc = new int* [n+1];
for(i =0; i<=n; i++)
myc[i] = new int[n+1];
for(i=1; i<=n; i++)
for(j =1; j<=n; j++)
{
fscanf(fp, "%d",&myc[i][j]);
if (myc[i][j]==-1)
myc[i][j] = MAXINT;
}
Dijkstra(5, 1, dist, prev, myc);
for(i = 1; i<=5; i++)
cout<<dist[i]<<endl;
for(i=2; i<=5; i++)
djpath(i,1,prev);
for(i = 0; i<=5; i++)
delete[] myc[i];
delete [] myc;
return 0;
}
输入数据采用文本文件格式，下面是data.txt的内容:
5
0 10 -1 30 100
10 0 50 -1 -1
-1 50 0 20 10
30 -1 20 0 60
100 -1 10 60 0
本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/mikewolf2009/archive/2009/09/12/4545537.aspx
二：
#include<iostream>
using namespace std;
void main()
{
int infinity=100,j,i,n,k,t,**w,*s,*p,*d;
cout<<"input the value of n:";
cin>>n;
cout<<endl;
d=new int[n];
s=new int[n];
p=new int[n];
w=new int*[n];
for(i=0;i<n;i++) {w[i]=new int[n];}
for(i=0;i<n;i++)
for(j=0;j<n;j++)
cin>>w[i][j];
for(s[0]=1,i=1;i<n;i++)
{
s[i]=0;d[i]=w[0][i];
if(d[i]<infinity) p[i]=0;
else p[i]=-1;
}
for(i=1;i<n;i++)
{
t=infinity;k=1;
for(j=1;j<n;j++)
if((!s[j])&&(d[j]<t)) {t=d[j];k=j;} //在蓝点集中选择一个最短距离最小的蓝点k来扩充红点集是Dijkstra算法的关键
s[k]=1;//point k join the S
for (j=1;j<n;j++) //将k扩充到红点后，剩余蓝点集的估计距离可能由于增加了新红点k而减小，此时必须调整相应蓝点的估计距离。对于任意的蓝点j，若k由蓝变红后使D[j]变小，则必定是由于存在一条从s到j且包含新红点k的更短路径：P=<s，…，k，j>。且D[j]减小的新路径P只可能是由于路径<s，…，k>和边<k，j>组成。所以，当length(P)=D[k]+w<k，j>小于D[j]时，应该用P的长度来修改D[j]的值。
if((!s[j])&&(d[j]>d[k]+w[k][j]))
{d[j]=d[k]+w[k][j];p[j]=k;}
}
cout<<"从源点到其它顶点的最短距离依次如下：";
for(i=1;i<n;i++) cout<<d[i]<<" ";
}
以上二个代码都是完整可以使用的，楼主喜欢哪个就用那个吧。自己还是可以仔细分析下代码。
⑤ 数据结构课程序设计: 将地图存储20个城市,求任意两个城市间的最短路径。
#include<stdio.h>
#include <iostream>
#include<string.h>
using namespace std;
#define M 22
int a[M][M],n,m;
void floyd()
{
int i,j,k;
for(k=0;k<n;k++)
{
(i=0;i<n;i++)
{
if(a[i][k]==0)//0当作无边
continue;
for(j=0;j<n;j++)
{
if(i==j)//自己到自己
continue;
if(a[k][j]==0)
continue;
if(a[i][j]==0||a[i][k]+a[k][j]<a[i][j])//若当前i到j没路。或者先到k绕回来，路程更短的话
{
a[i][j]=a[i][k]+a[k][j];
}
}
}
}
}
void main()
{
int i,j;
int p1,p2,w;
while(1)
{
scanf("%d%d",&n,&m);//点数，边数
memset(a,0,sizeof(a));
for(i=0;i<m;i++)//输入边
{
scanf("%d%d%d",&p1,&p2,&w);//p1至p2距离w
//0<=p1,p2<=n-1
if(a[p1][p2]==0||w<a[p1][p2])//无边，或重边
{
a[p1][p2]=w;
a[p2][p1]=w;//当无向图处理
}
}
floyd();
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
printf("%d ",a[i][j]);
}
printf("\n");
}
}
}
上面有注释~
最后输出答案矩阵~
⑥ c++课程设计最短路径
求单源最短路径，可以用Dijkstra算法；求每对顶点之间的最短路径，可以用Floyed算法。下面是我以前编的，不过好像有时候不大稳定，没最终改好，大致算法实现是这样的，或许可以参考一下。
a// AdjMatrix.h: interface for the AdjMatrix class.
//
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_ADJMATRIX_H__220DF675_DDB5_4E64_BD89_CDDA2C1F7804__INCLUDED_)
#define AFX_ADJMATRIX_H__220DF675_DDB5_4E64_BD89_CDDA2C1F7804__INCLUDED_
#include <iostream.h>
#include <iomanip.h>
#include "Stack.h"
#define INT_MAX 0x7FFFFFFF
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
template <class Type>
void Make2DArray(Type ** & x,int rows,int cols){//创建二维数组x
x = new Type *[rows];//创建行指针
for(int i = 0;i < rows;i++)//为每一行分配空间
x[i] = new Type[cols];
}
template <class Type>
void Delete2DArray(Type ** & x,int rows){//删除二维数组x
for(int i = 0;i < rows;i++)//释放为每一行所分配的空间
delete[]x[i];
delete[]x;//删除行指针
x = NULL;
}
class AdjMatrix{//方阵类
double **a;//数据缓存区
public:
AdjMatrix(double **b = NULL,int dimention = 0){//初始化方阵
Make2DArray(a,dimention+1,dimention+1);
a[0][0] = dimention;
for(int i = 1,j = 1;i <= dimention,j <= dimention;i++,j++){
a[i][0] = 0;
a[0][j] = 0;
}
if(b)
for(int i1 = 1;i1 <= dimention;i1++)
for(int j1 = 1;j1 <= dimention;j1++)
a[i1][j1] = b[i1-1][j1-1];
}
virtual ~AdjMatrix();//析构函数
AdjMatrix & operator = (const AdjMatrix &);//重载赋值运算符=
void Trs(AdjMatrix &);//矩阵转置:B=trs(*this)
void Show();//显示结果
void ShortestPath_Floyed();//弗洛伊德算法，求每对顶点之间的最短路径
void ShortestPath_Dijkstra(int);//狄克斯特拉算法，求单源最短路径
//输入v为源点编号
};
#endif // !defined(AFX_ADJMATRIX_H__220DF675_DDB5_4E64_BD89_CDDA2C1F7804__INCLUDED_)
// AdjMatrix.cpp: implementation of the AdjMatrix class.
//
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "AdjMatrix.h"
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
AdjMatrix::~AdjMatrix(){
int Dim = (int)a[0][0]+1;
Delete2DArray(a,Dim);
}
AdjMatrix & AdjMatrix::operator = (const AdjMatrix &matrix){
int Dim1 = (int)a[0][0],Dim2 = (int)matrix.a[0][0];
Delete2DArray(a,Dim1+1);
Make2DArray(a,Dim2+1,Dim2+1);
for(int i = 0;i <= Dim2;i++)
for(int j = 0;j <= Dim2;j++)
a[i][j] = matrix.a[i][j];
return *this;
}
void AdjMatrix::Trs(AdjMatrix &B){
int Dim1 = (int)a[0][0],Dim2 = (int)B.a[0][0];
Delete2DArray(B.a,Dim2+1);
Make2DArray(B.a,Dim1+1,Dim1+1);
B.a[0][0] = Dim1;
for(int i = 1,j = 1;i <= Dim1,j <= Dim1;i++,j++){
B.a[i][0] = 0;
B.a[0][j] = 0;
}
for(int i1 = 1;i1 <= Dim1;i1++)
for(int j1 = 1;j1 <= Dim1;j1++)
B.a[i1][j1] = a[j1][i1];
}
void AdjMatrix::Show(){
if((int)a[0][0] == 0)
cerr<<"Error!矩阵不存在!\n";
else{
for(int i = 1;i <= a[0][0];i++){
for(int j = 1;j <= a[0][0];j++){
if(a[i][j] == INT_MAX)
cout<<setw(5)<<setprecision(7)<<"∞"<<'\t';
else
cout<<setw(5)<<setprecision(7)<<a[i][j]<<'\t';
}
cout<<endl;
}
}
}
void AdjMatrix::ShortestPath_Floyed(){
int Dim = (int)a[0][0],pre;
AdjMatrix A,Path;
this->Trs(Path);
Path.Trs(A);//取A=*(this)
for(int i = 1;i <= Dim;i++){
for(int j = 1;j <= Dim;j++)
Path.a[i][j] = -1;
}
for(int k = 1;k <= Dim;k++){
for(int i1 = 1;i1 <= Dim;i1++)
for(int j1 = 1;j1 <= Dim;j1++)
if(A.a[i1][j1] > A.a[i1][k]+A.a[k][j1]){
A.a[i1][j1] = A.a[i1][k]+A.a[k][j1];
Path.a[i1][j1] = k;
}
}
cerr<<"↘Floyed算法求解如下:\n";
for(int i2 = 1;i2 <=Dim;i2++){//输出最短路径
for(int j2 = 1;j2 <=Dim;j2++)
if(i2 != j2){
cout<<" "<<i2<<"->"<<j2<<": ";
if(A.a[i2][j2] == INT_MAX){
if(i2 != j2)
cout<<"不存在路径!\n";
}
else{
cout<<"路径长度："<<setw(3)<<A.a[i2][j2]<<" ";
cout<<"路径："<<i2<<"->";
pre = (int)Path.a[i2][j2];
while(pre != -1){
cout<<pre<<"->";
pre = (int)Path.a[pre][j2];
}
cout<<j2<<endl;
}
}
}
}
void AdjMatrix::ShortestPath_Dijkstra(int v){
int Dim = (int)a[0][0];
AdjMatrix A,temp;
this->Trs(temp);
temp.Trs(A);//取A=*(this)
int *s, *path,u,pre;
s = new int[Dim+1],path = new int[Dim+1];
s[0]=0,path[0]=0;
double *dist,mindis;
dist = new double[Dim+1];
dist[0] = 0.0;
for(int k = 1;k <= Dim;k++){
dist[k] = A.a[v][k];//距离初始化
s[k] = 0;//s[]置空
if(A.a[v][k] < INT_MAX)//路径初始化
path[k] = v;
else
path[k] = -1;
}
s[v] = 1,path[v] = 0;//源点编号v放入s中
for(int i = 1;i <= Dim;i++){//循环直到所有顶点的最短路径都求出
mindis = INT_MAX;
u = -1;
for(int j = 1;j <= Dim;j++){//选取不在s中且具有最小距离的顶点u
if(s[j] == 0 && dist[j] < mindis){
u = j;
mindis = dist[j];
}
}
if(u != -1){
s[u] = 1;
for(int r = 1;r <= Dim;r++)
if(s[r] == 0)
if(A.a[u][r] < INT_MAX && dist[u]+A.a[u][r] < dist[r]){
dist[r] = dist[u]+A.a[u][r];
path[r] = u;
}
}
}
cout<<"↘Dijkstra算法求解如下：\n";
Stack<int> st;
for(int i1 = 1;i1 <= Dim;i1++){//输出最短路径的长度，路径逆序输出
if(i1 != v){
cout<<" "<<v<<"->"<<i1<<": ";
if(s[i1] == 1){
cout<<"路径长度："<<setw(3)<<dist[i1]<<" ";
pre = i1;
cout<<"路径：";
while(pre != v){//一直回溯到初始顶点
st.Push(pre);
pre = path[pre];
}
st.Push(pre);
while(0 < st.GetTop() ){
cout<<st.Pop()<<"->";
}
cout<<st.Pop()<<endl;
}
else
cout<<"不存在路径!\n";
}
}
}
// Stack.h: interface for the Stack class.
//
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_STACK_H__289E76B1_034C_4426_AE27_6ADCC13EDBCD__INCLUDED_)
#define AFX_STACK_H__289E76B1_034C_4426_AE27_6ADCC13EDBCD__INCLUDED_
#include<iostream.h>
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#define MaxSize 1024
template <class Type> class Stack{//堆栈类
private:
Type data[MaxSize];
int top;
public:
Stack(){ //初始化栈
top = -1;
}
virtual~Stack();
bool IsEmpty(); //判断栈为空
bool IsFull(); //判断栈为满
int GetTop(); //取top的位置
void Push(Type);//进栈
Type Pop(); //退栈
};
template <class Type> Stack<Type>::~Stack(){
}
template <class Type> bool Stack<Type>::IsEmpty(){
return(top == -1);
}
template <class Type> bool Stack<Type>::IsFull(){
return(top == MaxSize-1);
}
template <class Type> int Stack<Type>::GetTop(){
return top;
}
template <class Type> void Stack<Type>::Push(Type item){
if(IsFull())
cout<<"栈满!\n";
else{
top++;
data[top] = item;
}
}
template <class Type> Type Stack<Type>::Pop(){
if(IsEmpty()){
cout<<"栈空!\n";
return NULL;
}
else{
Type item;
item = data[top];
top--;
return item;
}
}
#endif // !defined(AFX_STACK_H__289E76B1_034C_4426_AE27_6ADCC13EDBCD__INCLUDED_)
⑦ 关于最短路径的C语言课程设计 有会的吗QQ476566409！！！很急~~
你好，这是我写的D氏算法求解：
－－－－－－－－－－－－－－－－－－－－－－－－－
#include<stdio.h>
#define MAX 200
#define N 5
void main()
{
int final[N]={0},D[N],G[N][N],P[N][N]={0},i,j,e,h,w,min;
for(i=0;i<N;i++)
for(j=0;j<N;j++)
G[i][j]=MAX;
printf("请输入有向线路条数:");scanf("%d",&e);
printf("\n请输入线路头尾及长度:\n");
for(i=0;i<e;i++)
{
scanf("%d%d%d",&h,&w,&j);G[h][w]=j;
}
printf("\n请输入路径起始点:");scanf("%d%d",&h,&w);
for(i=0;i<N;i++)
{
D[i]=G[h][i];
if(D[i]<MAX)
{P[i][h]=1;P[i][i]=2;}
}
final[h]=1;D[h]=0;
for(i=1;i<N;i++)
{min=MAX;
for(j=0;j<N;j++)
if(!final[j])
if(D[j]<min)
{e=j;min=D[j];}
final[e]=1;
for(j=0;j<N;j++)
if(!final[j]&&min+G[e][j]<D[j])
{D[j]=min+G[e][j];
for(h=0;h<N;h++)
P[j][h]=P[e][h];
P[j][j]=P[j][e]+1;
}
}
printf("\n最短路程为:%d",D[w]);
printf("\n最短路径为:");
for(j=1;j<=N;j++)
for(i=0;i<N;i++)
if(P[w][i]==j)
{printf("%d ",i);}
printf("\n");
}
－－－－－－－－－－－－－－－－－－－－－－－－