Merge branch 'neetcode-gh:main' into main

Author: unw9527

Diff for: README.md

@@ -0,0 +1,27 @@
+class Solution {
+private:
+    void backtrack(int start, int n, int k, vector<int> &combination, vector<vector<int>> &res){
+            //base case, when size of combination is k, we wanna stop
+            if(combination.size() == k){
+                res.push_back(combination);
+                return;
+            }
+
+            for(int i = start; i<=n; i++){
+                combination.push_back(i);
+                backtrack(i+1, n, k, combination, res);
+                combination.pop_back();
+            }
+        }
+public:
+    vector<vector<int>> combine(int n, int k) {
+        vector<vector<int>> res;
+
+        //initial empty list to pass to the backtrack function
+        vector<int> emptyCombination;
+
+        backtrack(1, n, k, emptyCombination, res);
+
+        return res;
+    }
+};

Diff for: cpp/0077-combinations.cpp

@@ -25,3 +25,20 @@ class Solution {
         return result;
     }
 };
+
+
+/* use kernighan's algorithm to only iterate num(set bits) times */
+class Solution {
+public:
+    int hammingWeight(uint32_t n) {
+        unsigned int count = 0;
+
+        while(n) {
+            ++count;
+            // unset rightmost set bit
+            n = (n & (n - 1));
+        }
+        
+        return count;
+    }
+};

Diff for: cpp/0191-number-of-1-bits.cpp

