有向图最短距离java（无向图最短距离）

本篇文章给大家谈谈有向图最短距离java，以及无向图最短距离对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

1、JAVA实现距离矢量算法2、求有向图Djistra算法C/C++代码3、JAVA，已知当前经纬度和距离，计算符合距离条件的经度最大值、最小值和纬度的最大值、最小值。4、图文解析 | Dijkstra单源最短路径算法5、数据结构求最短路径

JAVA实现距离矢量算法

public static void main(String[] args) {

new Jsq();

}

/* 利用构造进行实例化 */

public Jsq() {

求有向图Djistra算法C/C++代码

参考

/*===============================================

单源最短路径

Dijkstra 算法

适用条件：所有边的权非负

!!注意：

1.输入的图的权必须非负

2.顶点标号从0开始

3.当i,j不相邻时G[i,j]=infinity

================================================*/

int Dijkstra(Graph G,int n,int s,int t, int path[])

{

int i,j,w,minc, d[max_vertexes], mark[max_vertexes];

for (i=0; in; i++) mark[i]=0;

for (i=0; in; i++)

{

d[i]=G[s][i];

path[i]=s;

}

mark[s]=1; path[s]=0; d[s]=0;

for(i=1; in; i++)

{

minc = infinity;

w = 0;

for( j = 0; j n; j++ )

if( ( mark[j]==0 ) ( minc = d[j] ) ) {

minc=d[j];w=j;

}

mark[w]=1;

for(j=0; jn; j++)

if( (mark[j]==0) ( G[w][j] != infinity ) ( d[j] d[w]+G[w][j] ) )

{

d[j]=d[w]+G[w][j];

path[j]=w;

}

}

return d[t];

}

JAVA，已知当前经纬度和距离，计算符合距离条件的经度最大值、最小值和纬度的最大值、最小值。

自己算太麻烦了吧，用已有的工具包不行么？

如果支持GEO的话可以用spatial4j，不需要GEO用jts，画个圆，取外切框就行吧

6378137这个数，是赤道的6378.137，南北极的是6371.0087714

图文解析 | Dijkstra单源最短路径算法

给定 加权有向图 G=(V,E,W)，每条边的权值w为 非负数 ，表示两个顶点间的距离。

源点s∈V。

求：从s出发到其他各个顶点的最短路径。

如上图所示，以1为源点，计算到其余各个顶点的最短距离（我已用红线标出）。下面列出了最终解：

S集合 ：当从s到x（x ∈V ）的最短路径找到时，则x ∈S。当所有顶点都进入S集合时，算法结束。

初始：S=｛s｝，当S=V时算法结束。

从s到u相对于S的最短路径 ：指从s到u且仅经过S中顶点的最短路径。

dist[u]:从s到u相对于S的最短路径长度

short[u]:从s到u最短路径的长度（算法最终解）

dist[u] ≥ short[u]

Dijkstra算法采用贪心算法模式，算法过程就是通过计算dist[u],不断扩充S集合，同时dist[u]会不断优化改善，直到dist[u] = short[u]，并将其放到S中，当所有顶点都放入S集合时，算法结束。

输入：加权有向图G=(V,E,W)

          V={1,2,…,n}, s=1

输出：从s到每个顶点的最短路径

输入：G=(V,E,W)，源点1

          V={1,2,3,4,5,6}

初始S集合只有1，计算直接从1能到达的顶点的距离，其他不能从1号顶点直接到达的顶点都记为无穷大。此时从dist[u]里找出最短距离的顶点（6号），并将其放进S集合。

  S={1}

  dist[1] = 0

  dist[2] = 10

  dist[6 ] = 3

  dist[3] = ∞

  dist[4] = ∞

  dist[5] = ∞

当把6号顶点放进S集合后，经由6号顶点出发到达的顶点的最短距离可能会被优化更新，因为该算法的思想很“贪心”，谁更短我要谁！比如1-6-2要比1-2距离更短，所以dist[2]被更新为5，从专业术语上讲，这个“更新”过程叫做松弛，其他点同理。然后从dist[u]里找出最短的路径的那个顶点（5号），并放进S集合里。

  S={1,6}

  dist[1] = 0

 dist[6] = 3

  dist[2] = 5

  dist[4] = 9

  dist[5] = 4

  dist[3] = ∞

后面的操作步骤其实就是重复上面的操作。即当S集合里有个新的顶点后，就可能会更新其他点的最短距离，更新一遍后，找出当前最短距离的dist[u]，并将该顶点放进S集合。后面不重复阐述。

  S={1,6,5}

  dist[1] = 0

 dist[6] = 3

  dist[5] = 4

  dist[2] = 5

  dist[4] = 9

  dist[3] = ∞

  S={1,6,5,2}

  dist[1] = 0

 dist[6] = 3

  dist[5] = 4

 dist[2] = 5

  dist[4] = 9

  dist[3] = 12

  S={1,6,5,2,4}

  dist[1] = 0

 dist[6] = 3

  dist[5] = 4

 dist[2] = 5

 dist[4] = 9

  dist[3] = 12

  S={1,6,5,2,4,3}

  dist[1] = 0

 dist[6] = 3

  dist[5] = 4

 dist[2] = 5

 dist[4] = 9

 dist[3] = 12

当有向图中的所有顶点都进入了S集合后，算法结束，此时的dist[u]的值其实就是最初我们找出的那个最终解short[u]，所以，算法结束时，dist[u]=short[u],得到最终解。

数据结构求最短路径

用Dijkstra算法求从V1顶点到其他各顶点的最短距离和最短路径的C语言程序如下

#include stdio.h

#include string.h

#include stdlib.h

#define N 6 // 顶点数

#define INF 32767

int adj_arr[N][N] = {{INF, 2, 3, INF, INF, INF},

                   {INF, INF, INF, 5, INF, INF},

                   {INF, INF, INF, 3, 10, INF},

                   {INF, INF, INF, INF, INF, 4},

                   {INF, INF, INF, INF, INF, INF},

                   {INF, INF, INF, INF, 2, INF}}; // 用一个全局二维数组存储带权有向图的邻接矩阵

void shortest_path(int start, int end);

void print_shortest_path(int* distance,int* path,int* used,int start,int end);

int main(){

  int i;

  char s1[3];

  for(i=1;i6;i++){

   shortest_path(0, i);

  }

  return 0;

}

void shortest_path(int start, int end){ // 基于Dijkstra算法的最短路径函数

  int distance[N]; // 用于存放起始点到其余各点的最短距离

  int path[N]; // 用于存放起始点到其余各点最短路径的前一个顶点

  int used[N] = { 0 }; // 用于标记该顶点是否已经找到最短路径

  int i, j, min_node, min_dis, pass_flag = 0;

  for(i = 0; i N; i++){

      distance[i] = adj_arr

本篇文章给大家谈谈有向图最短距离java，以及无向图最短距离对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

[i]; // 初始化距离数组

      if(adj_arr

本篇文章给大家谈谈有向图最短距离java，以及无向图最短距离对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

[i] INF){

          path[i] = start; // 初始化路径数组

      }else{

          path[i] = -1;

      }

  }

  used

本篇文章给大家谈谈有向图最短距离java，以及无向图最短距离对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

= 1;

  path

本篇文章给大家谈谈有向图最短距离java，以及无向图最短距离对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

= start;

  for(i = 0; i N; i++){

      min_dis = INF;

      for(j = 0; j N; j++){

          if(used[j] == 0 distance[j] min_dis){

              min_node = j;

              min_dis = distance[j];

              pass_flag++; // 标记是否存在通路

          }

      }

      if(pass_flag != 0){

          used[min_node] = 1;

          for(j = 0; j N; j++){

              if(used[j] == 0){

                  if(adj_arr[min_node][j] INF distance[min_node] + adj_arr[min_node][j] distance[j]){

                      distance[j] = distance[min_node] + adj_arr[min_node][j];

                      path[j] = min_node;

                  }

              }

          }

      }else{

          printf(“没有通路!\n”);

          return;

      }

  }

  print_shortest_path(distance, path, used, start, end);

  return;

}

void print_shortest_path(int* distance,int* path,int* used,int start,int end){ // 输出最短距离并打印最短路径

  int i = 0, pre, inverse_path[N];

  char s1[3],s2[3];

  sprintf(s1, “V%d”, (start+1));

  sprintf(s2, “V%d”, (end+1));

  printf(“从%s顶点到%s顶点的最短距离: %d\n”, s1,  s2, distance

有向图最短距离java的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于无向图最短距离、有向图最短距离java的信息别忘了在本站进行查找喔。

);

  inverse_path[i] = end;

  pre = path

有向图最短距离java的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于无向图最短距离、有向图最短距离java的信息别忘了在本站进行查找喔。

;

  if(pre == -1){

      printf(“没有通路!\n”);

  }else{

      while(pre != start){

          inverse_path[++i] = pre;

          pre = path[pre];

      }

      inverse_path[++i] = start;

      printf(“从%s顶点到%s顶点的最短路径:\n”, s1, s2);

      for(; i 0; i–){

          sprintf(s1, “V%d”, (inverse_path[i]+1));

          printf(“%s – “, s1);

      }

      sprintf(s1, “V%d”, (inverse_path[i]+1));

      printf(“%s\n”, s1);

  }

  return;

}

有向图最短距离java的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于无向图最短距离、有向图最短距离java的信息别忘了在本站进行查找喔。