650 problems solved

Author: kaidul

Diff for: README.md

@@ -1,4 +1,45 @@
 class Solution {
+public:
+    unordered_map<string, string> url2Code;
+    unordered_map<string, string> code2Url;
+    
+    string alphaNums = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    int ENCODE_LENGTH = 6; 
+    
+    string generateCode(string const& longUrl) {
+        string code = "";
+        for (int i = 0; i < ENCODE_LENGTH; i++) {
+            code += alphaNums[rand() % alphaNums.length()];
+        }
+        
+        return code;
+    }
+
+    // Encodes a URL to a shortened URL.
+    string encode(string longUrl) {
+        if (url2Code.find(longUrl) != url2Code.end()) {
+            return "http://tinyurl.com/" + url2Code[longUrl];
+        }
+        string code;
+        do {
+            code = generateCode(longUrl);
+        } while (code2Url.find(code) != code2Url.end());
+        code2Url[code] = longUrl;
+        url2Code[longUrl] = code; 
+        
+        return "http://tinyurl.com/" + code;
+    }
+
+    // Decodes a shortened URL to its original URL.
+    string decode(string shortUrl) {
+        string code = shortUrl.substr(shortUrl.length() - ENCODE_LENGTH, ENCODE_LENGTH);
+        return code2Url[code];
+    }
+};
+
+
+// joke
+class Solution {
 public:
 
     // Encodes a URL to a shortened URL.

Diff for: source-code/Encode_and_Decode_TinyURL.cpp

@@ -0,0 +1,15 @@
+class Solution {
+public:
+    int numJewelsInStones(string J, string S) {
+        vector<bool> isJewel(256, false);
+        for (char jewel : J) {
+            isJewel[jewel] = true;
+        }
+        int count = 0;
+        for (char stone : S) {
+            count += isJewel[stone];
+        }
+        
+        return count;
+    }
+};

Diff for: source-code/Jewels_and_Stones.cpp

@@ -84,7 +84,8 @@ class LRUCache {
     }
 };
 
