add 6 problems

Author: zhuli19901106

add-one-row-to-tree_1_AC.cpp

@@ -0,0 +1,61 @@
+// I don't know why such boring problems should appear one after one on Leetcode.
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+#include <queue>
+#include <utility>
+using std::make_pair;
+using std::pair;
+using std::queue;
+
+class Solution {
+public:
+    TreeNode* addOneRow(TreeNode* root, int v, int d) {
+        if (d <= 0) {
+            return root;
+        }
+        
+        TreeNode *p;
+        if (d == 1) {
+            p = new TreeNode(v);
+            p->left = root;
+            return p;
+        }
+        
+        queue<pair<TreeNode *, int>> q;
+        q.push(make_pair(root, 1));
+        
+        TreeNode *p1, *p2;
+        pair<TreeNode *, int> pr;
+        while (!q.empty()) {
+            pr = q.front();
+            q.pop();
+            
+            p = pr.first;
+            if (pr.second < d - 1) {
+                if (p->left != NULL) {
+                    q.push(make_pair(p->left, pr.second + 1));
+                }
+                if (p->right != NULL) {
+                    q.push(make_pair(p->right, pr.second + 1));
+                }
+            } else {
+                p1 = p->left;
+                p->left = new TreeNode(v);
+                p->left->left = p1;
+                
+                p2 = p->right;
+                p->right = new TreeNode(v);
+                p->right->right = p2;
+            }
+        }
+        
+        return root;
+    }
+};

maximum-distance-in-arrays_1_AC.cpp

@@ -0,0 +1,67 @@
+#include <algorithm>
+#include <functional>
+#include <vector>
+using std::function;
+using std::max;
+using std::min;
+
+typedef bool (*FunComp)(const int &, const int &);
+
+class Solution {
+public:
+    int maxDistance(vector<vector<int>>& arrays) {
+        FunComp lessThan = [](const int &x, const int &y){return x < y;};
+        
+        int na = arrays.size();
+        int n;
+        int i, j;
+        int min_val, max_val;
+        
+        vector<int> vmin(na), vmax(na);
+        for (i = 0; i < na; ++i) {
+            n = arrays[i].size();
+            vmin[i] = vmax[i] = arrays[i][0];
+            for (j = 1; j < n; ++j) {
+                vmin[i] = min(vmin[i], arrays[i][j]);
+                vmax[i] = max(vmax[i], arrays[i][j]);
+            }
+        }
+        
+        vector<int> vmin1;
+        exceptSelf(vmin, vmin1, lessThan);
+        
+        int res = 0;
+        for (i = 0; i < na; ++i) {
+            res = max(res, vmax[i] - vmin1[i]);
+        }
+        
+        return res;
+    }
+private:
+    void exceptSelf(vector<int> &vin, vector<int> &vout, FunComp &cmp) {
+        int n = vin.size();
+        if (n < 2) {
+            vout = vin;
+            return;
+        }
+        
+        vector<int> v1(n), v2(n);
+        int i;
+        
+        v1[0] = vin[0];
+        for (i = 1; i <= n - 1; ++i) {
+            v1[i] = (cmp(vin[i], v1[i - 1]) ? vin[i] : v1[i - 1]);
+        }
+        v2[n - 1] = vin[n - 1];
+        for (i = n - 2; i >= 0; --i) {
+            v2[i] = (cmp(vin[i], v2[i + 1]) ? vin[i] : v2[i + 1]);
+        }
+        
+        vout.resize(n);
+        vout[0] = v2[1];
+        for (i = 1; i < n - 1; ++i) {
+            vout[i] = (cmp(v1[i - 1], v2[i + 1]) ? v1[i - 1] : v2[i + 1]);
+        }
+        vout[n - 1] = v1[n - 2];
+    }
+};

merge-two-binary-trees_1_AC.cpp

