14 problems

Author: zhuli19901106

baseball-game_1_AC.cpp

@@ -0,0 +1,34 @@
+#include <cstdio>
+#include <string>
+#include <vector>
+using std::sscanf;
+using std::string;
+using std::vector;
+
+class Solution {
+public:
+    int calPoints(vector<string>& ops) {
+        vector<int> v;
+        int num;
+        for (auto &op: ops) {
+            if (op == "C") {
+                v.pop_back();
+            } else if (op == "D") {
+                v.push_back(v.back() * 2);
+            } else if (op == "+") {
+                num = v.size();
+                v.push_back(v[num - 1] + v[num - 2]);
+            } else {
+                sscanf(op.data(), "%d", &num);
+                v.push_back(num);
+            }
+        }
+        
+        int sum = 0;
+        for (auto &x: v) {
+            sum += x;
+        }
+        
+        return sum;
+    }
+};

employee-importance_1_AC.cpp

@@ -0,0 +1,62 @@
+// IIRC, a same problem has already been posted.
+/*
+// Employee info
+class Employee {
+public:
+    // It's the unique ID of each node.
+    // unique id of this employee
+    int id;
+    // the importance value of this employee
+    int importance;
+    // the id of direct subordinates
+    vector<int> subordinates;
+};
+*/
+#include <unordered_map>
+using std::unordered_map;
+
+class Solution {
+public:
+    int getImportance(vector<Employee*> employees, int id) {
+        unordered_map<int, int> dj;
+        unordered_map<int, int> imp;
+        
+        for (auto &e: employees) {
+            if (dj.find(e->id) == dj.end()) {
+                dj[e->id] = e->id;
+            }
+            for (auto &sid: e->subordinates) {
+                if (sid == id) {
+                    continue;
+                }
+                dj[sid] = e->id;
+            }
+        }
+        
+        int sum = 0;
+        for (auto &e: employees) {
+            if (findRoot(dj, e->id) == id) {
+                sum += e->importance;
+            }
+        }
+        
+        return sum;
+    }
+private:
+    int findRoot(unordered_map<int, int> &dj, int x) {
+        if (dj.find(x) == dj.end()) {
+            return x;
+        }
+        int r = x;
+        while (r != dj[r]) {
+            r = dj[r];
+        }
+        int k = x;
+        while (x != r) {
+            x = dj[x];
+            dj[k] = r;
+            k = x;
+        }
+        return r;
+    }
+};

find-k-closest-elements_1_AC.cpp

@@ -0,0 +1,59 @@
+#include <algorithm>
+#include <queue>
+#include <vector>
+using std::priority_queue;
+using std::reverse;
+using std::vector;
+
+class Solution {
+public:
+    vector<int> findClosestElements(vector<int>& arr, int k, int x) {
+        vector<int> res;
+        if (k <= 0) {
+            return res;
+        }
+        
+        priority_queue<int, vector<int>, greater<int>> pq1;
+        priority_queue<int, vector<int>, less<int>> pq2;
+        
+        int i;
+        for (i = 0; i < k; ++i) {
+            if (arr[i] >= x) {
+                pq2.push(arr[i]);
+            } else {
+                pq1.push(arr[i]);
+            }
+        }
+        
+        int n = arr.size();
+        for (i = k; i < n; ++i) {
+            if (arr[i] >= x) {
+                pq2.push(arr[i]);
+            } else {
+                pq1.push(arr[i]);
+            }
+            if (pq1.empty()) {
+                pq2.pop();
+            } else if (pq2.empty()) {
+                pq1.pop();
+            } else if (x - pq1.top() > pq2.top() - x) {
+                pq1.pop();
+            } else {
+                pq2.pop();
+            }
+        }
+        
+        int n1 = pq1.size();
+        while (!pq1.empty()) {
+            res.push_back(pq1.top());
+            pq1.pop();
+        }
+        while (!pq2.empty()) {
+            res.push_back(pq2.top());
+            pq2.pop();
+        }
+        reverse(res.begin() + n1, res.end());
+        
+        return res;
+    }
+};

image-smoother_1_AC.cpp

@@ -0,0 +1,38 @@
+class Solution {
+public:
+    vector<vector<int>> imageSmoother(vector<vector<int>>& M) {
+        int n = M.size();
+        int m = M[0].size();
+        vector<vector<int>> M1(n, vector<int>(m, 0));
+        
+        static int offset[9][2] = {
+            {-1, -1}, {-1,  0}, {-1, +1}, 
+            { 0, -1}, { 0,  0}, { 0, +1}, 
+            {+1, -1}, {+1,  0}, {+1, +1}
+        };
+        
+        int i, j;
+        int i1, j1;
+        int k;
+        int cc;
+        int sum;
+        for (i = 0; i < n; ++i) {
+            for (j = 0; j < m; ++j) {
+                sum = 0;
+                cc = 0;
+                for (k = 0; k < 9; ++k) {
+                   i1 = i + offset[k][0];
+                   j1 = j + offset[k][1];
+                   if (i1 < 0 || i1 > n - 1 || j1 < 0 || j1 > m - 1) {
+                       continue;
+                   }
+                   sum += M[i1][j1];
+                   ++cc;
+                }
+                M1[i][j] = sum / cc;
+            }
+        }
+        
+        return M1;
+    }
+};

