javadijkstra算法

发布时间: 2023-02-14 03:01:48

Ⅰ java中最短路径算法

给你个算graph上最短路径的比较流行的方法

Algorithm Dijkstra(V, E, cost, s)
T ;
Cost(V[s]) 0
Prev(V[s]) none
for i 0 to length[V] - 1 do
if (i 6= s) then
Cost(V[i]) +1
Prev(V[i]) none
Build heap NotInTree from V
for i 1 to length[V] do
u DeleteMin(NotInTree)
add (u, Prev(u)) to T
for each neighbor v of u do
if (Cost(v) > Cost(u) + cost(u,v)) then
Cost(v) Cost(u) + cost(u,v)
Prev(v) u
return T

Ⅱ 题目1:一个简单的算法演示程序(JAVA语言实现)

1. 选择一个算法（提供选择见下），利用各种方法（图形、动画等）演示算法的演示过程。
2. 可以进行手动演示，也可以自动步进式演示。
3. 允许用户设置算法的各个输入参数，以及自动步进式演示中的时间间隔。
4. 不同的算法输入要求见下。
界面要求：
1. 尽量使用图形界面实现，要符合日常软件使用规范来设计菜单和界面。
2. 如果无法实现图形界面，则在命令行方式下也需要提供菜单，方便用户操作。
其他要求：
1. 标识符命名遵循Windows命名规范。
2. 能够注意各种异常处理，注重提高程序运行效率。
提交内容：
1. 全部源代码。
2. 软件设计和使用说明书（UML类图；实现的功能、主要技术；使用帮助文档）
参考算法：
1. 最小生成树算法：Prim算法、Kruskal算法。允许以下方式输入一个图形：绘制图形、输入邻接矩阵、输入边及其关联的顶点。要求在图形方式下进行演示算法执行步骤。
2. 单源最短路算法：Dijkstra算法。允许以下方式输入一个图形：绘制图形、输入邻接矩阵、输入边及其关联的顶点。要求在图形方式下进行演示算法执行步骤。
3. 最优编码算法：Huffman编码算法。允许用户输入一段英文文字，或者打开一个txt文档（英文内容），据此文档内容进行编码。要求动态列出每个字符的出现概率统计结果以及对应编码。
4. 其他可供演示的具有一定难度的算法，如关键路径问题、有向图的极大连通分支等。

Ⅲ 求数据结构公交线路咨询的代码用java，其中求最短路径用Floyd算法

不知道你想怎么搞反正感觉A*算法也可以，网上一大堆，还有就是Dijkstra算法

Ⅳ 求大佬用java帮我实现dijkstra算法，单源最短路径

python">import heapq
from collections import defaultdict
edges = [["A","B"],["A","D"],["A","E"],["B","C"],["C","E"],["D","E"],["D","C"]]
dist = [10,30,100,50,10,60,20]
res = []
def dijkstra(e,dist,start,end):
‍  hm = defaultdict(list)
‍  for i in range(len(e)):
‍  ‍  hm[e[i][0]].append((e[i][1],dist[i]))
‍  r = {}
‍  r[start] = 0
‍  q = [(0,start,[start])]
‍  while q:
‍  ‍  dis,node,res = heapq.heappop(q)
‍  ‍  if node == end:
‍  ‍  ‍  return dis,res
‍  ‍  for u,v in hm[node]:
‍  ‍  ‍  t = dis+v
‍  ‍  ‍  if u not in r or t < r[u]:
‍  ‍  ‍  ‍  r[u] = t
‍  ‍  ‍  ‍  heapq.heappush(q,(t,u,res+[u]))
‍  return 0,[]
dijkstra(edges,dist,"A","E")

Ⅳ webService 请求报错： Caused by: java.lang.NoSuchMethodError: javax.wsdl.xml.WSDLReader.readWSD

