Merge branch 'main' into main

xDido · web-flow · commit 1de3b311cc30 · 2023-07-31T20:13:53.000+03:00
diff --git a/README.md b/README.md
diff --git a/java/0139-word-break.java b/java/0139-word-break.java
@@ -3,11 +3,6 @@ class Solution {
     public boolean wordBreak(String s, List<String> wordDict) {
         boolean[] dp = new boolean[s.length() + 1];
 
-
-        for (int i = 0; i < dp.length; i++) {
-            dp[i] = false;
-        }
-
         dp[s.length()] = true;
 
         for (int i = s.length() - 1; i >= 0; i--) {
diff --git a/java/0698-partition-to-k-equal-sum-subsets.java b/java/0698-partition-to-k-equal-sum-subsets.java
@@ -0,0 +1,37 @@
+class Solution {
+    int target;
+  
+    public boolean canPartitionKSubsets(int[] nums, int k) {
+        int sum = 0;
+        for(int n : nums){
+            sum += n;
+        }
+        if(sum%k != 0)
+            return false;
+        
+        target = sum / k;
+        boolean[] used = new boolean[nums.length];
+        return backtrack(nums, 0, k, 0, used);
+    }
+
+    private boolean backtrack(int[] nums, int i, int k, int subsetSum, boolean[] used){
+        if(k == 0)
+            return true;
+        if(subsetSum == target)
+            return backtrack(nums, 0, k-1, 0, used);
+
+        for(int j = i; j < nums.length; j++){
+            if(j > 0 && !used[j-1] && nums[j] == nums[j-1])
+                continue;
+            if(used[j] || subsetSum + nums[j] > target)
+                continue;
+            
+            used[j] = true;
+            if(backtrack(nums, j+1, k, subsetSum + nums[j], used))
+                return true;
+
+            used[j] = false;        
+        }
+        return false;        
+    }
+}
diff --git a/java/0701-insert-into-a-binary-search-tree.java b/java/0701-insert-into-a-binary-search-tree.java
@@ -0,0 +1,37 @@
+class Solution {
+    public TreeNode insertIntoBST(TreeNode root, int val) {
+        if(root == null) return new TreeNode(val);
+        TreeNode curr = root;
+        while(true){
+            if(curr.val <= val){
+                if(curr.right != null){
+                    curr = curr.right;
+                }else{
+                    curr.right = new TreeNode(val);
+                    break;
+                }
+            }else{
+                if(curr.left != null) curr = curr.left;
+                else{
+                    curr.left = new TreeNode(val);
+                    break;
+                }
+            }
+        }
+        return root;
+    }
+
+  /*          Using Recursive Solution
+  -------------------------------------------------------------------
+     public TreeNode insertIntoBST(TreeNode root, int val) {
+        if(root == null) return new TreeNode(val);
+        if(root.val <= val){
+            root.right = insertIntoBST(root.right, val); 
+        }else{
+            root.left = insertIntoBST(root.left, val);
+        }
+        return root;
+    }
+  -------------------------------------------------------------------
+  */  
+}
diff --git a/java/0705-design-hashset.java b/java/0705-design-hashset.java
@@ -0,0 +1,57 @@
+class MyHashSet {
+    final int mod = 10000;
+    ListNode[] set;
+
+    class ListNode {
+        int val;
+        ListNode next;
+        private ListNode(int val) {
+            this.val = val;
+            this.next = null;
+        }
+    }
+
+    public MyHashSet() {
+        this.set = new ListNode[mod];
+        for (int i = 0; i < set.length; i++) {
+            set[i] = new ListNode(0);
+        }
+    }
+    
+    public void add(int key) {
+        ListNode head = set[key % mod];
+        while (head.next != null) {
+            if (head.next.val == key) return;
+            head = head.next;
+        }
+        head.next = new ListNode(key);
+    }
+    
+    public void remove(int key) {
+        ListNode head = set[key % mod];
+        while (head.next != null) {
+            if (head.next.val == key) {
+                head.next = head.next.next;
+                return;
+            }
+            head = head.next;
+        }
+    }
+    
+    public boolean contains(int key) {
+        ListNode head = set[key % mod];
+        while (head.next != null) {
+            if (head.next.val == key) return true;
+            head = head.next;
+        }
+        return false;
+    }
+}
+
+/**
+ * Your MyHashSet object will be instantiated and called as such:
+ * MyHashSet obj = new MyHashSet();
+ * obj.add(key);
+ * obj.remove(key);
+ * boolean param_3 = obj.contains(key);
+ */
diff --git a/java/0721-accounts-merge.java b/java/0721-accounts-merge.java
@@ -0,0 +1,75 @@
+class Solution {
+    public List<List<String>> accountsMerge(List<List<String>> accounts) {
+        int n = accounts.size();
+        DSU dsu = new DSU(n);
+
+        Map<String, Integer> map = new HashMap<>();  // email -> index of acc
+
+        for(int i = 0; i < n; i++){
+            for(int j = 1; j < accounts.get(i).size(); j++){
+                String email = accounts.get(i).get(j);
+                String name = accounts.get(i).get(0);
+
+                if(!map.containsKey(email))
+                    map.put(email, i);
+                else
+                    dsu.union(i, map.get(email)); 
+            }
+        }
+
+        Map<Integer, List<String>> merged = new HashMap<>();  // index of acc -> list of emails
+        for(String email : map.keySet()){
+            int group = map.get(email);
+            int lead = dsu.find(group);
+            
+            if(!merged.containsKey(lead))
+                merged.put(lead, new ArrayList<String>());
+
+            merged.get(lead).add(email);    
+        }
+
+        List<List<String>> res = new ArrayList<>();  
+        for(int ac : merged.keySet()){
+            List<String> grp = merged.get(ac);
+            Collections.sort(grp);
+            grp.add(0, accounts.get(ac).get(0));
+            res.add(grp);
+        }
+        return res;
+    }
+}
+
+class DSU {
+    int[] parent;
+    int[] rank;
+
+    public DSU(int size) {
+        rank = new int[size];
+        parent = new int[size];
+        for (int i = 0; i < size; i++)
+            parent[i] = i;
+    }
+
+    public int find(int x) {
+        if (parent[x] != x)
+            parent[x] = find(parent[x]);
+        return parent[x];
+    }
+
+    // Union By Rank
+
+    public boolean union(int x, int y) {
+        int xr = find(x), yr = find(y);
+        if (xr == yr) {
+            return false;
+        } else if (rank[xr] < rank[yr]) {
+            parent[xr] = yr;
+        } else if (rank[xr] > rank[yr]) {
+            parent[yr] = xr;
+        } else {
+            parent[yr] = xr;
+            rank[xr]++;
+        }
+        return true;
+    }
+}
diff --git a/java/0746-min-cost-climbing-stairs.java b/java/0746-min-cost-climbing-stairs.java
@@ -1,17 +1,14 @@
 class Solution {
-
     public int minCostClimbingStairs(int[] cost) {
-        int[] res = new int[cost.length + 1];
-        res[cost.length] = 0;
-        res[cost.length - 1] = cost[cost.length - 1];
+        int one = 0;
+        int two = 0;
 
-        for (int i = cost.length - 2; i >= 0; i--) {
-            res[i] =
-                (res[i + 1] < res[i + 2])
-                    ? res[i + 1] + cost[i]
-                    : res[i + 2] + cost[i];
+        for (int i = cost.length - 1; i >= 0; i--) {
+            cost[i] += Math.min(one, two);
+            two = one;
+            one = cost[i];
         }
 
-        return Math.min(res[0], res[1]);
+        return Math.min(cost[0], cost[1]);
     }
 }
diff --git a/java/0785-is-graph-bipartite.java b/java/0785-is-graph-bipartite.java
@@ -0,0 +1,29 @@
+class Solution {
+    public boolean isBipartite(int[][] graph) {
+        int[] color = new int[graph.length]; // 1 for one color , -1 for second color and 0 for not visited.
+
+        for(int i = 0; i < graph.length; i++){
+            if(color[i] != 0){
+                continue;
+            }
+
+            Queue<Integer> q = new LinkedList<>();
+            q.add(i);
+            color[i] = 1;
+
+            while(!q.isEmpty()){
+                int curr = q.poll();
+
+                for(int n : graph[curr]){
+                    if(color[n] == 0){
+                        color[n] = -1 * color[curr];
+                        q.add(n);
+                    }
+                    if(color[n] == color[curr])
+                        return false;
+                }
+            }
+        }
+        return true;
+    }
+}
diff --git a/java/0802-find-eventual-safe-states.java b/java/0802-find-eventual-safe-states.java
@@ -0,0 +1,25 @@
+class Solution {
+    public List<Integer> eventualSafeNodes(int[][] graph) {
+        List<Integer> res = new ArrayList<>();
+        HashMap<Integer, Boolean> safe = new HashMap<>();
+        for(int i = 0; i < graph.length; i++){
+            if(dfs(graph, i, safe))
+                res.add(i);
+        }
+        return res;
+    }
+
+    private boolean dfs(int[][] graph, int src, HashMap<Integer, Boolean> safe) {
+        if (safe.containsKey(src))
+            return safe.get(src);
+
+        safe.put(src, false);
+
+        for (int neighbour : graph[src]) {
+            if (!dfs(graph, neighbour, safe))
+                    return false;
+        }
+        safe.put(src, true);
+        return true;
+    }    
+}
diff --git a/java/1020-number-of-enclaves.java b/java/1020-number-of-enclaves.java
@@ -0,0 +1,46 @@
+/*
+The basic idea is to iterate through the boundary
+If we encounter any island i.e. 1 then we will run DFS
+And update all those islands as 2
+
+Then check for the number of 1s remaining in the board 
+Since those are the ones that have not been visited and return
+*/
+
+class Solution {
+    public int count(int [][]board){
+        int c = 0;
+        for(int i=0; i<board.length; i++){
+            for(int j=0; j<board[0].length; j++){
+                if(board[i][j] == 1){
+                    c++;
+                }
+            }
+        }
+        return c;
+    }
+    public void dfs(int r, int c, int[][] board){
+        if(r<0 || c<0 || r>board.length-1 || c>board[0].length-1 || board[r][c] != 1) return;
+
+        board[r][c] = 2;
+
+        dfs(r+1, c, board);
+        dfs(r-1, c, board);
+        dfs(r, c+1, board);
+        dfs(r, c-1, board);
+    }
+    public int numEnclaves(int[][] board) {
+        int n=board.length, m=board[0].length;
+
+        for(int i=0; i<n; i++){
+            if(board[i][0] == 1) dfs(i, 0, board);
+            if(board[i][m-1] == 1) dfs(i, m-1, board);
+        }
+
+        for(int i=1; i<m-1; i++){
+            if(board[0][i] == 1) dfs(0, i, board);
+            if(board[n-1][i] == 1) dfs(n-1, i, board);
+        }
+        return count(board);
+    }
+}
diff --git a/java/1557-minimum-number-of-vertices-to-reach-all-nodes.java b/java/1557-minimum-number-of-vertices-to-reach-all-nodes.java
@@ -0,0 +1,15 @@
+class Solution {
+    public List<Integer> findSmallestSetOfVertices(int n, List<List<Integer>> edges) {
+        int[] incoming = new int[n];
+        for(List<Integer> ls: edges){
+            int in = ls.get(1);
+            incoming[in]++; 
+        }
+        List<Integer> res = new ArrayList<>();
+        for(int i=0; i<n; i++){
+            if(incoming[i] == 0)
+                res.add(i);
+        }
+        return res;
+    }
+}
diff --git a/java/1822-sign-of-the-product-of-an-array.java b/java/1822-sign-of-the-product-of-an-array.java
@@ -0,0 +1,10 @@
+class Solution {
+    public int arraySign(int[] nums) {
+        int sign = 1;
+        for (int i : nums) {
+            if (i == 0) return 0;
+            if (i < 0) sign *= -1;
+        }
+        return sign;
+    }
+}
diff --git a/java/2477-minimum-fuel-cost-to-report-to-the-capital.java b/java/2477-minimum-fuel-cost-to-report-to-the-capital.java
diff --git a/python/1011-capacity-to-ship-packages-within-d-days.py b/python/1011-capacity-to-ship-packages-within-d-days.py
diff --git a/python/2300-successful-pairs-of-spells-and-potions.py b/python/2300-successful-pairs-of-spells-and-potions.py
