Merge pull request #3 from Subham1999/formatting_23aug2024

Formatting 23aug2024

Author: Subham1999

.idea/fileTemplates/internal/Class.java

@@ -28,4 +28,16 @@
             <version>3.1.8</version>
         </dependency>
     </dependencies>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>21</source>
+                    <target>21</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
 </project>

.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,37 @@
+package com.subham.ta.backtracking;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class CombinationSumI {
+  public List<List<Integer>> combinationSum(int[] candidates, int target) {
+    List<List<Integer>> result = new ArrayList<>();
+    List<Integer> runningSet = new ArrayList<>();
+    combinationSum(candidates, candidates.length - 1, target, result, runningSet);
+    return result;
+  }
+
+  void combinationSum(
+      int[] arr, int index, int target, List<List<Integer>> result, List<Integer> currentSet) {
+    if (index < 0 || target < 0) {
+      return;
+    }
+
+    if (target == 0) {
+      result.add(new ArrayList<>(currentSet));
+      return;
+    }
+
+    // include
+    currentSet.addLast(arr[index]);
+    combinationSum(arr, index, target - arr[index], result, currentSet);
+    currentSet.removeLast();
+
+    // exclude
+    combinationSum(arr, index - 1, target, result, currentSet);
+  }
+
+  public static void main(String[] args) {
+    System.out.println(new CombinationSumI().combinationSum(new int[] {2, 3, 6, 7}, 7));
+  }
+}

.idea/workspace.xml

@@ -0,0 +1,44 @@
+package com.subham.ta.backtracking;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * @author: Subham Santra
+ */
+public class PermutationI {
+
+  public List<List<Integer>> permute(int[] nums) {
+    List<List<Integer>> result = new ArrayList<>();
+    permute(nums, 0, result);
+    return result;
+  }
+
+  void permute(int[] arr, int i, List<List<Integer>> result) {
+    if (i == arr.length) {
+      result.add(Arrays.stream(arr).boxed().collect(Collectors.toList()));
+      return;
+    }
+
+    for (int j = i; j < arr.length; ++j) {
+      swap(arr, i, j);
+      permute(arr, i + 1, result);
+      swap(arr, i, j);
+    }
+  }
+
+  void swap(int[] arr, int f, int t) {
+    int x = arr[f];
+    arr[f] = arr[t];
+    arr[t] = x;
+  }
+
+  public static void main(String[] args) {
+    System.out.println(new PermutationI().permute(new int[] {0}));
+    System.out.println(new PermutationI().permute(new int[] {1}));
+    System.out.println(new PermutationI().permute(new int[] {1, 2}));
+    System.out.println(new PermutationI().permute(new int[] {1, 2, 3}));
+  }
+}

pom.xml

@@ -0,0 +1,33 @@
+package com.subham.ta.backtracking;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Subsets {
+  static class Solution {
+    public List<List<Integer>> subsets(int[] nums) {
+      int len = nums.length;
+      int powerLen = 1 << len;
+
+      List<List<Integer>> result = new ArrayList<>();
+      for (int i = 0; i < powerLen; ++i) {
+        int j = i;
+        int k = 0;
+        List<Integer> set = new ArrayList<>();
+        while (j > 0) {
+          if ((j & 1) == 1) {
+            set.add(nums[k]);
+          }
+          ++k;
+          j >>= 1;
+        }
+        result.add(set);
+      }
+      return result;
+    }
+  }
+
+  public static void main(String[] args) {
+    System.out.println(new Solution().subsets(new int[] {1, 2}));
+  }
+}

src/main/java/com/subham/ta/backtracking/CombinationSumI.java

