diff --git a/README.md b/README.md index 9dd86e8..7d9e9c3 100644 --- a/README.md +++ b/README.md @@ -72,6 +72,11 @@ Try to keep the interface and variable name consistent with the original book wh * [LazyPrimMST](algs4/lazy_prim_mst.py) * [PrimMST](algs4/prim_mst.py) * [KruskalMST](algs4/kruskal_mst.py) + * Shortest Paths + * [EdgeWeightedDigraph](algs4/edge_weighted_digraph.py) + * [DijkstraSP](algs4/dijkstra_sp.py) + * [AcyclicSP](algs4/acyclic_sp.py) + * [Bellman-FordSP](algs4/bellman_ford_sp.py) * 5 STRING diff --git a/algs4/dijkstra_sp.py b/algs4/dijkstra_sp.py new file mode 100644 index 0000000..ca12316 --- /dev/null +++ b/algs4/dijkstra_sp.py @@ -0,0 +1,86 @@ +""" + * Execution: python dijkstra_sp.py input.txt s + * Data files: https://algs4.cs.princeton.edu/44sp/tinyEWD.txt + * https://algs4.cs.princeton.edu/44sp/mediumEWD.txt + * https://algs4.cs.princeton.edu/44sp/largeEWD.txt + * + * Dijkstra's algorithm. Computes the shortest path tree. + * Assumes all weights are nonnegative. + * + * % python dijkstra_sp.py tinyEWD.txt 0 + * 0 to 0 (0.00) + * 0 to 1 (1.05) 0->4 0.38 4->5 0.35 5->1 0.32 + * 0 to 2 (0.26) 0->2 0.26 + * 0 to 3 (0.99) 0->2 0.26 2->7 0.34 7->3 0.39 + * 0 to 4 (0.38) 0->4 0.38 + * 0 to 5 (0.73) 0->4 0.38 4->5 0.35 + * 0 to 6 (1.51) 0->2 0.26 2->7 0.34 7->3 0.39 3->6 0.52 + * 0 to 7 (0.60) 0->2 0.26 2->7 0.34 + * + * % python dijkstra_sp.py mediumEWD.txt 0 + * 0 to 0 (0.00) + * 0 to 1 (0.71) 0->44 0.06 44->93 0.07 ... 107->1 0.07 + * 0 to 2 (0.65) 0->44 0.06 44->231 0.10 ... 42->2 0.11 + * 0 to 3 (0.46) 0->97 0.08 97->248 0.09 ... 45->3 0.12 + * 0 to 4 (0.42) 0->44 0.06 44->93 0.07 ... 77->4 0.11 + * ... + * +""" + +from algs4.edge_weighted_digraph import EdgeWeightedDigraph +from algs4.index_min_pq import IndexMinPQ +from algs4.stack import Stack + +POSITIVE_INFINITY = 999999.0 + + +class DijkstraSP: + def __init__(self, g, s): + self.edgeTo = [None for _ in range(g.V)] + self.distTo = [float("inf") for _ in range(g.V)] + for v in range(g.V): + self.distTo[v] = POSITIVE_INFINITY + self.distTo[s] = 0.0 + self.pq = IndexMinPQ(g.V) + self.pq.insert(s, self.distTo[s]) + while not self.pq.is_empty(): + self.relax(g, self.pq.del_min()) + + def relax(self, g, v): + for e in g.adj[v]: + w = e.To() + if self.distTo[w] > self.distTo[v]+e.weight: + self.distTo[w] = self.distTo[v] + e.weight + self.edgeTo[w] = e + if self.pq.contains(w): + self.pq.change(w, self.distTo[w]) + else: + self.pq.insert(w, self.distTo[w]) + + def has_path_to(self, v): + return self.distTo[v] < POSITIVE_INFINITY + + def path_to(self, v): + if not self.has_path_to(v): + return None + edges = Stack() + e = self.edgeTo[v] + while e != None: + edges.push(e) + e = self.edgeTo[e.From()] + return edges + + +if __name__ == "__main__": + import sys + graph = EdgeWeightedDigraph(file=open(sys.argv[1])) + s = int(sys.argv[2]) + sp = DijkstraSP(graph, s) + for t in range(graph.V): + if sp.has_path_to(t): + print("%d to %d (%.2f) " % (s, t, sp.distTo[t]), end="") + for e in sp.path_to(t): + print(e, " ", end="") + print() + else: + print("%d to %d no path" % (s, t)) diff --git a/algs4/directed_edge.py b/algs4/directed_edge.py new file mode 100644 index 0000000..8d858be --- /dev/null +++ b/algs4/directed_edge.py @@ -0,0 +1,20 @@ +class DirectedEdge: + def __init__(self, v, w, weight): + self.v = v + self.w = w + self.weight = weight + + def __str__(self): + return "%d->%s %.5f" % (self.v, self.w, self.weight) + + def __lt__(self, other): + return self.weight < other.weight + + def __gt__(self, other): + return self.weight > other.weight + + def From(self): + return self.v + + def To(self): + return self.w diff --git a/algs4/edge_weighted_digraph.py b/algs4/edge_weighted_digraph.py new file mode 100644 index 0000000..48c7957 --- /dev/null +++ b/algs4/edge_weighted_digraph.py @@ -0,0 +1,67 @@ +""" + * Execution: python edge_weighted_graph.py filename.txt + * Data files: https://algs4.cs.princeton.edu/43mst/tinyEWG.txt + * https://algs4.cs.princeton.edu/43mst/mediumEWG.txt + * https://algs4.cs.princeton.edu/43mst/largeEWG.txt + * + * An edge-weighted undirected graph, implemented using adjacency lists. + * Parallel edges and self-loops are permitted. + * + * % python edge_weighted_graph.py tinyEWD.txt + * 8 vertices, 15 edges + * 0: 0->2 0.26000 0->4 0.38000 + * 1: 1->3 0.29000 + * 2: 2->7 0.34000 + * 3: 3->6 0.52000 + * 4: 4->7 0.37000 4->5 0.35000 + * 5: 5->1 0.32000 5->7 0.28000 5->4 0.35000 + * 6: 6->4 0.93000 6->0 0.58000 6->2 0.40000 + * 7: 7->3 0.39000 7->5 0.28000 + * +""" +from algs4.bag import Bag +from algs4.directed_edge import DirectedEdge + + +class EdgeWeightedDigraph: + def __init__(self, v=0, **kwargs): + self.V = v + self.E = 0 + self.adj = {} + for v in range(self.V): + self.adj[v] = Bag() + + if 'file' in kwargs: + # init a digraph by a file input + in_file = kwargs['file'] + self.V = int(in_file.readline()) + for v in range(self.V): + self.adj[v] = Bag() + E = int(in_file.readline()) + for i in range(E): + v, w, weight = in_file.readline().split() + self.add_edge(DirectedEdge(int(v), int(w), float(weight))) + + def __str__(self): + s = "%d vertices, %d edges\n" % (self.V, self.E) + for i in range(self.V): + adjs = " ".join([str(x) for x in self.adj[i]]) + s += "%d: %s\n" % (i, adjs) + return s + + def add_edge(self, e): + self.adj[e.From()].add(e) + self.E += 1 + + def edges(self): + edges = [] + for v in range(self.V): + for e in self.adj[v]: + edges.append(e) + return edges + + +if __name__ == "__main__": + import sys + graph = EdgeWeightedDiraph(file=open(sys.argv[1])) + print(graph)