图的最短路径算法
❶ 利用Dijkstra算法求有向网图的最短路径
Dijkstra算法的适用范围是权值非负的图，即解决带有非负权值的图中的单源最短路径问题 比方说你从甲地走到乙地 需要走的步数怎么会是负值呢 是吧
❷ 无向网图的最短路径经算法
Prim 算法
或者是 Kruskal算法
只要有最小生成树之后一切就好办了
具体的太多了，有什么再追问吧
如果需要，留下邮箱，可以发你一个课件
❸ 求有向图最短路径算法（权重可为负）
单元最短路径：
1.如果没有负权环的稀疏图，可以用SPFA，时间复杂度O（KM）
M是边数，K是平均入队列的次数
2.如果没有负权环的稠密图，建议用Dijkstra O（N^2），用二叉堆可优化到
O（NlogN），斐波那契堆编程复杂度太高，不易于实现
3.如果有负权环，可以尝试floyd,O(n^3)
任两点最短路径：floyd较好实现，基于重标号johnson也不错（稀疏图效率高）
具体程序可以上网查
❹ 求解：图论中常见的最短路径算法有几种都是什么
主要是有三种、、
第一种是最直接的贪心dijkstra算法、、可以利用堆数据结构进行优化、、缺点就是不能求有负权的最短路与判断负环、、
第二种是bellman-ford算法、、根据松弛操作的性质是可以来判断负环的、、时间复杂度是O(nm)的、、
第三种是SPFA算法、、把他单独拿出来作为一种算法并不是非常好的、、他的实质应该是上面的bellman-ford算法的队列优化时间复杂度更低、O(KE)、K的值约等于2、、
❺ 求离散里面哈米尔顿图的最短路径的算法
本程序参考了风云的最短路径代码( http://member.nease.com/~cloudwu)，
并加以改进和优化：
1、把原来用于存放已处理节点的堆栈改为(store_queue)队列，这样在从
sort_queue队列出列时可直接放入store_queue中。
2、解除了地图大小的限制(如果有64K内存限制时，地图大小只能是180x180)
3、删除了原程序中的一些冗余，见程序中的注释。
4、程序继续使用dis_map数组保存各点历史历史最佳距离，也包含了某点是否已经
经过的信息，虽然这样做可能会比使用链表多用一些内存，但是在搜索时可以
节省不时间。
5、程序更具有实用性，可直接或修改后运用于你的程序中，但请你使用该代码后
应该返回一些信息给我，如算法的改进或使用于什么程序等。
本程序可以用Borland C++或DJGPP编译，并附带有一个数据文件 map.dat,
保存有地图的数据，（注：该地图文件格式与风云的原代码的地图格式不一样）
算法描述：
findpath()
{
把S点加入树根（各点所在的树的高度表示从S点到该点所走过的步数）；
把S点加入排序队列（按该点到E点的距离排序+走过的步数从小到大排序）；
1、排序队列sort_queue中距离最小的第一个点出列，并保存入store_queue中
2、从出列的点出发，分别向4个（或8个）方向中的一个各走出一步
3、并估算第2步所走到位置到目标点的距离，并把该位置加入树，
最后把该点按距离从小到大排序后并放入队列中。(由trytile函数实现)。
4、如果该点从四个方向上都不能移动，则把该点从store_queue中删除
5、回到第一点，直到找到E点则结束
从目标点回溯树，直到树根则可以找到最佳路径，并保存在path[]中
}
-------------------------------------------------------------------------*/
//#define NDEBUG
#include <stdio.h>
#include <conio.h>
#include <assert.h>
#include <stdlib.h>
#include <mem.h>
#define tile_num(x,y) ((y)*map_w+(x)) //将 x,y 坐标转换为地图上块的编号
#define tile_x(n) ((n)%map_w) //由块编号得出 x,y 坐标
#define tile_y(n) ((n)/map_w)
#define MAPMAXSIZE 180 //地图面积最大为 180x180，如果没有64K内存限制可以更大
#define MAXINT 32767
//树结构, 比较特殊, 是从叶节点向根节点反向链接，方便从叶节点找到根节点
typedef struct tree_node *TREE;
struct tree_node {
int h; //节点所在的高度，表示从起始点到该节点所有的步数
int tile; //该节点的位置
TREE father; //该节点的上一步
};
//链接结构，用于保存处理过的和没有处理过的结点
typedef struct link_node *LINK;
struct link_node {
TREE node;
int f;
LINK next;
};
LINK sort_queue; // 保存没有处理的行走方法的节点
LINK store_queue; // 保存已经处理过的节点 (搜索完后释放)
unsigned char * map; //地图数据
unsigned int * dis_map; //保存搜索路径时,中间目标地最优解
int map_w,map_h; //地图宽和高
int start_x,start_y,end_x,end_y; //地点,终点坐标
// 初始化队列
void init_queue(void)
{
sort_queue=(LINK)malloc(sizeof(*sort_queue));
sort_queue->node=NULL;
sort_queue->f=-1;
sort_queue->next=(LINK)malloc(sizeof(*sort_queue));
sort_queue->next->node=NULL;
sort_queue->next->f=MAXINT;
sort_queue->next->next=NULL;
store_queue=(LINK)malloc(sizeof(*store_queue));
store_queue->node=NULL;
store_queue->f=-1;
store_queue->next=NULL;
}
// 待处理节点入队列, 依靠对目的地估价距离插入排序
void enter_queue(TREE node,int f)
{
LINK p=sort_queue,father,q;
while(f>p->f) {
father=p;
p=p->next;
assert(p);
}
q=(LINK)malloc(sizeof(*q));
assert(sort_queue);
q->f=f,q->node=node,q->next=p;
father->next=q;
}
// 将离目的地估计最近的方案出队列
TREE get_from_queue(void)
{
LINK bestchoice=sort_queue->next;
LINK next=sort_queue->next->next;
sort_queue->next=next;
bestchoice->next=store_queue->next;
Top
3 楼keikei007（keikei）回复于 2004-06-21 19:16:02 得分 0
store_queue->next=bestchoice;
return bestchoice->node;
}
// 释放栈顶节点
void pop_stack(void)
{
LINK s=store_queue->next;
assert(s);
store_queue->next=store_queue->next->next;
free(s->node);
free(s);
}
// 释放申请过的所有节点
void freetree(void)
{
int i;
LINK p;
while(store_queue){
p=store_queue;
free(p->node);
store_queue=store_queue->next;
free(p);
}
while (sort_queue) {
p=sort_queue;
free(p->node);
sort_queue=sort_queue->next;
free(p);
}
}
// 估价函数,估价 x,y 到目的地的距离,估计值必须保证比实际值小
int judge(int x,int y)
{
int distance;
distance=abs(end_x-x)+abs(end_y-y);
return distance;
}
// 尝试下一步移动到 x,y 可行否
int trytile(int x,int y,TREE father)
{
TREE p=father;
int h;
if (map[tile_num(x,y)]!=' ') return 1; // 如果 (x,y) 处是障碍,失败
//这一步用来判断(x,y)点是否已经加入队列，多余可以删除，因为dis_map已经
//保存该点是否已经保存
//while (p) {
// if (x==tile_x(p->tile) && y==tile_y(p->tile)) return 1; //如果 (x,y) 曾经经过,失
败
// p=p->father;
//}
h=father->h+1;
if (h>=dis_map[tile_num(x,y)]) return 1; // 如果曾经有更好的方案移动到 (x,y) 失败
dis_map[tile_num(x,y)]=h; // 记录这次到 (x,y) 的距离为历史最佳距离
// 将这步方案记入待处理队列
p=(TREE)malloc(sizeof(*p));
p->father=father;
p->h=father->h+1;
p->tile=tile_num(x,y);
enter_queue(p,p->h+judge(x,y));
return 0;
}
// 路径寻找主函数
int * findpath(void)
{
TREE root;
int i,j;
int * path;
memset(dis_map,0xff,map_h*map_w*sizeof(*dis_map)); //填充dis_map为0XFF，表示各点未
曾经过
init_queue();
root=(TREE)malloc(sizeof(*root));
root->tile=tile_num(start_x,start_y);
root->h=0;
root->father=NULL;
enter_queue(root,judge(start_x,start_y));
for (;;) {
int x,y,child;
TREE p;
root=get_from_queue();
if (root==NULL) {
return NULL;
}
x=tile_x(root->tile);
y=tile_y(root->tile);
gotoxy(x+1,y+1);
putchar('\'');
if (x==end_x && y==end_y) break; // 达到目的地成功返回
child=trytile(x,y-1,root); //尝试向上移动
child&=trytile(x,y+1,root); //尝试向下移动
child&=trytile(x-1,y,root); //尝试向左移动
child&=trytile(x+1,y,root); //尝试向右移动
//child&=trytile(x+1,y-1,root);//尝试向右上移动
//child&=trytile(x+1,y+1,root); //尝试向右下移动
//child&=trytile(x-1,y+1,root); //尝试向左下移动
//child&=trytile(x-1,y-1,root); //尝试向左上移动
if (child!=0)
pop_stack(); // 如果四个方向均不能移动,释放这个死节点
}
// 回溯树，将求出的最佳路径保存在 path[] 中
path=(int*)malloc((root->h+2)*sizeof(int));
assert(path);
for (i=0;root;i++) {
path[i]=root->tile;
root=root->father;
}
path[i]=-1;
freetree();
return path;
}
void printpath(int *path)
{
int i;
if(path==NULL) return ;
for (i=0;path[i]>=0;i++) {
gotoxy(tile_x(path[i])+1,tile_y(path[i])+1);
cprintf(".");
}
}
int readmap(void)
{
FILE *f;
int i,j;
f=fopen("map.dat","r");
assert(f);
fscanf(f,"%d,%d\n",&map_w,&map_h);
map=malloc(map_w*map_h+1);
assert(map);
for(i=0;i<map_h;i++)
fgets(map+tile_num(0,i),map_w+2,f);
fclose(f);
start_x=-1,end_x=-1;
for (i=0;i<map_h;i++)
for (j=0;j<map_w;j++) {
if (map[tile_num(j,i)]=='s') map[tile_num(j,i)]=' ',start_x=j,start_y=i;
if (map[tile_num(j,i)]=='e') map[tile_num(j,i)]=' ',end_x=j,end_y=i;
}
assert(start_x>=0 && end_x>=0);
dis_map=malloc(map_w*map_h*sizeof(*dis_map));
assert(dis_map);
return 0;
}
void showmap(void)
{
int i,j;
clrscr();
for (i=0;i<map_h;i++) {
gotoxy(1,i+1);
for (j=0;j<map_w;j++)
if (map[tile_num(j,i)]!=' ') cprintf("O");
else cprintf(" ");
}
gotoxy(start_x+1,start_y+1);
cprintf("s");
gotoxy(end_x+1,end_y+1);
cprintf("e");
}
int main()
{
int * path;
readmap();
showmap();
getch();
path=findpath();
printpath(path);
if(dis_map) free(dis_map);
if(path) free(path);
if(map) free(map);
getch();
return 0;
}
❻ Dijkstra算法算最短路径
////////////////////////////////////////////////////////////
// Graph.h
#pragma once
#define maxPoint 100
class CGraph
{
public:
CGraph(void);
~CGraph(void);
bool SetGraph( double g[maxPoint][maxPoint] , int startPoint , int size );
bool Dijkstra();
void Display();
int GetStartPoint();
double GetBestWay( int dest , int path[] , int &pathLen );
private:
//标志当前图是否已经求解
bool solved;
//当前图布局
double graph[maxPoint][maxPoint];
//地图大小
int size;
//起点
int startPoint;
//当前图的解
double dist[maxPoint];
int prev[maxPoint];
};
////////////////////////////////////////////////////////////
// Graph.cpp
#include 'StdAfx.h'
#include '.\graph.h'
CGraph::CGraph(void)
{
for( int i = 0 ; i < maxPoint ; i++ )
{
for( int j = 0 ; j < maxPoint ; j++ )
graph[i][j] = -1;
}
startPoint = -1;
size = -1;
//当前图还没有求解
solved = false;
}
CGraph::~CGraph(void)
{
}
//
//
bool CGraph::SetGraph( double g[maxPoint][maxPoint] , int startPoint , int size )
{
for( int i = 0 ; i < size ; i++ )
{
for( int j = 0 ; j < size ; j++ )
graph[i][j] = g[i][j];
}
this->startPoint = startPoint;
this->size = size;
solved = false;
Dijkstra();
return true;
}
//
//
bool CGraph::Dijkstra()
{
bool s[maxPoint];
for( int j = 0 ; j < size ; j++ )
{
dist[j] = graph[startPoint][j];
s[j] = false;
//dist[i]<0，表示没有路径连接 结点startPoint 与 结点j
if( dist[j] < 0 )
prev[j] = 0;
else
prev[j] = startPoint;
}
//从起点出发
dist[startPoint] = 0;
s[startPoint] = true;
for( int i = 0 ; i < size ; i++ )
{
double temp;
int u = startPoint;
bool flag = false;
for( int j = 0 ; j < size ; j++ )
{
if( !s[j] )
{
//如果不是第一次比较，temp u，都已经赋值，则
if( flag )
{
if( dist[j] > 0 && dist[j] < temp )
{
u = j;
temp = dist[j];
}
}
else
{
u = j;
temp = dist[j];
flag = true;
}
}
}
s[u] = true;
for( int j = 0 ; j < size ; j++ )
{
if( !s[j] && graph[u][j] > 0 )
{
double newDist = dist[u] + graph[u][j];
if( dist[j] < 0 || newDist < dist[j] )
{
dist[j] = newDist;
prev[j] = u;
}
}
}
}
//标记当前问题已经解决
solved = true;
return true;
}
//
//
void CGraph::Display()
{
printf( '当前地图的邻接矩阵\n' );
for( int i = 0 ; i < size ; i++ )
{
for( int j = 0 ; j < size ; j++ )
{
printf( '%5.f' , graph[i][j] );
}
printf( '\n' );
}
}
//
//
double CGraph::GetBestWay( int dest , int path[] , int &pathLen )
{
int p = dest;
int theway[maxPoint];
int len = 0;
while( p != startPoint )
{
theway[len] = p;
p = prev[p];
len++;
}
theway[len] = startPoint;
len++;
for( int i = 0 , j = len - 1 ; i < len ; i++ , j-- )
path[i] = theway[j];
pathLen = len;
return dist[dest];
}
//
//
int CGraph::GetStartPoint()
{
return startPoint;
}
//
////////////////////////////////////////////////////////////
// Dijkstra.cpp : 定义控制台应用程序的入口点。
//
#include 'stdafx.h'
#include 'conio.h'
#include 'Graph.h'
int _tmain(int argc, _TCHAR* argv[])
{
double graph[][maxPoint] =
{
{ 1 , 10 , -1 , 30 , 100 } ,
{ -1 , 0 , 50 , -1 , -1 } ,
{ -1 , -1 , 0 , -1 , 10 } ,
{ -1 , -1 , 20 , 0 , 60 } ,
{ -1 , -1 , -1 , -1 , -1 }
};
int size = 5;
int start = 0;
int dest = 1;
int pathlen;
int path[maxPoint];
double dist;
CGraph g;
g.SetGraph( graph , start , size );
g.Display();
printf( '----------------------------------------\n' );
for( dest = 0 ; dest < size ; dest++ )
{
dist = g.GetBestWay( dest , path , pathlen );
printf( '从 %d 到 %d 的最短路径长 %.f\n' , g.GetStartPoint() , dest , dist );
printf( '所经结点为:\n' );
for( int i = 0 ; i < pathlen ; i++ )
printf( '%3d' , path[i] );
printf( '\n----------------------------------------\n' );
}
getch();
return 0;
}
////////////////////////////////////////////////////////////
// 程序说明：
// 本程序在 VC++.NET 2003 上调试通过
// 首先建立 Win32控制台应用程序，工程名为 Dijkstra
// 工程设置默认
// 添加 一般C++类 CGraph
// 填写以上内容
❼ 数据结构之图：求所有节点之间的最短路径，用什么算法时间复杂度小求答案与解释
两者时间复杂度一般都是O(n3)，但对于稀疏图来说重复使用Dijkstra方法比较好！
Dijkstra算法时间复杂度为O（V*V+E）,可以用优先队列进行优化，优化后时间复杂
度变为0（v*lgn）。
源点可达的话，O（V*lgV+E*lgV）=>O（E*lgV）。
当是稀疏图的情况时，此时E=V*V/lgV，所以算法的时间复杂度可为O（V^2） 。可以用优先队列进行优化，优化后时间复杂度变为0（v*lgn）。
具体详细解释你可以看看这个http://blog.chinaunix.net/uid-27164517-id-3287891.html。
❽ 有什么无权无向图的最短路径算法比较好，求一个用java实现的
有什么无权无向图的最短路径算法比较好
带权图也分有向和无向两种，基本的算法可以看看书咯。 带权的无向图的最短路径又叫最小生成树，Prim算法和Kruskal算法； 带权的有向图的最短路径算法有迪杰斯特拉算法和佛洛依德算法；
String[]s={"January","February","March","April","May","June","July","August","September","October","November","December"};
System.out.print("请输入数字（1-12）：");
BufferedReaderbr=newBufferedReader(newInputStreamReader(System.in));
Stringstr=br.readLine();
intm=Integer.parseInt(str);
if(m<=0||m>=13)
{
❾ 求无向图的最短路径C/C++/C#算法
using System;
using System.Collections.Generic;
using System.Text;
namespace PathEst
{
public static class qu
{
public static string shortest(int[][] g, int a, int v)
//g,矩阵图。a,2起点。v,5终点。返回值,最后路径
{
int t = v;
int[] P = new int[6];//用来存储得到的最短路径
int[] D = new int[6];//用于存储由a到其它路径的长度
const int INFINITY = 65535;
int[] final = new int[6];//保存结点是否已访问过
for (int i = 0; i < 6; ++i)//初始化
{
D[i] = g[a][i];//路径长度
P[i] = a;//由此可“叶落归根”
final[i] = 0;
}
final[a] = 1;//不访问起点
for (int i = 1; i < 6; ++i)
{
int min = INFINITY;//当前的最短路径
for (int w = 0; w < 6; ++w)//取最距离a最近的点v
{
if ((final[w] == 0) && (D[w] < min))
//如果存在更短的路径，替换
{
v = w;
min = D[w];
}
}
final[v] = 1;
for (int w = 0; w < 6; ++w)
//如果v是最短路径上的点，加到P[]中
{
if ((final[w] == 0) && (min + g[v][w] < D[w]))
{
D[w] = min + g[v][w];
P[w] = v;//从a到w最近路径，是v
}
}
}
//现在，P中已存在最短路径。。。D[t]，是路径长度
string r = t.ToString();
do
{
r += P[t].ToString();
t = P[t];
} while (t != a);//读出反向路径
//倒置字符串
char[] chararray = r.ToCharArray();
Array.Reverse(chararray);
return new string(chararray);
}
}
}