judge-route-circle_1_AC.cpp

@@ -0,0 +1,15 @@
+#include <string>
+#include <unordered_map>
+using std::string;
+using std::unordered_map;
+
+class Solution {
+public:
+    bool judgeCircle(string moves) {
+        unordered_map<char, int> um;
+        for (auto &c: moves) {
+            ++um[c];
+        }
+        return (um['L'] == um['R'] && um['U'] == um['D']);
+    }
+};

longest-continuous-increasing-subsequence_1_AC.cpp

@@ -0,0 +1,24 @@
+// I'm getting bored of this.
+#include <algorithm>
+#include <vector>
+using std::max;
+using std::vector;
+
+class Solution {
+public:
+    int findLengthOfLCIS(vector<int>& nums) {
+        int n = nums.size();
+        int i, j;
+        int res = 0;
+        i = 0;
+        while (i < n) {
+            j = i + 1;
+            while (j < n && nums[j] > nums[j - 1]) {
+                ++j;
+            }
+            res = max(res, j - i);
+            i = j;
+        }
+        return res;
+    }
+};

longest-univalue-path_1_AC.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) {}
+ * };
+ */
+#include <algorithm>
+#include <unordered_map>
+using std::max;
+using std::unordered_map;
+
+class Solution {
+public:
+    int longestUnivaluePath(TreeNode* root) {
+        if (root == NULL) {
+            return 0;
+        }
+        if (um.find(root) != um.end()) {
+            return um[root];
+        }
+        
+        int r1 = traverse(root->left, root->val) + traverse(root->right, root->val);
+        int r2 = longestUnivaluePath(root->left);
+        int r3 = longestUnivaluePath(root->right);
+        um[root] = max(r1, max(r2, r3));
+        
+        return um[root];
+    }
+private:
+    unordered_map<TreeNode *, int> um;
+    
+    int traverse(TreeNode *root, int val) {
+        if (root == NULL || root->val != val) {
+            return 0;
+        }
+        return 1 + max(traverse(root->left, val), traverse(root->right, val));
+    }
+};

maximum-width-of-binary-tree_1_AC.cpp

@@ -0,0 +1,63 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+#include <algorithm>
+#include <cstdint>
+#include <unordered_map>
+using std::max;
+using std::min;
+using std::unordered_map;
+
+class Solution {
+public:
+    int widthOfBinaryTree(TreeNode* root) {
+        if (root == NULL) {
+            return 0;
+        }
+        
+        traverse(root, 0, 0);
+        
+        int64_t res = 0;
+        int dep;
+        for (auto &p: um_max) {
+            dep = p.first;
+            res = max(res, um_max[dep] - um_min[dep]);
+        }
+        um_max.clear();
+        um_min.clear();
+        
+        return res + 1;
+    }
+private:
+    unordered_map<int, int64_t> um_max, um_min;
+    
+    void traverse(TreeNode *root, int dep, int64_t path) {
+        if (root == NULL) {
+            return;
+        }
+        
+        int64_t cur;
+        if (um_max.find(dep) == um_max.end()) {
+            um_max[dep] = path;
+        } else {
+            cur = um_max[dep];
+            um_max[dep] = max(cur, path);
+        }
+        
+        if (um_min.find(dep) == um_min.end()) {
+            um_min[dep] = path;
+        } else {
+            cur = um_min[dep];
+            um_min[dep] = min(cur, path);
+        }
+        
+        traverse(root->left, dep + 1, path << 1);
+        traverse(root->right, dep + 1, (path << 1) | 1);
+    }
+};

non-decreasing-array_1_AC.cpp

@@ -0,0 +1,29 @@
+// Messy.
+#include <climits>
+
+class Solution {
+public:
+    bool checkPossibility(vector<int>& nums) {
+        int n = nums.size();
+        int cc = 0;
+        int maxval = INT_MIN, old_maxval = INT_MIN;
+        
+        int i;
+        for (i = 0; i < n; ++i) {
+            if (nums[i] >= maxval) {
+                old_maxval = maxval;
+                maxval = nums[i];
+            } else {
+                if (cc > 0) {
+                    return false;
+                }
+                ++cc;
+                if (nums[i] >= old_maxval) {
+                    maxval = nums[i];
+                }
+            }
+        }
+        
+        return true;
+    }
+};