add 10 problems

Author: zhuli19901106

2-keys-keyboard_1_AC.cpp

@@ -0,0 +1,32 @@
+// Trivial
+#include <vector>
+using std::vector;
+
+class Solution {
+public:
+    int minSteps(int n) {
+        vector<int> dp(n + 1, 0);
+        int i;
+        for (i = 2; i <= n; ++i) {
+            dp[i] = i;
+        }
+        
+        int j;
+        for (i = 2; i <= n; ++i) {
+            for (j = 1; j <= n / j; ++j) {
+                if (i % j != 0) {
+                    continue;
+                }
+                if (dp[i] > dp[j] + i / j) {
+                    dp[i] = dp[j] + i / j;
+                }
+                if (j != i / j && dp[i] > dp[i / j] + j) {
+                    dp[i] = dp[i / j] + j;
+                }
+            }
+        }
+        
+        int res = dp[n];
+        return res;
+    }
+};

dota2-senate_1_AC.cpp

@@ -0,0 +1,90 @@
+// Just greedy, no game theory involved.
+// Although the problem itself is not exactly easy, could be a bit tricky.
+class Solution {
+public:
+    string predictPartyVictory(string senate) {
+        auto &s = senate;
+        int ls = s.size();
+        
+        int nr, nd;
+        nr = nd = 0;
+        int i;
+        for (i = 0; i < ls; ++i) {
+            if (senate[i] == 'R') {
+                ++nr;
+            } else {
+                ++nd;
+            }
+        }
+        if (nd == 0) {
+            return "Radiant";
+        } else if (nr == 0) {
+            return "Dire";
+        }
+        
+        int ir = nextPos(s, 'R', 0);
+        int id = nextPos(s, 'D', 0);
+        int cr = nr;
+        int cd = nd;
+        for (i = 0; i < ls; ++i) {
+            if (nr == 0 || nd == 0) {
+                break;
+            }
+            if (s[i] == 'R') {
+                // choose the next 'D' to ban
+                if (id < i && cd > 0) {
+                    id = nextPos(s, 'D', i + 1);
+                }
+                s[id] = 'X';
+                --nd;
+                --cd;
+                id = nextPos(s, 'D', id + 1);
+                
+                --cr;
+            } else if (s[i] == 'D') {
+                // choose the next 'R' to ban
+                if (ir < i && cr > 0) {
+                    ir = nextPos(s, 'R', i + 1);
+                }
+                s[ir] = 'X';
+                --nr;
+                --cr;
+                ir = nextPos(s, 'R', ir + 1);
+                
+                --cd;
+            } else {
+                // already banned
+            }
+        }
+        if (nd == 0) {
+            return "Radiant";
+        } else if (nr == 0) {
+            return "Dire";
+        }
+        
+        string s1;
+        for (i = 0; i < ls; ++i) {
+            if (s[i] == 'R' || s[i] == 'D') {
+                s1.push_back(s[i]);
+            }
+        }
+        return predictPartyVictory(s1);
+    }
+private:
+    int nextPos(const string &s, char c, int idx) {
+        int ls = s.size();
+        int i = idx;
+        while (i < ls && s[i] != c) {
+            ++i;
+        }
+        if (i < ls && s[i] == c) {
+            return i;
+        }
+        
+        i = 0;
+        while (i < idx && s[i] != c) {
+            ++i;
+        }
+        return i;
+    }
+};

find-duplicate-subtrees_1_AC.cpp

@@ -0,0 +1,51 @@
+// When it comes to pattern matching in structured data, you need serialization.
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+#include <string>
+#include <unordered_map>
+#include <vector>
+using std::string;
+using std::to_string;
+using std::unordered_map;
+using std::vector;
+
+class Solution {
+public:
+    vector<TreeNode*> findDuplicateSubtrees(TreeNode* root) {
+        vector<TreeNode *> res;
+        if (root == NULL) {
+            return res;
+        }
+        
+        serialize(root);
+        for (auto &p: um) {
+            if (p.second.size() > 1) {
+                res.push_back(p.second[0]);
+            }
+        }
+        um.clear();
+        
+        return res;
+    }
+private:
+    unordered_map<string, vector<TreeNode *>> um;
+    
+    string serialize(TreeNode *root) {
+        if (root == NULL) {
+            return "null";
+        }
+        string sl = serialize(root->left);
+        string sr = serialize(root->right);
+        string s = "{" + to_string(root->val) + "," + sl + "," + sr + "}";
+        um[s].push_back(root);
+        
+        return s;
+    }
+};

maximum-binary-tree_1_AC.cpp

