477/520 problems solved

Author: kaidul

Continuous_Subarray_Sum.cpp

@@ -0,0 +1,20 @@
+class Solution {
+public:
+    bool checkSubarraySum(vector<int>& nums, int k) {
+        unordered_map<int, int> indxMap;
+        int sum = 0;
+        indxMap[sum] = -1;
+        for(int i = 0; i < nums.size(); i++) {
+            sum += nums[i];
+            if(k != 0) sum %= k;
+            if(indxMap.count(sum)) {
+                if(i - indxMap[sum] >= 2) {
+                    return true;    
+                }
+            } else {
+                indxMap[sum] = i;
+            }
+        }
+        return false;
+    }
+};

Longest_Word_in_Dictionary_through_Deleting.cpp

@@ -0,0 +1,30 @@
+class Solution {
+    bool isSubseq(string const& txt, string const& subseq) {
+        int n = (int)txt.length();
+        int m = (int)subseq.length();
+        if(m > n) return false;
+        int i = 0, j = 0;
+        while(i < n and j < m) {
+            if(subseq[j] == txt[i]) {
+                j++, i++;
+            } else {
+                i++;
+            }
+        }
+        return j == m;
+    }
+public:
+    string findLongestWord(string s, vector<string>& d) {
+        string result = "";
+        int maxLen = 0;
+        sort(d.begin(), d.end());
+        for(int i = 0; i < (int)d.size(); i++) {
+            if(d[i].length() > result.length() and isSubseq(s, d[i])) {
+                maxLen = (int)d[i].length();
+                result = d[i];
+            }
+        }
+        
+        return result;
+    }
+};

Minesweeper.cpp

@@ -0,0 +1,52 @@
+class Solution {
+    const int dx[8] = {-1, -1, -1, 0, 1, 1, 1, 0};
+    const int dy[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
+    
+    bool valid(int x, int y, vector<vector<char>>& board) {
+        int n = (int)board.size();
+        int m = (int)board[0].size();
+        return x >= 0 and y >= 0 and x < n and y < m;
+    }
+    
+    int countMine(int x, int y, vector<vector<char>>& board) {
+        int cnt = 0;
+        for(int i = 0; i < 8; i++) {
+            int X = x + dx[i];
+            int Y = y + dy[i];
+            cnt += (valid(X, Y, board) and board[X][Y] == 'M');
+        }
+        return cnt;
+    }
+    
+    void reveal(int x, int y, vector<vector<char>>& board) {
+        int mine = countMine(x, y, board);
+        if(mine > 0) {
+            board[x][y] = mine + '0';
+            return;
+        }
+        board[x][y] = 'B';
+        for(int i = 0; i < 8; i++) {
+            int X = x + dx[i];
+            int Y = y + dy[i];
+            if(valid(X, Y, board) and board[X][Y] == 'E') {
+                reveal(X, Y, board);
+            }
+        }
+    }
+    
+public:
+    vector<vector<char>> updateBoard(vector<vector<char>>& board, vector<int>& click) {
+        int x = click[0], y = click[1];
+        switch(board[x][y]) {
+            case 'M':
+                board[x][y] = 'X';
+                break;
+            case 'E':
+                reveal(x, y, board);
+                break;
+            default:
+                break;
+        }
+        return board;
+    }
+};

Minimum_Absolute_Difference_in_BST.cpp

@@ -0,0 +1,25 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+    int getMinimumDifference(TreeNode* root, int& prev) {
+        if(!root) return INT_MAX;
+        int leftMin = getMinimumDifference(root->left, prev);
+        int diff = (prev == INT_MIN) ? INT_MAX : root->val - prev;
+        prev = root->val;
+        int rightMin = getMinimumDifference(root->right, prev);
+        
+        return min(diff, min(leftMin, rightMin));
+    }
+public:
+    int getMinimumDifference(TreeNode* root) {
+        int prev = INT_MIN;
+        return getMinimumDifference(root, prev);
+    }
+};

Next_Greater_Element_I.cpp

@@ -0,0 +1,22 @@
+class Solution {
+public:
+    vector<int> nextGreaterElement(vector<int>& findNums, vector<int>& nums) {
+        int n = (int)findNums.size();
+        int m = (int)nums.size();
+        unordered_map<int, int> nxtGreaterMap;
+        stack<int> Stack;
+        for(int i = 0; i < m; i++) {
+            while(!Stack.empty() and Stack.top() < nums[i]) {
+                nxtGreaterMap[Stack.top()] = nums[i];
+                Stack.pop();
+            }
+            Stack.push(nums[i]);
+        }
+        vector<int> result(n);
+        for(int i = 0; i < n; i++) {
+            result[i] = (nxtGreaterMap.count(findNums[i])) ? nxtGreaterMap[findNums[i]] : -1;
+        }
+        
+        return result;
+    }
+};

Next_Greater_Element_II.cpp

@@ -0,0 +1,22 @@
+class Solution {
+public:
+    vector<int> nextGreaterElements(vector<int>& nums) {
+        int n = (int)nums.size();
+        for(int i = 0; i < n - 1; i++) {
+            nums.push_back(nums[i]);
+        }
+        stack<pair<int, int>> Stack;
+        vector<int> result(n, -1);
+        for(int i = 0; i < (int)nums.size(); ++i) {
+            while(!Stack.empty() and Stack.top().first < nums[i]) {
+                result[Stack.top().second] = nums[i];
+                Stack.pop();
+            }
+            if(i < n) {
+                Stack.push({nums[i], i});
+            }
+        }
+        
+        return result;
+    }
+};