Java最新帖子JAVA GC 机制详解fastjson获取unknown的字段150. Evaluate Reverse Polish NotationJAVA 常用集合内部机制原理OWNER支持配置文件目录的继承ThreadPoolExecutor策略配置以及应用场景通过maven管理不同环境下的配置文件MyBatis 基本用法NumberPicker实现滑动选择MyBatis 使用annonation定义类型映射Java热门帖子Android入门简单实例Android中Socket通信的实现方法概述模拟打印机排队打印效果Java设计模式之责任链模式简介实例解读Ajax与servlet交互的方法java压缩zip文件中文乱码问题解决方法基于Java实现的Dijkstra算法示例JAVA中使用双括号来初始化静态常量的小技巧Java8新特性之重复注解（repeating annotations）浅析Jedis出现connection timeout问题解决方法（JedisPool连接池使用实例）

Ⅵ 一个有关于java的算法问题，求高手协做

//参考别人的,自己就懒得写了,你拿去参考参考...

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class Dijkstra {
private int[][] graph;// 加权有向图
private int start;// 源点编号从 0开始
private int dimention;
static int INF = Integer.MAX_VALUE / 100;
// 用于标记顶点是否已经计算
private Set<Integer> vertexSet = new HashSet<Integer>();
// 存储结果，Map的key对应各终点编号，value对应路径编号列表。
private Map<Integer, List<Integer>> pathListMap = new HashMap<Integer, List<Integer>>();

public Dijkstra(int[][] graph, int start) {
this.graph = graph;
this.start = start;
this.dimention = graph.length;
calculate();
}

private void calculate() {
// 初始化
for (int end = 0; end < dimention; end++) {
if (end == start) {
continue;
}// 起始点自己的路径排除。
List<Integer> pathList = new ArrayList<Integer>();
pathList.add(start);// 每条路径的起始点都为start，pathList只记录编号，不记录路径权值
pathList.add(end);// 每条路径的第二个参数为终点编号
pathListMap.put(end, pathList);
}
// 计算主体
for (int bridge = 0; bridge < dimention; bridge++) {
if (bridge == start) {
continue;
}
if (!vertexSet.contains(bridge)) {// 确保每个基点只循环计算一次
for (int next = 0; next < dimention; next++) {
if (next == start || next == bridge) {
continue;
}
if (startTo(bridge) + getRawLength(bridge, next) < startTo(next)) {
List<Integer> pathList = pathListMap.get(next);
List<Integer> bridgePathList = pathListMap.get(bridge);
// 清空，使用新的
pathList.clear();
pathList.addAll(bridgePathList);
pathList.add(next);
}
}
}
vertexSet.add(bridge);
}
// 检查，是否桥接的路径都被更新
for (int end = 0; end < dimention; end++) {
if (end == start) {
continue;
}
List<Integer> pathList = pathListMap.get(end);
int size = pathList.size();
if (size > 2) {
for (int end2 = 0; end2 < dimention; end2++) {
int isEnd = pathList.get(size - 2);
if (end2 == isEnd) {
pathList.clear();
pathList.addAll(pathListMap.get(end2));
pathList.add(end);
}
}
}
}
}

private int startTo(int end) {
int pathLen = 0;
List<Integer> pathList = pathListMap.get(end);
for (int i = 0; i < pathList.size() - 1; i++) {
pathLen += graph[pathList.get(i)][pathList.get(i + 1)];
}
return pathLen;
}

private int getRawLength(int start, int end) {
if (end == start) {
return 0;
}
return graph[start][end];
}

public int getLength(int end) {
if (end == start) {
return 0;
}
return startTo(end);
}

public void printResult() {
System.out.println(pathListMap);
}

public Map<Integer, List<Integer>> getPathListMap() {
return pathListMap;
}

public static void main(String[] args) {
/*
* int [][] graph = { { INF, 10, INF, 30, 100}, { INF, INF, 50, INF,
* INF}, { INF, INF, INF, INF, 10}, { INF, INF, 20, INF, 60}, { INF,
* INF, INF, INF, INF}};
*/
int[][] graph = { { INF, INF, 10, INF, 30, 100 },
{ INF, INF, 5, INF, INF, INF },
{ INF, INF, INF, 50, INF, INF },
{ INF, INF, INF, INF, INF, 10 },
{ INF, INF, INF, 20, INF, 60 },
{ INF, INF, INF, INF, INF, INF }, };
int start = 0;
int end = 0;
int length = graph.length;
for (start = 0; start < length; start++) {
System.out.println();
Dijkstra dijkstra = new Dijkstra(graph, start);
dijkstra.printResult();
for (end = 0; end < length; end++) {
if (end == start) {
continue;
}
int len = dijkstra.getLength(end);
System.out.println(" Length(" + start + "-" + end + ") = "
+ ((len == INF) ? "Infinity" : len));
}
}
}
}