@@ -0,0 +1,40 @@
+// Brute-force
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+#include <vector>
+using std::vector;
+
+class Solution {
+public:
+    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
+        int n = nums.size();
+        TreeNode *root;
+        
+        traverse(root, nums, 0, n - 1);
+        return root;
+    }
+private:
+    void traverse(TreeNode *&root, vector<int> &v, int ll, int rr) {
+        if (ll > rr) {
+            root = NULL;
+            return;
+        }
+        int mm = ll;
+        int i;
+        for (i = ll + 1; i <= rr; ++i) {
+            if (v[i] > v[mm]) {
+                mm = i;
+            }
+        }
+        root = new TreeNode(v[mm]);
+        traverse(root->left, v, ll, mm - 1);
+        traverse(root->right, v, mm + 1, rr);
+    }
+};

maximum-binary-tree_2_AC.cpp

@@ -0,0 +1,85 @@
+// RMQ problem, very intuitive and efficient, but be careful with the coding.
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+#include <cmath>
+#include <vector>
+using std::log;
+using std::vector;
+
+class Solution {
+public:
+    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
+        auto &v = nums;
+        int n = v.size();
+        int dep = (int)(log(n) / log(2.0)) + 1;
+        
+        int i;
+        max_idx.resize(dep, vector<int>(n));
+        for (i = 0; i < n; ++i) {
+            max_idx[0][i] = i;
+        }
+        
+        int j;
+        int b2 = 1;
+        int i1, i2;
+        for (i = 1; i < dep; ++i) {
+            for (j = 0; j < n; ++j) {
+                i1 = max_idx[i - 1][j];
+                if (j + b2 < n) {
+                    i2 = max_idx[i - 1][j + b2];
+                    max_idx[i][j] = (v[i1] > v[i2]) ? i1 : i2;
+                } else {
+                    max_idx[i][j] = i1;
+                }
+            }
+            b2 <<= 1;
+        }
+        
+        TreeNode *root;
+        traverse(root, nums, 0, n);
+        max_idx.clear();
+        
+        return root;
+    }
+private:
+    vector<vector<int>> max_idx;
+    
+    int rmq(vector<int> &v, int ll, int rr) {
+        int d = 0;
+        int b2 = 1;
+        int lr, rl;
+        while (true) {
+            lr = ll + b2;
+            rl = rr - b2;
+            if (lr >= rl) {
+                // two intervals overlap
+                break;
+            } else {
+                // double the interval length
+                d += 1;
+                b2 <<= 1;
+            }
+        }
+        int i1 = max_idx[d][ll];
+        int i2 = max_idx[d][rl];
+        return (v[i1] > v[i2]) ? i1 : i2;
+    }
+    
+    void traverse(TreeNode *&root, vector<int> &v, int ll, int rr) {
+        if (ll >= rr) {
+            root = NULL;
+            return;
+        }
+        int mm = rmq(v, ll, rr);
+        root = new TreeNode(v[mm]);
+        traverse(root->left, v, ll, mm);
+        traverse(root->right, v, mm + 1, rr);
+    }
+};

maximum-length-of-pair-chain_1_AC.cpp

@@ -0,0 +1,36 @@
+// Think for a while before coding.
+#include <algorithm>
+#include <vector>
+using std::sort;
+using std::vector;
+
+typedef vector<int> VI;
+
+bool comparator(const VI &v1, const VI &v2)
+{
+    if (v1[1] != v2[1]) {
+        return v1[1] < v2[1];
+    }
+    return false;
+}
+
+class Solution {
+public:
+    int findLongestChain(vector<VI> &pairs) {
+        auto &v = pairs;
+        int n = v.size();
+        int i;
+        
+        sort(v.begin(), v.end(), comparator);
+        int max_val = v[0][1];
+        int max_len = 1;
+        for (i = 1; i < n; ++i) {
+            // the key
+            if (v[i][0] > max_val) {
+                max_val = v[i][1];
+                ++max_len;
+            }
+        }
+        return max_len;
+    }
+};

palindromic-substrings_1_AC.cpp

@@ -0,0 +1,27 @@
+// Brute-force, I don't wanna bother those fancy tricks.
+#include <string>
+using std::string;
+
+class Solution {
+public:
+    int countSubstrings(string s) {
+        int ls = s.size();
+        int i, j;
+        int sum = 0;
+        for (i = 0; i < ls; ++i) {
+            j = 1;
+            while (i - j >= 0 && i + j <= ls - 1 && s[i - j] == s[i + j]) {
+                ++j;
+            }
+            sum += j;
+        }
+        for (i = 0; i + 1 < ls; ++i) {
+            j = 0;
+            while (i - j >= 0 && i + 1 + j <= ls - 1 && s[i - j] == s[i + 1 + j]) {
+                ++j;
+            }
+            sum += j;
+        }
+        return sum;
+    }
+};