diagraph, toplogical sorting

Author: dhananjay-ng

Diff for: src/main/java/datastructures/graph/DepthFirstPaths.java

@@ -18,6 +18,13 @@ public DepthFirstPaths(Graph G, int s) {
         dfs(G, s);
     }
 
+    public DepthFirstPaths(Graph G) {
+        this.s = s;
+        marked = new boolean[G.V()];
+        edgeTo = new int[G.V()];
+        Arrays.fill(edgeTo, -1);
+    }
+
     public void dfs(Graph g, int v) {
         marked[v] = true;
         for (int i : g.adj(v)) {

Diff for: src/main/java/datastructures/graph/Digraph.java

@@ -0,0 +1,53 @@
+package datastructures.graph;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Digraph implements Graph {
+    int vertices;
+    int edges;
+    List<Integer>[] adj;
+
+    public Digraph(int vertices) {
+        this.vertices = vertices;
+        this.edges = 0;
+        adj = new ArrayList[vertices];
+        for (int i = 0; i < vertices; i++)
+            adj[i] = new ArrayList<>();
+
+    }
+
+    @Override
+    public void addEdge(int from, int to) {
+        this.edges++;
+        this.adj[from].add(to);
+    }
+
+    @Override
+    public Iterable<Integer> adj(int vertex) {
+        return this.adj[vertex];
+    }
+
+    @Override
+    public int V() {
+        return this.vertices;
+    }
+
+    @Override
+    public int E() {
+        return this.edges;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder stringBuilder = new StringBuilder();
+
+        stringBuilder.append("-------Graph-------\n");
+
+        for (int i = 0; i < this.vertices; i++) {
+            stringBuilder.append(i).append(adj[i].toString()).append("\n");
+        }
+
+        return stringBuilder.toString();
+    }
+}

Diff for: src/main/java/datastructures/graph/TestUndirectedGraph.java

@@ -48,22 +48,43 @@ public static void main(String[] args) {
         graph2.addEdge(11, 12);
 
 
+        graph = new Digraph(5);
 
+        graph.addEdge(0, 1);
+        graph.addEdge(1, 2);
+        graph.addEdge(2, 3);
+        graph.addEdge(2, 4);
 
+        // graph.adj(1).forEach(integer -> System.out.println(integer));
+        System.out.println(graph.toString());
 
+        depthFirstPaths = new DepthFirstPaths(graph, 0);
+        System.out.println(depthFirstPaths.hasPathTo(4));
 
-        ConnectedComponent  connectedComponent = new ConnectedComponent(graph2);
+        System.out.println();
+        System.out.println("DFS");
+        for (int path : depthFirstPaths.pathTo(4)) {
+            System.out.print(path + "->");
+        }
 
+        breadthFirstPaths = new BreadthFirstPaths(graph, 0);
         System.out.println();
+        System.out.println("BFS");
+        for (int path : breadthFirstPaths.pathTo(4)) {
+            System.out.print(path + "->");
+        }
 
-        System.out.println("Number of Connected Components : "+ connectedComponent.count());
-        System.out.println("Connected 0 & 6 : "+ connectedComponent.connected(0, 6));
-        System.out.println("Connected 0 & 8 : "+ connectedComponent.connected(0, 8));
-        System.out.println("Component of 4 : "+ connectedComponent.id(4));
-        System.out.println("Component of 7 : "+ connectedComponent.id(7));
-        System.out.println("Component of 12 : "+ connectedComponent.id(12));
 
+        ConnectedComponent connectedComponent = new ConnectedComponent(graph2);
+
+        System.out.println();
 
+        System.out.println("Number of Connected Components : " + connectedComponent.count());
+        System.out.println("Connected 0 & 6 : " + connectedComponent.connected(0, 6));
+        System.out.println("Connected 0 & 8 : " + connectedComponent.connected(0, 8));
+        System.out.println("Component of 4 : " + connectedComponent.id(4));
+        System.out.println("Component of 7 : " + connectedComponent.id(7));
+        System.out.println("Component of 12 : " + connectedComponent.id(12));
 
 
     }

Diff for: src/main/java/problems/onRecursionAndDp/PhoneKeypad.java

@@ -7,8 +7,8 @@ public class PhoneKeypad {
     private String[] MAPPINGS = {"0", "1", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
 
 
-    public List<String> letterCombinations(String digits) {
-        List<String> res = new ArrayList<>();
+    public ArrayList<String> letterCombinations(String digits) {
+        ArrayList<String> res = new ArrayList<>();
         if (digits == null || digits.length() == 0) return res;
         StringBuilder builder = new StringBuilder();
         find(res, 0, builder, digits);

Diff for: src/main/java/problems/ongraph/FIndJudge.java

@@ -0,0 +1,78 @@
+package problems.ongraph;
+
+public class FIndJudge {
+    /**
+     * 997. Find the Town Judge
+     * Easy
+     *
+     * 290
+     *
+     * 41
+     *
+     * Favorite
+     *
+     * Share
+     * In a town, there are N people labelled from 1 to N.  There is a rumor that one of these people is secretly the town judge.
+     *
+     * If the town judge exists, then:
+     *
+     * The town judge trusts nobody.
+     * Everybody (except for the town judge) trusts the town judge.
+     * There is exactly one person that satisfies properties 1 and 2.
+     * You are given trust, an array of pairs trust[i] = [a, b] representing that the person labelled a trusts the person labelled b.
+     *
+     * If the town judge exists and can be identified, return the label of the town judge.  Otherwise, return -1.
+     *
+     *
+     *
+     * Example 1:
+     *
+     * Input: N = 2, trust = [[1,2]]
+     * Output: 2
+     * Example 2:
+     *
+     * Input: N = 3, trust = [[1,3],[2,3]]
+     * Output: 3
+     * Example 3:
+     *
+     * Input: N = 3, trust = [[1,3],[2,3],[3,1]]
+     * Output: -1
+     * Example 4:
+     *
+     * Input: N = 3, trust = [[1,2],[2,3]]
+     * Output: -1
+     * Example 5:
+     *
+     * Input: N = 4, trust = [[1,3],[1,4],[2,3],[2,4],[4,3]]
+     * Output: 3
+     *
+     *
+     * Note:
+     *
+     * 1 <= N <= 1000
+     * trust.length <= 10000
+     * trust[i] are all different
+     * trust[i][0] != trust[i][1]
+     * 1 <= trust[i][0], trust[i][1] <= N
+     * @param N
+     * @param trust
+     * @return
+     */
+    public int findJudge(int N, int[][] trust) {
+        int[] in = new int[N + 1];
+        int[] out = new int[N + 1];
+        for (int i = 0; i < trust.length; i++) {
+            out[trust[i][0]]++;
+            in[trust[i][1]]++;
+        }
+
+        for (int i = 1; i <= N; i++) {
+            if (out[i] == 0 && in[i] == N - 1) return i;
+        }
+
+        return -1;
+    }
+
+    //concept of indegree and outdegree is used
+    //judge will satisfy, out[i] == 0 && in[i] == N - 1
+}

Diff for: src/main/java/problems/ongraph/TopologicalSorting.java

@@ -0,0 +1,53 @@
+package problems.ongraph;
+
+import datastructures.graph.DepthFirstPaths;
+import datastructures.graph.Digraph;
+import datastructures.graph.Graph;
+
+import java.util.Arrays;
+import java.util.Stack;
+
+public class TopologicalSorting {
+    boolean[] marked;
+    int s;
+    Stack<Integer> topoOrder;
+
+    public TopologicalSorting(Graph G, int s) {
+        this.s = s;
+        marked = new boolean[G.V()];
+        topoOrder = new Stack<>();
+        dfs(G, s);
+    }
+
+
+    public void dfs(Graph g, int v) {
+        marked[v] = true;
+        for (int i : g.adj(v)) {
+            if (!marked[i]) {
+                dfs(g, i);
+            }
+        }
+        topoOrder.push(v);
+    }
+
+    public static void main(String[] args) {
+        Graph graph = new Digraph(5);
+
+        /**
+         *   4<--0-->1-->2
+         *   |
+         *   3-->2
+         *
+         */
+
+        graph.addEdge(0, 1);
+        graph.addEdge(1, 2);
+        graph.addEdge(1, 3);
+        graph.addEdge(3, 2);
+        graph.addEdge(4, 3);
+        graph.addEdge(0, 4);
+
+        TopologicalSorting topologicalSorting = new TopologicalSorting(graph, 0);
+        topologicalSorting.topoOrder.forEach(integer -> System.out.println(integer));
+    }
+}