@@ -1,3 +1,40 @@
+/**
+  This function uses the Bellman-Ford algorithm to find the cheapest price from source (src) to destination (dst)
+  with at most k stops allowed. It iteratively relaxes the edges for k+1 iterations, updating the minimum
+  cost to reach each vertex. The final result is the minimum cost to reach the destination, or -1 if the
+  destination is not reachable within the given constraints.
+  
+  Space Complexity: O(n) - space used for the prices array.
+  Time Complexity: O(k * |flights|) - k iterations, processing all flights in each iteration.
+ */
+class Solution {
+public:
+    int findCheapestPrice(int n, vector<vector<int>>& flights, int src, int dst, int k) {
+        vector<int> prices(n, INT_MAX);
+        prices[src] = 0;
+
+        // Perform k+1 iterations of Bellman-Ford algorithm.
+        for (int i = 0; i < k + 1; i++) {
+            vector<int> tmpPrices(begin(prices), end(prices));
+
+            for (auto it : flights) {
+                int s = it[0];
+                int d = it[1];
+                int p = it[2];
+
+                if (prices[s] == INT_MAX) continue;
+
+                if (prices[s] + p < tmpPrices[d]) {
+                    tmpPrices[d] = prices[s] + p;
+                }
+            }
+            prices = tmpPrices;
+        }
+        return prices[dst] == INT_MAX ? -1 : prices[dst];
+    }
+};
+
+
 /*
     Given cities connected by flights [from,to,price], also given src, dst, & k:
     Return cheapest price from src to dst with at most k stops
@@ -75,4 +112,4 @@ class Solution {
         }
         return distances[dst];
     }
-};
+};

Diff for: cpp/0787-cheapest-flights-within-k-stops.cpp

@@ -0,0 +1,39 @@
+class Solution {
+public:
+    int shortestPathBinaryMatrix(vector<vector<int>>& grid) {
+        int n = grid.size();
+        if(grid[0][0]==1 || grid[n-1][n-1]==1) return -1;
+
+        // {{r,c},length}
+        queue<pair<pair<int,int>,int>> q;
+        set<pair<int,int>> visited;
+
+        q.push({{0,0},0});
+        visited.insert(make_pair(0,0));
+
+        int drow[] = {0,1,0,-1,1,-1,1,-1};
+        int dcol[] = {1,0,-1,0,1,-1,-1,1};
+
+        while(!q.empty()){
+            int row = q.front().first.first;
+            int col = q.front().first.second;
+            int len = q.front().second;
+
+            if(row == n-1 && col == n-1){
+                return len+1;
+            }
+
+            for(int i=0; i<8; i++){
+                int nrow = row + drow[i];
+                int ncol = col + dcol[i];
+
+                if(nrow>=0 && nrow<n && ncol>=0 && ncol<n && visited.find({nrow,ncol})==visited.end() && grid[nrow][ncol]==0){
+                    q.push({{nrow,ncol},len+1});
+                    visited.insert(make_pair(nrow,ncol));
+                }
+            }
+            q.pop(); 
+        }
+        return -1;
+    }
+};

Diff for: cpp/1091-shortest-path-in-binary-matrix.cpp

@@ -0,0 +1,51 @@
+/*
+    This class implements a solution to find a binary string that differs from a given list of binary strings.
+    
+    Approach:
+    1. Define a backtrack function to explore all possible binary strings of the same length as the input strings.
+    2. Use a set to store the input strings to efficiently check for duplicates.
+    3. Backtrack through all possible binary strings of length equal to the input strings.
+    4. If a binary string is found that does not exist in the set of input strings, update the result and return.
+    
+    Variables:
+    - result: Holds the result, initialized to an empty string.
+    - backtrack(): Recursive function to generate binary strings and check for uniqueness.
+    - inputStrings: Input vector of binary strings.
+    - currentString: Current binary string being constructed during backtracking.
+    - stringLength: Length of binary strings in the input.
+    - stringSet: Set to store input binary strings for fast duplicate checking.
+
+    Time Complexity: O(2^N * N), where N is the length of the binary strings.
+        - The function 'backtrack' explores all possible binary strings of length N, which is O(2^N).
+        - Checking for uniqueness in the set takes O(1) time on average.
+    Space Complexity: O(2^N * N) considering the space required to store the generated binary strings during backtracking.
+*/
+
+class Solution {
+public:
+    string result = "";
+    
+    void backtrack(vector<string>& inputStrings, string& currentString, int stringLength, set<string>& stringSet) {
+        if (!result.empty()) return;
+        if (currentString.size() == stringLength && stringSet.find(currentString) == stringSet.end()) {
+            result = currentString;
+            return;
+        }
+        if (currentString.size() > stringLength) return;
+
+        for (char ch = '0'; ch <= '1'; ++ch) {
+            currentString.push_back(ch);
+            backtrack(inputStrings, currentString, stringLength, stringSet);
+            currentString.pop_back();
+        }
+    }
+    
+    string findDifferentBinaryString(vector<string>& inputStrings) {
+        int stringLength = inputStrings[0].size();
+        string currentString = "";
+        set<string> stringSet(inputStrings.begin(), inputStrings.end());
+
+        backtrack(inputStrings, currentString, stringLength, stringSet);
+        return result;
+    }
+};

Diff for: cpp/1980-find-unique-binary-string.cpp

@@ -0,0 +1,22 @@
+public class Solution {
+    public int UniquePathsWithObstacles(int[][] obstacleGrid) {
+        var rowLength = obstacleGrid.Length;
+        var colLength = obstacleGrid[0].Length;
+
+        int[] row = new int[colLength];
+        Array.Fill(row, 0);
+        row[colLength - 1] = 1;
+
+        for(int i = rowLength - 1; i >= 0; i--)
+        {
+            for(int j = colLength - 1; j >= 0; j--)
+            {
+                if(obstacleGrid[i][j] == 1)
+                    row[j] = 0;
+                else if (j + 1 < colLength) 
+                    row[j] = row[j] + row[j + 1];
+            }
+        }
+        return row[0];
+    }
+}

Diff for: csharp/0063-unique-paths-ii.cs

@@ -0,0 +1,30 @@
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ *     Val int
+ *     Next *ListNode
+ * }
+ */
+func mergeInBetween(list1 *ListNode, a int, b int, list2 *ListNode) *ListNode {
+	curr := list1
+	i := 0
+	for i < a-1 {
+		curr = curr.Next
+		i++
+	}
+
+	head := curr
+	for i <= b {
+		curr = curr.Next
+		i++
+	}
+	head.Next = list2
+
+	for list2.Next != nil {
+		list2 = list2.Next
+	}
+
+	list2.Next = curr
+
+	return list1
+}