Ⅶ 自然语言处理（NLP）的基础难点：分词算法

自然语言处理（NLP，Natural Language Processing）是人工智能领域中的一个重要方向，主要研究人与计算机之间用自然语言进行有效通信的各种理论和方法。自然语言处理的底层任务由易到难大致可以分为词法分析、句法分析和语义分析。分词是词法分析（还包括词性标注和命名实体识别）中最基本的任务，也是众多NLP算法中必不可少的第一步，其切分准确与否往往与整体结果息息相关。

金融领域分词的难点

分词既简单又复杂。简单是因为分词的算法研究已经很成熟了，大部分的算法（如HMM分词、CRF分词）准确率都可以达到95%以上；复杂则是因为剩下的5%很难有突破，主要可以归结于三点：

▲粒度，即切分时的最小单位，不同应用对粒度的要求不一样，比如“融资融券”可以是一个词也可以是两个词

▲歧义，比如“恒生”一词，既可指恒生公司，又可指恒生指数

▲未登录词，即未出现在算法使用的词典中的词，比如不常见的专业金融术语，以及各种上市公司的名称

在金融领域中，分词也具有上述三个难点，并且在未登录词方面的难点更为突出，这是因为金融类词汇本来就多，再加上一些专有名词不仅有全称还有简称，这就进一步增大了难度。

在实际应用中，以上难点时常会造成分词效果欠佳，进而影响之后的任务。尤其是在一些金融业务中，有许多需要与用户交互的场景，某些用户会用口语化的词汇描述业务，如果分词错误会影响用户意图的解析，这对分词的准确性提出了更高的要求。因此在进行NLP上层应用开发时，需要对分词算法有一定的了解，从而在效果优化时有能力对分词器进行调整。接下来，我们介绍几种常用的分词算法及其应用在金融中的优劣。

几种常见的分词算法

分词算法根据其核心思想主要分为两种：

第一种是基于字典的分词，先把句子按照字典切分成词，再寻找词的最佳组合方式，包括最大匹配分词算法、最短路径分词算法、基于N-Gram model的分词算法等；

第二种是基于字的分词，即由字构词，先把句子分成一个个字，再将字组合成词，寻找最优的切分策略，同时也可以转化成序列标注问题，包括生成式模型分词算法、判别式模型分词算法、神经网络分词算法等。

最大匹配分词寻找最优组合的方式是将匹配到的最长词组合在一起，主要的思路是先将词典构造成一棵Trie树（也称为字典树），Trie树由词的公共前缀构成节点，降低了存储空间的同时可以提升查找效率。

最大匹配分词将句子与Trie树进行匹配，在匹配到根结点时由下一个字重新开始进行查找。比如正向（从左至右）匹配“他说的确实在理”，得出的结果为“他／说／的确／实在／理”。如果进行反向最大匹配，则为“他／说／的／确实／在理”。

这种方式虽然可以在O(n)时间对句子进行分词，但是只单向匹配太过绝对，尤其是金融这种词汇较丰富的场景，会出现例如“交易费/用”、“报价单/位”等情况，所以除非某些词的优先级很高，否则要尽量避免使用此算法。

最短路径分词算法首先将一句话中的所有词匹配出来，构成词图（有向无环图DAG），之后寻找从起始点到终点的最短路径作为最佳组合方式，例：

我们认为图中每个词的权重都是相等的，因此每条边的权重都为1。