@@ -0,0 +1,75 @@
+package com.subham.ta.graph;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public final class ArticulationPointOnDirectedGraph {
+  public static <K, V> Set<Vertex<K, V>> findArticulationPoint(final Graph<K, V> graph) {
+    final Map<Vertex<K, V>, Integer> highTime = new HashMap<>();
+    final Map<Vertex<K, V>, Integer> lowTime = new HashMap<>();
+    final Set<Vertex<K, V>> articulationPoints = new HashSet<>();
+    final Set<Vertex<K, V>> visitedSet = new HashSet<>();
+    final AtomicInteger timer = new AtomicInteger(0);
+
+    Vertex<K, V> root = graph.getVertexSet().iterator().next();
+    DFS(timer, graph, root, null, highTime, lowTime, articulationPoints, visitedSet);
+
+    return articulationPoints;
+  }
+
+  private static <K, V> void DFS(
+      final AtomicInteger timer,
+      final Graph<K, V> graph,
+      final Vertex<K, V> currentVertex,
+      final Vertex<K, V> parent,
+      final Map<Vertex<K, V>, Integer> highTime,
+      final Map<Vertex<K, V>, Integer> lowTime,
+      final Set<Vertex<K, V>> articulationPoints,
+      final Set<Vertex<K, V>> visitedSet) {
+
+    if (visitedSet.contains(currentVertex)) {
+      return;
+    }
+
+    visitedSet.add(currentVertex);
+    int currentTime = timer.incrementAndGet();
+
+    highTime.put(currentVertex, currentTime);
+    lowTime.put(currentVertex, currentTime);
+
+    for (final Vertex<K, V> children : currentVertex.getNeighbors()) {
+      if (children.equals(parent)) {
+        continue;
+      }
+      DFS(timer, graph, children, currentVertex, highTime, lowTime, articulationPoints, visitedSet);
+    }
+
+    // calculate low time for current vertex.
+    for (final Vertex<K, V> children : currentVertex.getNeighbors()) {
+      if (children.equals(parent)) {
+        continue;
+      }
+      lowTime.put(
+          currentVertex,
+          Math.min(lowTime.getOrDefault(children, Integer.MAX_VALUE), lowTime.get(currentVertex)));
+    }
+  }
+
+  public static void main(String[] args) {
+    Graph<Character, Character> graph = new Graph<>(false);
+    graph.addEdge(Edge.createSimpleEdgeUnWeighted('A', 'B'));
+    graph.addEdge(Edge.createSimpleEdgeUnWeighted('A', 'C'));
+    graph.addEdge(Edge.createSimpleEdgeUnWeighted('C', 'B'));
+    graph.addEdge(Edge.createSimpleEdgeUnWeighted('C', 'D'));
+    graph.addEdge(Edge.createSimpleEdgeUnWeighted('E', 'D'));
+    graph.addEdge(Edge.createSimpleEdgeUnWeighted('E', 'G'));
+    graph.addEdge(Edge.createSimpleEdgeUnWeighted('E', 'F'));
+    graph.addEdge(Edge.createSimpleEdgeUnWeighted('G', 'F'));
+    graph.addEdge(Edge.createSimpleEdgeUnWeighted('H', 'F'));
+
+    System.out.println(findArticulationPoint(graph));
+  }
+}

src/main/java/com/subham/ta/backtracking/PermutationI.java

