add comments, add DAG shortest path

Author: tamasbrandstadter

HolczerUdemyCourses/src/graphs/shortestpath/Dijkstra.java

@@ -5,8 +5,13 @@
 import java.util.List;
 import java.util.PriorityQueue;
 
+/* - handles positive edge weights
+ * - greedy algorithm
+ * - applications: GPS, navigation, routing information protocol
+ */
 public class Dijkstra {
 
+ // running time complexity: O(V log V + E)
  public void computePaths(Vertex source) {
  source.setDistance(0);
  PriorityQueue<Vertex> queue = new PriorityQueue<>();

HolczerUdemyCourses/src/graphs/shortestpath/dag/AcyclicShortestPath.java

@@ -0,0 +1,56 @@
+package graphs.shortestpath.dag;
+
+import graphs.shortestpath.Edge;
+import graphs.shortestpath.Vertex;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Stack;
+
+/* - compute the topological order of a DAG, then iterate through it and relax all edges from the actual vertex
+ * - handles negative edge weights
+ * - application: solving Knapsack-problem, seam carving (Avidan-Shamir method)
+ */
+public class AcyclicShortestPath {
+
+ // running time complexity: O(V + E)
+ public void computePaths(List<Vertex> graph, Vertex source, Vertex target) {
+ source.setDistance(0);
+
+ TopologicalSort topologicalSort = new TopologicalSort();
+ topologicalSort.sort(graph);
+ Stack<Vertex> stack = topologicalSort.getTopologicalOrder();
+
+ for (Vertex vertex : stack) {
+ for (Edge edge : vertex.getAdjacencies()) {
+ Vertex u = edge.getU();
+ Vertex v = edge.getV();
+ double tempDistance = u.getDistance() + edge.getWeight();
+ if (tempDistance < v.getDistance()) {
+ v.setDistance(tempDistance);
+ v.setPredecessor(u);
+ }
+ }
+ }
+
+ if (target.getDistance() == Double.MAX_VALUE) {
+ System.out.println("There is no shortest path.");
+ } else {
+ System.out.println("Target vertex shortest path: " + target.getDistance());
+ }
+ }
+
+ public List<Vertex> getShortestPath(Vertex target) {
+ List<Vertex> shortestPath = new ArrayList<>();
+ Vertex v = target;
+ while (v != null) {
+ shortestPath.add(v);
+ v = v.getPredecessor();
+ }
+
+ Collections.reverse(shortestPath);
+ return shortestPath;
+ }
+
+}

HolczerUdemyCourses/src/graphs/shortestpath/dag/TopologicalSort.java

@@ -0,0 +1,43 @@
+package graphs.shortestpath.dag;
+
+import graphs.shortestpath.Edge;
+import graphs.shortestpath.Vertex;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Stack;
+
+public class TopologicalSort {
+ private Stack<Vertex> stack;
+
+ public TopologicalSort() {
+ this.stack = new Stack<>();
+ }
+
+ public void sort(List<Vertex> graph) {
+ for (Vertex vertex : graph) {
+ if (!vertex.isVisited()) {
+ dfs(vertex);
+ }
+ }
+ }
+
+ private void dfs(Vertex vertex) {
+ vertex.setVisited(true);
+
+ for (Edge edge : vertex.getAdjacencies()) {
+ if (!edge.getV().isVisited()) {
+ edge.getV().setVisited(true);
+ dfs(edge.getV());
+ }
+ }
+
+ stack.push(vertex);
+ }
+
+ public Stack<Vertex> getTopologicalOrder() {
+ Collections.reverse(stack);
+ return stack;
+ }
+
+}

HolczerUdemyCourses/src/graphs/shortestpath/BellmanFord.java renamed to HolczerUdemyCourses/src/graphs/shortestpath/negativeedge/BellmanFord.java

@@ -1,7 +1,15 @@
-package graphs.shortestpath;
+package graphs.shortestpath.negativeedge;
+
+import graphs.shortestpath.Edge;
+import graphs.shortestpath.Vertex;
 
 import java.util.List;
 
+/* - handles negative edge weights
+ * - relaxes all edges at the same time for V - 1 iteration
+ * - +1 iteration for detecting cycles, if the cost increases in the Vth iteration -> negative cycle
+ * - applications: arbitrage situation on FOREX, longest path problem, paralell job scheduling problem, critical path method
+ */
 public class BellmanFord {
  private List<Edge> edges;
  private List<Vertex> vertices;
@@ -11,6 +19,7 @@ public BellmanFord(List<Edge> edges, List<Vertex> vertices) {
  this.vertices = vertices;
  }
 
+ // running time complexity: O(V * E)
  public void computePaths(Vertex source) {
  source.setDistance(0);
  for (int i = 0; i < vertices.size() - 1; i++) {
@@ -28,6 +37,7 @@ public void computePaths(Vertex source) {
  }
  }
 
+ // cycle detection
  for (Edge edge : edges) {
  if (edge.getU().getDistance() != Double.MAX_VALUE) {
  if (hasCycle(edge)) {