在求解DAG图的最短路径问题时，总是要利用到一种性质：即两点之间的最短路径也包含了路径上其他顶点间的最短路径。比如S->A->B->E为S到E到最短路径，那S->A->B一定是S到B到最短路径，否则会存在一点C使得d(S->C->B)<d(S->A->B)，那S到E的最短路径也会变为S->C->B->E，这就与假设矛盾了。利用上述的最优子结构性质，可以利用贪心算法或动态规划两种求解算法：

（1）基于Dijkstra算法求解最短路径，该算法适用于所有带权有向图，求解源节点到其他所有节点的最短路径，并可以求得全局最优解；

（2）N-最短路径分词算法，该方法是对Dijkstra算法的扩展，在每一步保存最短的N条路径，并记录这些路径上当前节点的前驱，在最后求得最优解时回溯得到最短路径。这种方法的准确率优于Dijkstra算法，但在时间和空间复杂度上都更大。

相较于最大匹配分词算法，最短路径分词算法更加灵活，可以更好地把词典中的词组合起来，能更好地解决有歧义的场景。比如上述“他说的确实在理”这句话，用最短路径算法的计算结果为“他／说／的／确实／在理”，避免了正向最大匹配的错误。但是对于词典中未存在的词基本没有识别能力，无法解决金融领域分词中的“未登录词”难点。

N-Gram（又称N元语法模型）是基于一个假设：第n个词出现与前n-1个词相关，而与其他任何词不相关。在此种假设下，可以简化词的条件概率，进而求解整个句子出现的概率。

现实中，常用词的出现频率或者概率肯定比罕见词要大。因此，可以将求解词图最短路径的问题转化为求解最大概率路径的问题，即分词结果为“最有可能的词的组合“。

计算词出现的概率，仅有词典是不够的，还需要充足的语料，所以分词任务已经从单纯的“算法”上升到了“建模”，即利用统计学方法结合大数据挖掘，对“语言”（句子出现的概率）进行建模。

我们将基于N-gram模型所统计出的概率分布应用到词图中，可以得到词的概率图。对该词图用最短路径分词算法求解最大概率的路径，即可得到分词结果。

相较于前两种分词算法，基于N-Gram model的分词算法对词频进行了统计建模，在切分有歧义的时候力求得到全局最优值，比如在切分方案“证券/自营/业务”和“证券/自/营业/务”中，统计出“证券/自营/业务”出现的概率更大，因此结果有更高的准确率。但也依然无法解决金融场景中未登录词的问题。

生成式模型主要有隐马尔可夫模型（HMM，Hidden Markov Model）、朴素贝叶斯分类等。HMM是常用的分词模型，基于Python的jieba分词器和基于Java的HanLP分词器都使用了HMM。

HMM模型认为在解决序列标注问题时存在两种序列，一种是观测序列，即人们显性观察到的句子，另一种是隐状态序列，即观测序列的标签。假设观测序列为X，隐状态序列是Y，则因果关系为Y->X。因此要得到标注结果Y，必须对X的概率、Y的概率、P(X|Y)进行计算，即建立P(X,Y)的概率分布模型。

HMM算法可以在一定程度上解决未登录词的问题，但生成式模型的准确率往往没有接下来要谈到的判别式模型高。

判别式模型主要有感知机、支持向量机（SVM，Support Vector Machine）、条件随机场（CRF，Conditional Random Field）、最大熵模型等，其中感知机模型和CRF模型是常用的分词模型。

（1）平均感知机分词算法

感知机是一种简单的二分类线性模型，通过构造超平面，将特征空间（输入空间）中的样本分为正负两类。通过组合，感知机也可以处理多分类问题。但由于每次迭代都会更新模型的所有权重，被误分类的样本会造成很大影响，因此采用平均的方法，在处理完一部分样本后对更新的权重进行平均。

（2）CRF分词算法

CRF可以看作一个无向图模型，假设给定的标注序列为Y，观测序列为X，CRF对条件概率P(Y|X)进行定义，而不是对联合概率建模。

