Merge branch 'main' into main

Author: neetcode-gh

.gitignore

@@ -0,0 +1 @@
+.DS_Store

130-Surrounded-Regions.java

@@ -0,0 +1,37 @@
+class Solution {
+    public void solve(char[][] board) {
+        int nRows = board.length;
+        int nCols = board[0].length;
+        
+        // 1a) Capture unsurrounded regions - top and bottom row (O -> T)
+        for (int i = 0; i < nCols; i++) {
+            if (board[0][i] == 'O') dfs(board, 0, i);
+            if (board[nRows-1][i] == 'O') dfs(board, nRows-1, i);
+        }
+        
+        // 1b) Capture unsurrounded regions - Left and right columns (O -> T)
+        for (int i = 0; i < nRows; i++) {
+            if (board[i][0] == 'O') dfs(board, i, 0);
+            if (board[i][nCols-1] == 'O') dfs(board, i, nCols-1);
+        }
+        
+        for (int r = 0; r < nRows; r++) {
+            for (int c = 0; c < nCols; c++) {
+                if (board[r][c] == 'O') board[r][c] = 'X'; // 2) Capture surrounded regions (O -> X)
+                if (board[r][c] == 'T') board[r][c] = 'O'; // 3) Uncapture unsurrounded regions (T- O)
+            }
+        }
+    }
+    
+    private void dfs(char[][] board, int r, int c) {
+        int nRows = board.length;
+        int nCols = board[0].length;
+        if (r < 0 || c < 0 || r >= nRows || c >= nCols || board[r][c] != 'O') return;
+        
+        board[r][c] = 'T';
+        dfs(board, r+1, c);
+        dfs(board, r-1, c);
+        dfs(board, r, c+1);
+        dfs(board, r, c-1);
+    }  
+}

200-Number-of-Islands.py

@@ -4,7 +4,6 @@ def numIslands(self, grid: List[List[str]]) -> int:
             return 0
 
         islands = 0
-        q = collections.deque()
         visit = set()
         rows, cols = len(grid), len(grid[0])
 

371-Sum-of-Two-Integers.java

@@ -7,4 +7,4 @@ public int getSum(int a, int b) {
         }
         return a;
     }
-}
+}

cpp/neetcode_150/01_arrays_&_hashing/contains_duplicate.cpp

@@ -0,0 +1,25 @@
+/*
+    Given int array, return true if any value appears at least twice
+    Ex. nums = [1,2,3,1] -> true, nums = [1,2,3,4] -> false
+
+    If seen num previously then has dupe, else insert into hash set
+
+    Time: O(n)
+    Space: O(n)
+*/
+
+class Solution {
+public:
+    bool containsDuplicate(vector<int>& nums) {
+        unordered_set<int> s;
+        
+        for (int i = 0; i < nums.size(); i++) {
+            if (s.find(nums[i]) != s.end()) {
+                return true;
+            }
+            s.insert(nums[i]);
+        }
+        
+        return false;
+    }
+};

cpp/neetcode_150/01_arrays_&_hashing/encode_and_decode_strings.cpp

@@ -0,0 +1,48 @@
+/*
+    Design algorithm to encode/decode: list of strings <-> string
+
+    Encode/decode w/ non-ASCII delimiter: {len of str, "#", str}
+
+    Time: O(n)
+    Space: O(1)
+*/
+
+class Codec {
+public:
+
+    // Encodes a list of strings to a single string.
+    string encode(vector<string>& strs) {
+        string result = "";
+        
+        for (int i = 0; i < strs.size(); i++) {
+            string str = strs[i];
+            result += to_string(str.size()) + "#" + str;
+        }
+        
+        return result;
+    }
+
+    // Decodes a single string to a list of strings.
+    vector<string> decode(string s) {
+        vector<string> result;
+        
+        int i = 0;
+        while (i < s.size()) {
+            int j = i;
+            while (s[j] != '#') {
+                j++;
+            }
+            int length = stoi(s.substr(i, j - i));
+            string str = s.substr(j + 1, length);
+            result.push_back(str);
+            i = j + 1 + length;
+        }
+        
+        return result;
+    }
+private:
+};
+
+// Your Codec object will be instantiated and called as such:
+// Codec codec;
+// codec.decode(codec.encode(strs));

cpp/neetcode_150/01_arrays_&_hashing/group_anagrams.cpp

