480/520 problems solved. Can't access some problems due to expiration of premium membership

Author: kaidul

Teemo_Attacking.cpp

@@ -0,0 +1,18 @@
+class Solution {
+public:
+    int findPoisonedDuration(vector<int>& timeSeries, int duration) {
+        int result = 0;
+        int n = (int)timeSeries.size();
+        for(int i = 0; i < n; i++) {
+            int start = timeSeries[i];
+            int end = start + duration - 1;
+            while(i + 1 < n and timeSeries[i + 1] <= end) {
+                end = timeSeries[i + 1] + duration - 1;
+                i++;
+            }
+            result += (end - start + 1);
+        }
+        
+        return result;
+    }
+};

UTF-8_Validation.cpp

@@ -0,0 +1,32 @@
+class Solution {
+    const int MSB = 7;
+public:
+    bool validUtf8(vector<int>& data) {
+        int i = 0, n = (int)data.size();
+        while(i < n) {
+            int nbyte = 0;
+            for(int k = 0; k < 4 and (data[i] & (1 << (MSB - k))); k++) {
+                nbyte++;
+            }
+            if(nbyte == 1) {
+                return false;
+            }
+            if(nbyte == 0) nbyte++;
+            if(nbyte > 1 and (bool)(data[i] & (1 << (MSB - nbyte))) ) {
+                return false;
+            }
+            if(i + nbyte - 1 >= n) {
+                return false;
+            }
+            for(int k = 1; k < nbyte; k++) {
+                bool on = data[i + k] & (1 << MSB);
+                bool off = data[i + k] & (1 << (MSB - 1));
+                if(!on or off) {
+                    return false;
+                }
+            }
+            i += nbyte; 
+        }
+        return true;
+    }
+};

Zuma_Game.cpp

@@ -0,0 +1,66 @@
+class Solution {
+    const int MAX_STEP = 6;
+    
+    void shrink(string& board) {
+        if(board.empty()) {
+            return;
+        }
+        int left = 0;
+        for(int i = 0; i <= board.size(); i++) {
+            if (i == board.size() || board[i] != board[left]) {
+                if(i - left >= 3) {
+                    board = board.substr(0, left) + board.substr(i);
+                    shrink(board);
+                    return;
+                }
+                left = i;
+            }
+        }
+    }
+    
+    int solve(string board, unordered_map<char, int>& handMap) {
+        if (board.empty()) return 0;
+        if (handMap.empty()) return MAX_STEP;
+        int ret = MAX_STEP;
+        int n = (int)board.size();
+        int i = 0;
+        while (i < n) {
+            if(!handMap.count(board[i])) {
+                i++;
+                continue;
+            }
+            if(i + 1 < n and board[i] == board[i + 1]) {
+                string nextBoard = board.substr(0, i) + board.substr(i + 2);
+                shrink(nextBoard);
+                handMap[board[i]]--;
+                if(!handMap[board[i]]) {
+                    handMap.erase(board[i]);
+                }
+                ret = min(ret, 1 + solve(nextBoard, handMap));
+                handMap[board[i]]++;
+                i++;
+            } else if(handMap[board[i]] >= 2) {
+                string nextBoard = board.substr(0, i) + board.substr(i + 1);
+                shrink(nextBoard);
+                handMap[board[i]] -= 2;
+                if(!handMap[board[i]]) {
+                    handMap.erase(board[i]);
+                }
+                ret = min(ret, 2 + solve(nextBoard, handMap));
+                handMap[board[i]] += 2;
+            }
+            i++;
+        }
+        return ret;
+    }
+    
+public:
+    int findMinStep(string board, string hand) {
+        unordered_map<char, int> handMap;
+        for(int i = 0; i < hand.size(); i++) {
+            handMap[hand[i]]++;
+        }
+        int result = solve(board, handMap);
+        return result >= MAX_STEP ? -1 : result;
+    }
+};