-// using C++ list. got RE for memory corruption though :(
+
+// using C++ std::list
 class LRUCache {
 public:
     LRUCache(int capacity) {
@@ -95,27 +96,24 @@ class LRUCache {
 
     int get(int key) {
         if (table.find(key) != table.end()) {
-            auto node = table[key];
-            pair<int, int> entry = *node;
-            entries.erase(node);
-            entries.push_front(entry);
-            return entry.second;
+            auto entry = table[key];
+            entries.splice(entries.begin(), entries, entry);
+            return entry->second;
         }
         return -1;
     }
 
     void put(int key, int value) {
-        pair<int, int> newEntry = {key, value};
         if (table.find(key) != table.end()) {
-            auto curr = table[key];
-            entries.erase(curr);
+            entries.erase(table[key]);
         } else {
-            if(entries.size() >= capacity) {
+           if(entries.size() >= capacity) {
                 pair<int, int> tailEntry = entries.back();
-                entries.pop_back();
                 table.erase(tailEntry.first);
-            }
+                entries.pop_back();
+            } 
         }
+        pair<int, int> newEntry = {key, value};
         entries.push_front(newEntry);
         table[key] = entries.begin();
     }

Diff for: source-code/LRU_Cache.cpp

@@ -27,10 +27,9 @@ class Solution {
         for(int i = 0; i < positions.size(); ++i) {
             int x = positions[i].first;
             int y = positions[i].second;
-            if(find(x, y, parent) == WATER) {
-                parent[x][y] = pair<int, int>(x, y);
-                nSet++;
-            }
+            parent[x][y] = pair<int, int>(x, y);
+            nSet++;
+            
             for(int k = 0; k < 4; ++k) {
                 int newX = x + dx[k];
                 int newY = y + dy[k];

Diff for: source-code/Number_of_Islands_II.cpp

@@ -1,3 +1,26 @@
+// top-down
+class Solution {
+    int numSquares(int n, vector<int>& dp) {
+        if (n == 0) {
+            return 0;
+        }
+        if (dp[n] != INT_MAX) {
+            return dp[n];
+        }
+        for (int i = 1; i * i <= n; i++) {
+            int sqr = i * i;
+            dp[n] = min(dp[n], 1 + numSquares(n - sqr, dp));
+        }
+        
+        return dp[n];
+    }
+public:
+    int numSquares(int n) {
+        vector<int> dp(n + 1, INT_MAX);
+        return numSquares(n, dp);
+    }
+};
+
 // DP O(n sqrt(n))
 class Solution {
 public:

Diff for: source-code/Perfect_Squares.cpp

@@ -12,17 +12,15 @@ class Solution {
         }
         for(int i = 0; i < n; ++i) {
             if(!taken[s[i] - 'a']) {
-                while(!Stack.empty() and Stack.top() > s[i] and freq[Stack.top() - 'a'] > 1) {
+                while(!Stack.empty() and Stack.top() > s[i] and freq[Stack.top() - 'a'] > 0) {
                     char rmv = Stack.top();
                     Stack.pop();
                     taken[rmv - 'a'] = false;
-                    freq[rmv - 'a']--;
                 }
                 Stack.push(s[i]);
                 taken[s[i] - 'a'] = true;
-            } else {
-                freq[s[i] - 'a']--;
             }
+            freq[s[i] - 'a']--;
         }
         string result = "";
         result.reserve(Stack.size());

Diff for: source-code/Remove_Duplicate_Letters.cpp

@@ -0,0 +1,14 @@
+class Solution {
+public:
+    bool judgeCircle(string moves) {
+        int x = 0;
+        int y = 0;
+        for (char ch : moves) {
+            y += (ch == 'U');
+            y -= (ch == 'D');
+            x += (ch == 'R');
+            x -= (ch == 'L');
+        }
+        return (x == 0 and y == 0);   
+    }
+};

Diff for: source-code/Robot_Return_to_Origin.cpp

@@ -0,0 +1,58 @@
+/**
+ * // This is the robot's control interface.
+ * // You should not implement it, or speculate about its implementation
+ * class Robot {
+ *   public:
+ *     // Returns true if the cell in front is open and robot moves into the cell.
+ *     // Returns false if the cell in front is blocked and robot stays in the current cell.
+ *     bool move();
+ *
+ *     // Robot will stay in the same cell after calling turnLeft/turnRight.
+ *     // Each turn will be 90 degrees.
+ *     void turnLeft();
+ *     void turnRight();
+ *
+ *     // Clean the current cell.
+ *     void clean();
+ * };
+ */
+
+class Solution {
+    unordered_map<int, unordered_map<int, int>> grid;
+    int dx[4] = {-1, 0, 1, 0};
+    int dy[4] = {0, 1, 0, -1};
+    int x = 0, y = 0;
+    int dir = 0;
+    
+    void setback(Robot& robot) {
+        robot.turnRight();
+        robot.turnRight();
+        robot.move();
+        robot.turnRight();
+        robot.turnRight();
+    }
+public:
+    void cleanRoom(Robot& robot) {
+        if(grid[x][y] == 1) {
+            return;
+        }
+        
+        robot.clean();
+        grid[x][y] = 1;
+        
+        for (int i = 0; i < sizeof(dx) / sizeof(dx[0]); i++) {
+            if (robot.move()) {
+                x += dx[dir];
+                y += dy[dir];
+                
+                cleanRoom(robot);
+                
+                setback(robot);
+                x -= dx[dir];
+                y -= dy[dir];
+            }
+            robot.turnRight();
+            dir = (dir + 1) % 4;
+        }
+    }
+};

Diff for: source-code/Robot_Room_Cleaner.cpp

@@ -2,36 +2,24 @@ class Solution {
 public:
     vector<string> summaryRanges(vector<int>& nums) {
         vector<string> result;
-        string elem = "";
-        if(nums.size() > 0) {
-            elem = to_string(nums[0]) + "->";
-        }
-
-        for(int i = 1; i < nums.size(); ++i) {
-            bool isRange = false;
-            
-            while(i < nums.size() and (i > 0 and nums[i] == nums[i - 1] + 1)) {
-                ++i;
-                isRange = true;
+        int n = (int)nums.size();
+        for (int left = 0, right = 0; right < n; left++, right++) {
+            while (right + 1 < n and nums[right + 1] == nums[right] + 1) {
+                right++;
             }
-            if(isRange) {
-                elem += to_string(nums[i - 1]);
+            int rangeLength = right - left + 1;
+            string range;
+            if (rangeLength == 1) {
+                range = to_string(nums[left]);
             } else {
-                elem = elem.substr(0, elem.size() - 2);
-                // elem.erase(elem.size() - 3, 2);
-            }
-            result.push_back(elem);
-
-            if(i < nums.size()) {
-                elem = to_string(nums[i]) + "->";
+                range = to_string(nums[left]);
+                range += "->";
+                range += to_string(nums[right]);
             }
-
-        }
-
-        if(elem.size() > 0 and elem[elem.size() - 1] == '>') {
-            result.push_back(elem.substr(0, elem.size() - 2));
+            result.push_back(range);
+            left = right;
         }
-
+        
         return result;
     }
 };

Diff for: source-code/Summary_Ranges.cpp

@@ -0,0 +1,54 @@
+// visualization of this logic: https://www.youtube.com/watch?v=cJayBq38VYw
+class Solution {
+public:
+    int trapRainWater(vector<vector<int>>& heightMap) {
+        int m = heightMap.size();
+        if (m <= 0) return 0;
+        int n = heightMap[0].size();
+        if (n <= 0) return 0;
+        vector<vector<bool>> visited(m, vector<bool>(n, false));
+        priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> minHeap;
+        for (int i = 0; i < m; i++) {
+            minHeap.push({heightMap[i][0], i * n});
+            visited[i][0] = true;
+            if (n - 1 > 0) {
+                minHeap.push({heightMap[i][n - 1], i * n + n - 1});
+                visited[i][n - 1] = true;
+            }
+        }
+
+        for (int i = 0; i < n; i++) {
+            minHeap.push({heightMap[0][i], i});
+            visited[0][i] = true;
+            if (m - 1 > 0) {
+                minHeap.push({heightMap[m - 1][i], (m - 1) * n + i});
+                visited[m - 1][i] = true;
+            }
+        }
+
+        int totalWater = 0;
+        int maxHeight = INT_MIN;
+        
+        int dx[4] = {-1, 0, 1, 0};
+        int dy[4] = {0, 1, 0, -1};
+        
+        while (!minHeap.empty()) {
+            pair<int, int> curr = minHeap.top();
+            minHeap.pop();
+            int currHeight = curr.first, x = curr.second / n, y = curr.second % n;
+            maxHeight = max(maxHeight, currHeight);
+            for (int i = 0; i < sizeof(dx) / sizeof(dx[0]); i++) {
+                int neighX = x + dx[i];
+                int neighY = y + dy[i];
+                if (neighX < 0 or neighY < 0 or neighX >= m or neighY >= n or visited[neighX][neighY]) {
+                    continue;
+                }
+                totalWater += max(maxHeight - heightMap[neighX][neighY], 0);
+                minHeap.push({heightMap[neighX][neighY], neighX * n + neighY});
+                visited[neighX][neighY] = true;
+            }
+        }
+
+        return totalWater;
+    }
+};

Diff for: source-code/Trapping_Rain_Water_II.cpp

@@ -9,18 +9,17 @@ class Solution {
                 if(nums[i] > nums[i + 1]) {
                     swap(nums[i], nums[i + 1]);
                 }
-                flag ^= 1;
             } else {
                 if(nums[i] < nums[i + 1]) {
                     swap(nums[i], nums[i + 1]);
                 }
-                flag ^= 1;
             }
+            flag ^= 1;
         }
     }
 };
-// with extra space\
-/*
+
+// with extra space
 class Solution {
 public:
     void wiggleSort(vector<int>& nums) {
@@ -40,5 +39,4 @@ class Solution {
             nums[i] = tmp[k];
         }
     }
-};
-*/
+};