@@ -0,0 +1,39 @@
+/*
+    Given array of strings, group anagrams together (same letters diff order)
+    Ex. strs = ["eat","tea","tan","ate","nat","bat"] -> [["bat"],["nat","tan"],["ate","eat","tea"]]
+
+    Count chars, for each string use total char counts (naturally sorted) as key
+
+    Time: O(n x l) -> n = length of strs, l = max length of a string in strs
+    Space: O(n x l)
+*/
+
+class Solution {
+public:
+    vector<vector<string>> groupAnagrams(vector<string>& strs) {
+        unordered_map<string, vector<string>> m;
+        for (int i = 0; i < strs.size(); i++) {
+            string key = getKey(strs[i]);
+            m[key].push_back(strs[i]);
+        }
+        
+        vector<vector<string>> result;
+        for (auto it = m.begin(); it != m.end(); it++) {
+            result.push_back(it->second);
+        }
+        return result;
+    }
+private:
+    string getKey(string str) {
+        vector<int> count(26);
+        for (int j = 0; j < str.size(); j++) {
+            count[str[j] - 'a']++;
+        }
+        
+        string key = "";
+        for (int i = 0; i < 26; i++) {
+            key.append(to_string(count[i] + 'a'));
+        }
+        return key;
+    }
+};

cpp/neetcode_150/01_arrays_&_hashing/longest_consecutive_sequence.cpp

@@ -0,0 +1,36 @@
+/*
+    Given unsorted array, return length of longest consecutive sequence
+    Ex. nums = [100,4,200,1,3,2] -> 4, longest is [1,2,3,4]
+
+    Store in hash set, only check for longer seq if it's the beginning
+
+    Time: O(n)
+    Space: O(n)
+*/
+
+class Solution {
+public:
+    int longestConsecutive(vector<int>& nums) {
+        unordered_set<int> s;
+        for (int i = 0; i < nums.size(); i++) {
+            s.insert(nums[i]);
+        }
+        
+        int result = 0;
+        
+        for (auto it = s.begin(); it != s.end(); it++) {
+            int currNum = *it;
+            if (s.find(currNum - 1) != s.end()) {
+                continue;
+            }
+            int currLength = 1;
+            while (s.find(currNum + 1) != s.end()) {
+                currLength++;
+                currNum++;
+            }
+            result = max(result, currLength);
+        }
+        
+        return result;
+    }
+};

cpp/neetcode_150/01_arrays_&_hashing/product_of_array_except_self.cpp

@@ -0,0 +1,32 @@
+/*
+    Given an integer array nums, return an array such that:
+    answer[i] is equal to the product of all elements of nums except nums[i]
+    Ex. nums = [1,2,3,4] -> [24,12,8,6], nums = [-1,1,0,-3,3] -> [0,0,9,0,0]
+
+    Calculate prefix products forward, then postfix backwards in a 2nd pass
+
+    Time: O(n)
+    Space: O(1)
+*/
+
+class Solution {
+public:
+    vector<int> productExceptSelf(vector<int>& nums) {
+        int n = nums.size();
+        vector<int> result(n, 1);
+        
+        int prefix = 1;
+        for (int i = 0; i < n; i++) {
+            result[i] = prefix;
+            prefix = prefix * nums[i];
+        }
+        
+        int postfix = 1;
+        for (int i = n - 1; i >= 0; i--) {
+            result[i] = result[i] * postfix;
+            postfix = postfix * nums[i];
+        }
+        
+        return result;
+    }
+};

cpp/neetcode_150/01_arrays_&_hashing/top_k_frequent_elements.cpp

@@ -0,0 +1,65 @@
+/*
+    Given an integer array nums & an integer k, return the k most frequent elements
+    Ex. nums = [1,1,1,2,2,3] k = 2 -> [1,2], nums = [1] k = 1 -> [1]
+    
+    Heap -> optimize w/ freq map & bucket sort (no freq can be > n), get results from end
+*/
+
+// Time: O(n log k)
+// Space: O(n + k)
+
+// class Solution {
+// public:
+//     vector<int> topKFrequent(vector<int>& nums, int k) {
+//         unordered_map<int, int> m;
+//         for (int i = 0; i < nums.size(); i++) {
+//             m[nums[i]]++;
+//         }
+//         priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
+//         for (auto it = m.begin(); it != m.end(); it++) {
+//             pq.push({it->second, it->first});
+//             if (pq.size() > k) {
+//                 pq.pop();
+//             }
+//         }
+//         vector<int> result;
+//         while (!pq.empty()) {
+//             result.push_back(pq.top().second);
+//             pq.pop();
+//         }
+//         return result;
+//     }
+// };
+
+// Time: O(n)
+// Space: O(n)
+
+class Solution {
+public:
+    vector<int> topKFrequent(vector<int>& nums, int k) {
+        int n = nums.size();
+        
+        unordered_map<int, int> m;
+        for (int i = 0; i < n; i++) {
+            m[nums[i]]++;
+        }
+        
+        vector<vector<int>> buckets(n + 1);
+        for (auto it = m.begin(); it != m.end(); it++) {
+            buckets[it->second].push_back(it->first);
+        }
+        
+        vector<int> result;
+        
+        for (int i = n; i >= 0; i--) {
+            if (result.size() >= k) {
+                break;
+            }
+            if (!buckets[i].empty()) {
+                result.insert(result.end(), buckets[i].begin(), buckets[i].end());
+            }
+        }
+        
+        return result;
+    }
+};