Merge pull request doocs#164 from hoooga/dev

Add cpp solution for problem 1024-1028

Author: yanglbme

solution/1024.Video Stitching/Solution.cpp

@@ -0,0 +1,24 @@
+class Solution {
+public:
+    int videoStitching(vector<vector<int>>& clips, int T) {
+        int maxEnding = 0;
+        int count = 0;
+        vector<int> maxEnd(T+1, 0); // maxEnd[i] : maximum ending time of all videos that start by time i
+        for (int i = 0; i < clips.size(); ++i) {
+            if (clips[i][0] >= T) continue;
+            maxEnd[clips[i][0]] = max(maxEnd[clips[i][0]], clips[i][1]);
+        }
+        for (int i = 1; i < T; ++i) {
+                maxEnd[i] = max(maxEnd[i], maxEnd[i-1]);
+        }
+        for (int i = 0; i < T; ++i) { 
+            if (maxEnding == i) { // select video with maximum ending if one more video is necessary 
+                count ++;
+                maxEnding = maxEnd[i];
+            } else if (maxEnding < i) {
+                return -1;
+            }
+        }
+        return count;
+    }
+};

solution/1025.Divisor Game/Solution.cpp

@@ -0,0 +1,20 @@
+class Solution {
+    unordered_map<int, bool> mem;
+public:
+    bool divisorGame(int N) { 
+        if (N == 1) return false;
+        if (mem.count(N)) {
+            return mem[N];
+        }
+        for (int i = 1; i < N; ++i) {
+            if (N % i == 0) {
+                if (divisorGame(N-i) == false) {
+                    mem[N] = true;
+                    return true;
+                }
+            }
+        }
+        mem[N] = false;
+        return false;
+    }
+};

solution/1026.Maximum Difference Between Node and Ancestor/Solution.cpp

@@ -0,0 +1,41 @@
+/**
+ * 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 helper(TreeNode* node, int& left, int & right) {
+        left = INT_MAX;
+        right = INT_MIN;
+        if (node == nullptr) {
+            return 0;
+        }
+        left = node->val;
+        right = node->val;
+        
+        int tmpLeft, tmpRight;
+        int res = 0;
+        
+        res = max(res, helper(node->left, tmpLeft, tmpRight));
+        left = min(left, tmpLeft);
+        right = max(right, tmpRight);
+        
+        res = max(res, helper(node->right, tmpLeft, tmpRight));
+        left = min(left, tmpLeft);
+        right = max(right, tmpRight);
+        
+        res = max(res, abs(node->val - left));
+        res = max(res, abs(node->val - right));
+        
+        return res;
+    }
+public:
+    int maxAncestorDiff(TreeNode* root) {
+        int left = 0, right = 0;
+        return helper(root, left, right);
+    }
+};

solution/1027.Longest Arithmetic Sequence/Solution.cpp

@@ -0,0 +1,19 @@
+class Solution {
+    unordered_map<int, int> tested; // map (start index * 1005 + steps) to longest length  
+public:
+    int longestArithSeqLength(vector<int>& A) {
+        int res = 0;
+        for (int i = 0; i < A.size(); ++i) {
+            for (int j = 0; j < i; ++j) {
+                int diff = A[i] - A[j];
+                if (tested.count(j*10005 + diff)) {
+                    tested[i*10005+diff] = max(tested[i*10005+diff], 1+tested[j*10005 + diff]);
+                } else {
+                    tested[i*10005+diff] = max(tested[i*10005+diff], 2);
+                }
+                res = max(res, tested[i*10005+diff]);
+            }
+        }
+        return res;
+    }
+};

solution/1028.Recover a Tree From Preorder Traversal/Solution.cpp

@@ -0,0 +1,46 @@
+/**
+ * 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 {
+public:
+    TreeNode* recoverFromPreorder(string S) {
+        stack<TreeNode*> st;
+        int depth = 0;
+        int num = 0;
+        for (int i = 0; i < S.length(); ++i) {
+            if (S[i] == '-') {
+                depth ++;
+            } else {
+                num = 10*num + S[i]-'0';
+            }
+            if (i+1 >= S.length() || (isdigit(S[i]) && S[i+1] == '-')) {
+                TreeNode * newNode = new TreeNode(num);
+                while (st.size() > depth) {
+                    st.pop();
+                }
+                if (!st.empty()) {
+                    if (st.top()->left == nullptr) {
+                        st.top()->left = newNode;
+                    } else {
+                        st.top()->right = newNode;
+                    }
+                }
+                st.push(newNode);
+                depth = 0;
+                num = 0;
+            }
+        }
+        TreeNode* res;
+        while (!st.empty()) {
+            res = st.top();
+            st.pop();
+        }
+        return res;
+    }
+};