@@ -0,0 +1,35 @@
+// I suppose every node of the new tree should be newly allocated, otherwise things sure can be pretty messed up around here.
+/**
+ * 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* mergeTrees(TreeNode* t1, TreeNode* t2) {
+        TreeNode *root = NULL;
+        if (t1 == NULL && t2 == NULL) {
+            return root;
+        }
+        
+        int v1 = (t1 != NULL ? t1->val : 0);
+        int v2 = (t2 != NULL ? t2->val : 0);
+        root = new TreeNode(v1 + v2);
+        
+        TreeNode *p1, *p2;
+
+        p1 = (t1 != NULL ? t1->left : NULL);
+        p2 = (t2 != NULL ? t2->left : NULL);
+        root->left = mergeTrees(p1, p2);
+        
+        p1 = (t1 != NULL ? t1->right : NULL);
+        p2 = (t2 != NULL ? t2->right : NULL);
+        root->right = mergeTrees(p1, p2);
+        
+        return root;
+    }
+};

minimum-factorization_1_AC.cpp

@@ -0,0 +1,76 @@
+// Ugly...
+#include <algorithm>
+#include <climits>
+#include <cstdint>
+#include <string>
+using std::min;
+using std::sort;
+using std::string;
+
+class Solution {
+public:
+    int smallestFactorization(int a) {
+        if (a < 0) {
+            return 0;
+        }
+        if (a <= 9) {
+            return a;
+        }
+        
+        const int NP = 4;
+        const int ND = 10;
+        int p[NP] = {2, 3, 5, 7};
+        int c[NP] = {0, 0, 0, 0};
+        int m[ND][NP] = {
+            {0, 0, 0, 0}, 
+            {0, 0, 0, 0}, 
+            {1, 0, 0, 0}, 
+            {0, 1, 0, 0}, 
+            {2, 0, 0, 0}, 
+            {0, 0, 1, 0}, 
+            {1, 1, 0, 0}, 
+            {0, 0, 0, 1}, 
+            {3, 0, 0, 0}, 
+            {0, 2, 0, 0} 
+        };
+        
+        int i;
+        for (i = 0; i < NP; ++i) {
+            while (a % p[i] == 0) {
+                a /= p[i];
+                ++c[i];
+            }
+        }
+        if (a > 1) {
+            return 0;
+        }
+        
+        string s = "";
+        int n;
+        int j;
+        for (i = 9; i >= 2; --i) {
+            n = INT_MAX;
+            for (j = 0; j < NP; ++j) {
+                if (m[i][j] > 0) {
+                    n = min(n, c[j] / m[i][j]);
+                }
+            }
+            if (n == 0) {
+                continue;
+            }
+            for (j = 0; j < n; ++j) {
+                s.push_back('0' + i);
+            }
+            for (j = 0; j < NP; ++j) {
+                if (m[i][j] > 0) {
+                    c[j] -= n * m[i][j];
+                }
+            }
+        }
+        sort(s.begin(), s.end());
+        
+        int64_t res;
+        sscanf(s.data(), "%lld", &res);
+        return res <= INT_MAX ? res : 0;
+    }
+};

task-scheduler_1_AC.cpp

@@ -0,0 +1,42 @@
+#include <vector>
+using std::vector;
+
+class Solution {
+public:
+    int leastInterval(vector<char>& tasks, int n) {
+        const int N_DICT = 26;
+        vector<int> idx(N_DICT, -(n + 1));
+        vector<int> cnt(N_DICT, 0);
+        int cc = 0;
+        
+        int lt = tasks.size();
+        int i;
+        for (i = 0; i < lt; ++i) {
+            ++cnt[tasks[i] - 'A'];
+            ++cc;
+        }
+        
+        int m = 0;
+        int mc, mi;
+        while (cc > 0) {
+            mc = mi = -1;
+            for (i = 0; i < N_DICT; ++i) {
+                if (m - idx[i] <= n || cnt[i] <= 0) {
+                    continue;
+                }
+                if (cnt[i] > mc) {
+                    mc = cnt[i];
+                    mi = i;
+                }
+            }
+            if (mi != -1) {
+                --cnt[mi];
+                idx[mi] = m;
+                --cc;
+            }
+            ++m;
+        }
+        
+        return m;
+    }
+};

valid-triangle-number_1_AC.cpp

@@ -0,0 +1,33 @@
+#include <algorithm>
+#include <vector>
+using std::sort;
+using std::vector;
+
+class Solution {
+public:
+    int triangleNumber(vector<int>& nums) {
+        auto &a = nums;
+        int n = a.size();
+        
+        sort(a.begin(), a.end());
+        int i, j, k;
+        int sum = 0;
+        
+        i = 0;
+        while (i < n && a[i] <= 0) {
+            ++i;
+        }
+        while (i + 2 < n) {
+            k = i + 2;
+            for (j = i + 1; j + 1 < n; ++j) {
+                while (k < n && a[i] + a[j] > a[k]) {
+                    ++k;
+                }
+                sum += k - (j + 1);
+            }
+            ++i;
+        }
+        
+        return sum;
+    }
+};