平均感知机算法虽然速度快，但仍不够准确。适合一些对速度要求高、对准确性要求相对不那么高的场景。CRF分词算法可以说是目前最常用的分词、词性标注和实体识别算法，它对未登陆词也有很好的识别能力，是目前在速度、准确率以及未登录词识别上综合表现最突出的算法，也是我们目前所采用的解决方案，但速度会比感知机慢一些。

在NLP中，最常用的神经网络为循环神经网络（RNN，Recurrent Neural Network），它在处理变长输入和序列输入问题中有着巨大的优势。LSTM（Long Short-Term Memory，长短期记忆网络）为RNN变种的一种，在一定程度上解决了RNN在训练过程中梯度消失和梯度爆炸的问题。

目前对于序列标注任务，业内公认效果最好的模型是BiLSTM+CRF。相比于上述其它模型，双向循环神经网络BiLSTM，可以更好地编码当前字等上下文信息，并在最终增加CRF层，核心是用Viterbi算法进行解码，以得到全局最优解，避免B,S,E这种不可能的标记结果的出现，提高准确率。

神经网络分词虽然能在准确率、未登录词识别上有更好的表现，但RNN无法并行计算，在速度上没有优势，所以该算法通常在算法研究、句子精确解析等对速度要求不高的场景下使用。

分词作为NLP底层任务之一，既简单又重要，很多时候上层算法的错误都是由分词结果导致的。因此，对于底层实现的算法工程师，不仅需要深入理解分词算法，更需要懂得如何高效地实现和调试。

而对于上层应用的算法工程师，在实际分词时，需要根据业务场景有选择地应用上述算法，比如在搜索引擎对大规模网页进行内容解析时，对分词对速度要求大于精度，而在智能问答中由于句子较短，对分词的精度要求大于速度。

Ⅷ 求java实现矩阵图上任意两点的最短路径源码

我用的是递归调用方法，有个小问题就是在打印步数的时候是返向的，原因是就是程序不断的调用自己，到最后判断基值位准退出调用。这才开始从栈里取出方法进行执行的原因。

代码欣赏：

publicstaticintstep=1;

=newStringBuffer();

publicstaticint[][]maze={{1,1,1,1,1,1,1,1,1,1,1},

{1,0,1,0,1,0,0,0,0,0,1},

{1,0,1,0,0,0,1,0,1,1,1},

{1,0,0,0,1,0,1,0,0,0,1},

{1,0,1,1,0,0,1,0,0,1,1},//0代表可以通过，1代表不可通过

{1,0,1,0,1,1,0,1,0,0,1},

{1,0,0,0,0,0,0,0,1,0,1},

{1,0,1,0,1,0,1,0,1,0,1},

{1,0,0,1,0,0,1,0,1,0,1},

{1,1,1,1,1,1,1,1,1,1,1}};

publicstaticvoidmain(String[]args){

inti,j;//循环记数变量

Sample.way(1,1);//二维数组起始值从下标1，1开始

System.out.println("起点从坐标x=1,y=1开始");

System.out.println("终点坐标是x=8,y=9结束");

System.out.println("这是迷宫图表");

System.out.println("012345678910");

System.out.println("+---+---+---+---+---+---+---+---+---+---+---+---+---+");

for(i=0;i<10;i++){

System.out.print(""+i+"‖");

for(j=0;j<11;j++)

System.out.print("-"+maze[i][j]+"-‖");

System.out.println("");

System.out.println("+---+---+---+---+---+---+---+---+---+---+---+---+---+");

}

//打印显示步数

System.out.print(printStep.toString());

}

publicstaticbooleanway(intx,inty){

if(maze[8][9]==2)//代表递归终止条件（也就是当走出出口时标记为2）

returntrue;

else{

if(maze[y][x]==0){

maze[y][x]=2;

*下面if判断条件代表当前坐标为基点，

*根据判断对当前位置进行递归调用：如：

*往上、往右上、往右、往右下、往下、

*往左下、往左、往左上的坐标是否可走，

*判断是否可走的返回条件是：

*2代表可通过、1代表不能通过、3表示已经走过，但是未能走通。

if(way(x,y-1)){