Diff for: go/1669-merge-in-between-linked-lists.go

@@ -1,3 +1,31 @@
+class Solution {
+    public List<List<String>> groupAnagrams(String[] strs) {
+        Map<String, List<String>> res = new HashMap<>();
+
+        for (String s : strs) {
+            int[] count = new int[26];
+
+            for (char c : s.toCharArray()) {
+                count[c - 'a']++;
+            }
+
+            StringBuilder sb = new StringBuilder();
+            for (int i = 0; i < 26; i++) {
+                sb.append('#');
+                sb.append(count[i]);
+            }
+            String key = sb.toString();
+            
+            if (!res.containsKey(key)) {
+                res.put(key, new ArrayList<>());
+            }
+            res.get(key).add(s);
+        }
+
+        return new ArrayList<>(res.values());
+    }
+}
+-------------------------------------------------------------------------
 class Solution {
     public List<List<String>> groupAnagrams(String[] strs) {
         Map<String, List<String>> map = new HashMap<>();

Diff for: java/0049-group-anagrams.java

@@ -0,0 +1,30 @@
+class Solution {
+    public int[][] generateMatrix(int n) {
+        int[][] ans = new int[n][n];
+
+        int r1=0, r2=n-1;
+        int c1=0, c2=n-1;
+        int elem = 1;
+        while(r2>=r1 && c2>=c1){
+            for(int i=c1; i<=c2; i++){
+                ans[r1][i] = elem++;
+            }
+            for(int j=r1+1; j<=r2-1; j++){
+                ans[j][c2] = elem++;
+            }
+            if(r2>r1 && c2>c1){
+                for (int i = c2; i >= c1; i--){
+                    ans[r2][i] = elem++;
+                }
+                for (int j = r2-1; j>=r1+1; j--){
+                    ans[j][c1] = elem++;
+                }
+            }
+            r1++;
+            r2--;
+            c1++;
+            c2--;
+        }
+        return ans;
+    }
+}

Diff for: java/0059-spiral-matrix-ii.java

@@ -0,0 +1,27 @@
+class Solution {
+    public List<TreeNode> generateTrees(int n) {
+        return generate(1, n);
+    }
+
+    private List<TreeNode> generate(int left, int right) {
+        if (left > right) {
+            List<TreeNode> r = new ArrayList<>();
+            r.add(null);
+            return r;
+        }
+
+        List<TreeNode> res = new ArrayList<>();
+        for (int val = left; val <= right; val++) {
+            for (TreeNode leftSubtree : generate(left, val - 1)) {
+                for (TreeNode rightSubtree: generate(val + 1, right)) {
+                    TreeNode root = new TreeNode(val);
+                    root.left = leftSubtree;
+                    root.right = rightSubtree;
+                    res.add(root);
+                }
+            }
+        }
+
+        return res;
+    }
+}

Diff for: java/0095-unique-binary-search-trees-ii.java

@@ -0,0 +1,39 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+
+    static void preOrder(TreeNode root, List<Integer> res){
+
+
+        if(root == null){
+            return;
+        }
+        res.add(root.val);
+        preOrder(root.left,res);
+        preOrder(root.right,res);
+
+    }
+
+    public List<Integer> preorderTraversal(TreeNode root) {
+
+        List<Integer> res = new ArrayList<>();
+
+        preOrder(root,res);
+
+        return res;
+
+    }
+}

Diff for: java/0144-binary-tree-preorder-traversal.java

@@ -0,0 +1,11 @@
+class Solution {
+    public int rangeBitwiseAnd(int left, int right) {
+        int i = 0;
+        while(left != right){
+            left = left >> 1;
+            right = right >> 1;
+            i += 1;
+        }
+        return left << i;
+    }
+}