《算法》第四章部分程序 part 19
▶ 书中第四章部分程序,包括在加上自己补充的代码,有边权有向图的邻接矩阵,FloydWarshall 算法可能含负环的有边权有向图任意两点之间的最短路径
● 有边权有向图的邻接矩阵
package package01; import java.util.Iterator;
import java.util.NoSuchElementException;
import edu.princeton.cs.algs4.StdOut;
import edu.princeton.cs.algs4.StdRandom;
import edu.princeton.cs.algs4.DirectedEdge; public class class01
{
private static final String NEWLINE = System.getProperty("line.separator"); private final int V;
private int E;
private DirectedEdge[][] adj; public class01(int inputV)
{
if (inputV < 0)
throw new IllegalArgumentException("\n<Constructor> V < 0.\n");
V = inputV;
E = 0;
adj = new DirectedEdge[V][V];
} public class01(int inputV, int inputE)
{
this(inputV);
if (inputE < 0 || inputE > V*V)
throw new IllegalArgumentException("\n<Constructor> E < 0 || E > V*V.\n"); for (E = 0; E != inputE;)
{
int v = StdRandom.uniform(V), w = StdRandom.uniform(V);
double weight = Math.round(100 * StdRandom.uniform()) / 100.0;
addEdge(new DirectedEdge(v, w, weight));
}
} public int V()
{
return V;
} public int E()
{
return E;
} public void addEdge(DirectedEdge e)
{
int v = e.from();
int w = e.to();
if (adj[v][w] == null)
{
E++;
adj[v][w] = e;
}
} public Iterable<DirectedEdge> adj(int v)
{
return new AdjIterator(v);
} private class AdjIterator implements Iterator<DirectedEdge>, Iterable<DirectedEdge>
{
private int v;
private int w = 0; public AdjIterator(int inputV)
{
v = inputV;
} public Iterator<DirectedEdge> iterator()
{
return this;
} public boolean hasNext() // 同一行里还有元素(还有以该顶点为起点的边)
{
for (; w < V; w++)
{
if (adj[v][w] != null)
return true; }
return false;
} public DirectedEdge next()
{
if (!hasNext())
throw new NoSuchElementException();
return adj[v][w++];
} public void remove()
{
throw new UnsupportedOperationException();
}
} public String toString()
{
StringBuilder s = new StringBuilder();
s.append(V + " " + E + NEWLINE);
for (int v = 0; v < V; v++)
{
s.append(v + ": ");
for (DirectedEdge e : adj(v))
s.append(e + " ");
s.append(NEWLINE);
}
return s.toString();
} public static void main(String[] args)
{
int V = Integer.parseInt(args[0]);
int E = Integer.parseInt(args[1]);
class01 G = new class01(V, E);
StdOut.println(G);
}
}
● FloydWarshall 算法可能含负环的有边权有向图任意两点之间的最短路径
package package01; import edu.princeton.cs.algs4.StdOut;
import edu.princeton.cs.algs4.StdRandom;
import edu.princeton.cs.algs4.DirectedEdge;
import edu.princeton.cs.algs4.EdgeWeightedDigraph;
import edu.princeton.cs.algs4.EdgeWeightedDirectedCycle;
import edu.princeton.cs.algs4.Stack;
import edu.princeton.cs.algs4.AdjMatrixEdgeWeightedDigraph; public class class01
{
private boolean hasNegativeCycle; // 是否有负环
private double[][] distTo; // 从 v 到 w 的最短路径记作 distTo[v][w]
private DirectedEdge[][] edgeTo; // 从 v 到 w 的最短路径的最后一条边记作 edgeTo[v][w] public class01(AdjMatrixEdgeWeightedDigraph G)
{
int V = G.V();
distTo = new double[V][V];
edgeTo = new DirectedEdge[V][V];
for (int v = 0; v < V; v++) // 邻接表元素初始化为正无穷
{
for (int w = 0; w < V; w++)
distTo[v][w] = Double.POSITIVE_INFINITY;
}
for (int v = 0; v < G.V(); v++)
{
for (DirectedEdge e : G.adj(v)) // 添加以 v 为起点的各条边
{
distTo[e.from()][e.to()] = e.weight();
edgeTo[e.from()][e.to()] = e;
}
if (distTo[v][v] >= 0.0) // 自环归零
{
distTo[v][v] = 0.0;
edgeTo[v][v] = null;
}
}
for (int i = 0; i < V; i++) // 循环 V 次
{
for (int v = 0; v < V; v++) // 用 0 ~ i 作为中间顶点,尝试将其引入
{
if (edgeTo[v][i] == null) // v 不可达 i,跳过
continue;
for (int w = 0; w < V; w++)
{
if (distTo[v][w] > distTo[v][i] + distTo[i][w]) // 引入顶点 i 使得 v 到 w 的距离缩短
{
distTo[v][w] = distTo[v][i] + distTo[i][w]; // 正式引入顶点 i
edgeTo[v][w] = edgeTo[i][w];
}
}
if (distTo[v][v] < 0.0) // 检测负环,条件是某顶点到自身的最短路径小于 0
{
hasNegativeCycle = true;
return;
}
}
}
} public boolean hasNegativeCycle()
{
return hasNegativeCycle;
} public Iterable<DirectedEdge> negativeCycle()
{
for (int v = 0; v < distTo.length; v++)
{
if (distTo[v][v] < 0.0)
{
int V = edgeTo.length;
EdgeWeightedDigraph spt = new EdgeWeightedDigraph(V);
for (int w = 0; w < V; w++) // 把与 v 有关的边加入一个含边权有向图,用类 EdgeWeightedDirectedCycle 寻找环
{
if (edgeTo[v][w] != null) // 实际上所有从 v 延伸出去的最短路径的边都加上了
spt.addEdge(edgeTo[v][w]);
}
EdgeWeightedDirectedCycle finder = new EdgeWeightedDirectedCycle(spt);
return finder.cycle();
}
}
return null;
} public boolean hasPath(int s, int t)
{ return distTo[s][t] < Double.POSITIVE_INFINITY;
} public double dist(int s, int t)
{
if (hasNegativeCycle())
throw new UnsupportedOperationException("\n<dist> Negative cost cycle exists.\n");
return distTo[s][t];
} public Iterable<DirectedEdge> path(int s, int t)
{
if (hasNegativeCycle())
throw new UnsupportedOperationException("\n<Iterable> Negative cost cycle exists.\n");
if (!hasPath(s, t))
return null;
Stack<DirectedEdge> path = new Stack<DirectedEdge>();
for (DirectedEdge e = edgeTo[s][t]; e != null; e = edgeTo[s][e.from()])
path.push(e);
return path;
} public static void main(String[] args)
{
int V = Integer.parseInt(args[0]);
int E = Integer.parseInt(args[1]);
AdjMatrixEdgeWeightedDigraph G = new AdjMatrixEdgeWeightedDigraph(V);
for (int i = 0; i < E; i++)
{
int v = StdRandom.uniform(V);
int w = StdRandom.uniform(V);
double weight = Math.round(100 * (StdRandom.uniform() - 0.15)) / 100.0;
if (v == w) G.addEdge(new DirectedEdge(v, w, Math.abs(weight)));
else G.addEdge(new DirectedEdge(v, w, weight));
} StdOut.println(G);
class01 spt = new class01(G);
StdOut.printf(" ");
for (int v = 0; v < G.V(); v++)
StdOut.printf("%6d ", v);
StdOut.println();
for (int v = 0; v < G.V(); v++)
{
StdOut.printf("%3d: ", v);
for (int w = 0; w < G.V(); w++)
{
if (spt.hasPath(v, w))
StdOut.printf("%6.2f ", spt.dist(v, w));
else
StdOut.printf(" Inf "); // 存在负环的路径长度显示为负无穷
}
StdOut.println();
}
if (spt.hasNegativeCycle()) // 有负环单独显示,否则正常显示各条最短路径
{
StdOut.println("Negative cost cycle:");
for (DirectedEdge e : spt.negativeCycle())
StdOut.println(e);
StdOut.println();
}
else
{
for (int v = 0; v < G.V(); v++)
{
for (int w = 0; w < G.V(); w++)
{
if (spt.hasPath(v, w)) {
StdOut.printf("%d to %d (%5.2f) ", v, w, spt.dist(v, w));
for (DirectedEdge e : spt.path(v, w))
StdOut.print(e + " ");
StdOut.println();
}
else
StdOut.printf("%d to %d no path\n", v, w);
}
}
}
}
}
《算法》第四章部分程序 part 19的更多相关文章
- 《算法》第四章部分程序 part 18
▶ 书中第四章部分程序,包括在加上自己补充的代码,在有权有向图中寻找环,Bellman - Ford 算法求最短路径,套汇算法 ● 在有权有向图中寻找环 package package01; impo ...
- 《算法》第四章部分程序 part 16
▶ 书中第四章部分程序,包括在加上自己补充的代码,Dijkstra 算法求有向 / 无向图最短路径,以及所有顶点对之间的最短路径 ● Dijkstra 算法求有向图最短路径 package packa ...
- 《算法》第四章部分程序 part 15
▶ 书中第四章部分程序,包括在加上自己补充的代码,Kruskal 算法和 Boruvka 算法求最小生成树 ● Kruskal 算法求最小生成树 package package01; import e ...
- 《算法》第四章部分程序 part 14
▶ 书中第四章部分程序,包括在加上自己补充的代码,两种 Prim 算法求最小生成树 ● 简单 Prim 算法求最小生成树 package package01; import edu.princeton ...
- 《算法》第四章部分程序 part 10
▶ 书中第四章部分程序,包括在加上自己补充的代码,包括无向图连通分量,Kosaraju - Sharir 算法.Tarjan 算法.Gabow 算法计算有向图的强连通分量 ● 无向图连通分量 pack ...
- 《算法》第四章部分程序 part 9
▶ 书中第四章部分程序,包括在加上自己补充的代码,两种拓扑排序的方法 ● 拓扑排序 1 package package01; import edu.princeton.cs.algs4.Digraph ...
- 《算法》第四章部分程序 part 17
▶ 书中第四章部分程序,包括在加上自己补充的代码,无环图最短 / 最长路径通用程序,关键路径方法(critical path method)解决任务调度问题 ● 无环图最短 / 最长路径通用程序 pa ...
- 《算法》第四章部分程序 part 13
▶ 书中第四章部分程序,包括在加上自己补充的代码,图的前序.后序和逆后续遍历,以及传递闭包 ● 图的前序.后序和逆后续遍历 package package01; import edu.princeto ...
- 《算法》第四章部分程序 part 12
▶ 书中第四章部分程序,包括在加上自己补充的代码,图的几种补充数据结构,包括无向 / 有向符号图,有权边结构,有边权有向图 ● 无向符号图 package package01; import edu. ...
随机推荐
- Hadoop错误集:Could not find the main class: org.apache.hadoop.*
在搭建Hadoop机群的时候,之前遇见了很多次找不到类的错误,因为对Hadoop了解不深,所以就在网上漫无目的的找解决方案,所以这里总结下我用的方法. 解决办法一: 我之前遇到了找不到 org.apa ...
- 51nod 1132 覆盖数字的数量 V2
http://www.51nod.com/onlineJudge/questionCode.html#!problemId=1132 题意是给定a,b,l,r求[l,r]内有几个整数可以表示成ax+b ...
- Hadoop概念学习系列之Hadoop、Spark学习路线(很值得推荐)(十八)
不多说,直接上干货! 说在前面的话 此笔,对于仅对于Hadoop和Spark初中学者.高手请忽略! 1 Java基础: 视频方面: 推荐<毕向东JAVA基础视频教程>.学 ...
- Sqoop-1.4.6安装部署及详细使用介绍
之所以选择Sqoop1是因为Sqoop2目前问题太多.无法正常使用,综合比较后选择Sqoop1. Sqoop1安装配置比较简单 一.安装部署 (1).下载安装包 下载地址:http://archive ...
- 廖雪峰Java1-4数组操作-1遍历数组
1.遍历数组 for循环通过下标遍历数组 for each直接遍历数组所有元素 int[] ns1 = {1, 34, 9, 16, 25}; for(int i = 0;i<ns1.lengt ...
- jmap、jstack、jps无法连接jvm解决办法
转载 http://blog.51cto.com/zhangshaoxiong/1310166 一.背景 在对线上服务器的java应用dump操作时发现,以下报错,不能dump.jps也获取不到jav ...
- keystone认证服务
实验操作平台:OpenStack单节点操作 一.相关概念 1.认证(authentication) 认证是确认允许一个用户访问的进程 2.证书(credentials) 用于确认用户身份的数据 3.令 ...
- Jmeter(十七)Logic Controllers 之 Interleave Controller
Interleave Controller----交错控制器,对于交错控制器官方文档解释的很清楚,上例子: 可以看到运行一次 Interleave Controller下的Sampler,运行一次 I ...
- [UE4]C++代码实现播放粒子特效
转自:http://aigo.iteye.com/blog/2273345 函数参数说明(在GameplayStatics.h中) 将一个粒子放到指定位置上播放: 另一种重载形式: 将一个粒子atta ...
- java中原生的发送http请求(无任何的jar包导入)
package com.teamsun.pay.wxpay.util; import java.io.BufferedReader; import java.io.IOException; impor ...