@@ -0,0 +1,74 @@
+package com.subham.ta.graph;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class CoursesII {
+  static class Solution {
+    private boolean cycleExists = false;
+    private List<Integer> orderedList;
+
+    public int[] findOrder(int numCourses, int[][] prerequisites) {
+      orderedList = new ArrayList<>();
+      Map<Integer, List<Integer>> graph = new HashMap<>();
+      for (int i = 0; i < numCourses; ++i) {
+        graph.putIfAbsent(i, new ArrayList<>());
+      }
+
+      for (int[] edge : prerequisites) {
+        graph.get(edge[1]).add(edge[0]);
+      }
+
+      // System.out.println(graph);
+      int[] visited = new int[numCourses];
+
+      for (Map.Entry<Integer, List<Integer>> e : graph.entrySet()) {
+        if (visited[e.getKey()] == 0) {
+          dfs(graph, numCourses, e.getKey(), visited);
+        }
+      }
+
+      int[] res = new int[orderedList.size()];
+
+      System.out.println(orderedList);
+
+      for (int i = orderedList.size() - 1, j = 0; (i >= 0); --i, ++j) {
+        res[j] = orderedList.get(i);
+      }
+
+      return cycleExists ? new int[] {} : res;
+    }
+
+    void dfs(Map<Integer, List<Integer>> graph, int courseLen, int node, int[] visited) {
+      if (cycleExists) {
+        return;
+      }
+
+      if (!(0 <= node && node < courseLen) || visited[node] == 2) {
+        return;
+      }
+
+      if (visited[node] == 1) {
+        cycleExists = true;
+        return;
+      }
+
+      visited[node] = 1;
+
+      for (int next : graph.get(node)) {
+        dfs(graph, courseLen, next, visited);
+      }
+
+      visited[node] = 2;
+      orderedList.add(node);
+    }
+  }
+
+  public static void main(String[] args) {
+    System.out.println(
+        Arrays.toString(new Solution().findOrder(4, new int[][] {{1, 0}, {2, 0}, {3, 1}, {3, 2}})));
+  }
+}

src/main/java/com/subham/ta/backtracking/Subsets.java

@@ -1,27 +1,32 @@
 package com.subham.ta.graph;
 
 import java.util.Objects;
+import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 
-@AllArgsConstructor
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
 @Getter
 public class Edge<K, V> {
-  private Vertex<K, V> start;
-  private Vertex<K, V> end;
+  private Vertex<K, V> vertex1;
+  private Vertex<K, V> vertex2;
   private double weight = 1D;
 
+  public static <V> Edge<V, V> createSimpleEdgeUnWeighted(V v1, V v2) {
+    return new Edge<>(Vertex.create(v1), Vertex.create(v2), 0D);
+  }
+
   @Override
   public boolean equals(Object o) {
     if (this == o) return true;
     if (!(o instanceof Edge<?, ?> edge)) return false;
     return Double.compare(getWeight(), edge.getWeight()) == 0
-        && Objects.equals(getStart(), edge.getStart())
-        && Objects.equals(getEnd(), edge.getEnd());
+        && Objects.equals(getVertex1(), edge.getVertex1())
+        && Objects.equals(getVertex2(), edge.getVertex2());
   }
 
   @Override
   public int hashCode() {
-    return Objects.hash(getStart(), getEnd(), getWeight());
+    return Objects.hash(getVertex1(), getVertex2(), getWeight());
   }
 }

src/main/java/com/subham/ta/graph/ArticulationPointOnDirectedGraph.java

@@ -0,0 +1,35 @@
+package com.subham.ta.graph;
+
+import java.util.HashSet;
+import java.util.Set;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@AllArgsConstructor
+@Getter
+public class Graph<K, V> {
+  private Set<Vertex<K, V>> vertexSet;
+  private Set<Edge<K, V>> edgeSet;
+  private boolean isDirected;
+
+  public Graph(boolean isDirected) {
+    this.isDirected = isDirected;
+    this.vertexSet = new HashSet<>();
+    this.edgeSet = new HashSet<>();
+  }
+
+  public void addEdge(Edge<K, V> edge) {
+    if (!edgeSet.contains(edge)) {
+      vertexSet.add(edge.getVertex1());
+      vertexSet.add(edge.getVertex2());
+      edgeSet.add(edge);
+
+      edge.getVertex1().getEdges().add(edge);
+      edge.getVertex1().getNeighbors().add(edge.getVertex2());
+      if (!this.isDirected()) {
+        edge.getVertex2().getEdges().add(edge);
+        edge.getVertex2().getNeighbors().add(edge.getVertex1());
+      }
+    }
+  }
+}