8 problems

Author: zhuli19901106

array-nesting_1_AC.cpp

@@ -0,0 +1,39 @@
+// Permutation group.
+#include <algorithm>
+#include <vector>
+using std::max;
+using std::vector;
+
+class Solution {
+public:
+    int arrayNesting(vector<int>& nums) {
+        int n = nums.size();
+        vector<bool> vb(n, false);
+        
+        int i, j;
+        int res;
+        int cnt;
+        
+        res = 0;
+        j = 0;
+        while (j < n) {
+            if (vb[j]) {
+                ++j;
+                continue;
+            }
+            
+            i = j;
+            cnt = 0;
+            while (!vb[i]) {
+                vb[i] = true;
+                i = nums[i];
+                ++cnt;
+            }
+            res = max(res, cnt);
+            ++j;
+        }
+        vb.clear();
+        
+        return res;
+    }
+};

can-place-flowers_1_AC.cpp

@@ -0,0 +1,37 @@
+// If you don't one-shot, you're dead.
+#include <vector>
+using std::vector;
+
+class Solution {
+public:
+    bool canPlaceFlowers(vector<int>& flowerbed, int n) {
+        auto &a = flowerbed;
+        int na = a.size();
+        int i, j;
+        int cnt;
+        int len;
+        
+        cnt = 0;
+        i = 0;
+        while (i < na) {
+            if (a[i] == 1) {
+                ++i;
+                continue;
+            }
+            j = i + 1;
+            while (j < na && a[j] == 0) {
+                ++j;
+            }
+            len = j - i;
+            if (i == 0) {
+                ++len;
+            }
+            if (j == na) {
+                ++len;
+            }
+            cnt += (len - 1) / 2;
+            i = j;
+        }
+        return cnt >= n;
+    }
+};

construct-string-from-binary-tree_1_AC.cpp

@@ -0,0 +1,29 @@
+/**
+ * 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>
+using std::string;
+using std::to_string;
+
+class Solution {
+public:
+    string tree2str(TreeNode* t) {
+        if (t == NULL) {
+            return "";
+        }
+        
+        string res = to_string(t->val);
+        if (t->right != NULL) {
+            res += "(" + tree2str(t->left) + ")(" + tree2str(t->right) + ")";
+        } else if (t->left != NULL) {
+            res += "(" + tree2str(t->left) + ")";
+        }
+        return res;
+    }
+};

find-duplicate-file-in-system_1_AC.cpp

@@ -0,0 +1,88 @@
+#include <string>
+#include <unordered_map>
+#include <vector>
+using std::string;
+using std::unordered_map;
+using std::vector;
+
+class Solution {
+public:
+    vector<vector<string>> findDuplicate(vector<string>& paths) {
+        vector<string> vt;
+        int nt;
+        int i;
+        string path, fname, content;
+        unordered_map<string, vector<string>> um;
+        
+        for (string &s: paths) {
+            tokenize(s, vt);
+            nt = vt.size();
+            path = vt[0];
+            for (i = 1; i < nt; ++i) {
+                parse(vt[i], fname, content);
+                um[content].push_back(path + "/" + fname);
+            }
+        }
+        
+        vector<vector<string>> res;
+        for (auto it = um.begin(); it != um.end(); ++it) {
+            if (it->second.size() > 1) {
+                res.push_back(it->second);
+            }
+        }
+        um.clear();
+        
+        return res;
+    }
+private:
+    void tokenize(const string &s, vector<string> &vt) {
+        int ls = s.size();
+        int cnt_br = 0;
+        int i = 0;
+        
+        string ss = "";
+        vt.clear();
+        while (true) {
+            while (i < ls && s[i] == ' ' && cnt_br == 0) {
+                ++i;
+            }
+            if (i >= ls) {
+                break;
+            }
+            
+            while (i < ls) {
+                if (cnt_br == 0 && s[i] == ' ') {
+                    break;
+                }
+                if (s[i] == '(') {
+                    ++cnt_br;
+                } else if (s[i] == ')') {
+                    --cnt_br;
+                }
+                ss.push_back(s[i]);
+                ++i;
+            }
+            vt.push_back(ss);
+            ss.clear();
+            if (i >= ls) {
+                break;
+            }
+        }
+    }
+    
+    void parse(const string &s, string &fname, string &content) {
+        int ls = s.size();
+        int i;
+        
+        fname = "";
+        content = "";
+        i = 0;
+        while (s[i] != '(') {
+            fname.push_back(s[i++]);
+        }
+        ++i;
+        while (s[i] != ')') {
+            content.push_back(s[i++]);
+        }
+    }
+};

minimum-index-sum-of-two-lists_1_AC.cpp

@@ -0,0 +1,62 @@
+// Lame, dude.
+#include <algorithm>
+#include <string>
+#include <unordered_map>
+#include <vector>
+using std::min;
+using std::string;
+using std::unordered_map;
+using std::vector;
+
+class Solution {
+public:
+    vector<string> findRestaurant(vector<string>& list1, vector<string>& list2) {
+        unordered_map<string, int> um;
+        int n1 = list1.size();
+        int n2 = list2.size();
+        
+        for (string &s: list1) {
+            ++um[s];
+        }
+        for (string &s: list2) {
+            ++um[s];
+        }
+        
+        auto it = um.begin();
+        while (it != um.end()) {
+            if (it->second == 1) {
+                it = um.erase(it);
+            } else {
+                it->second = 0;
+                ++it;
+            }
+        }
+        
+        int i;
+        for (i = 0; i < n1; ++i) {
+            if (um.find(list1[i]) != um.end()) {
+                um[list1[i]] += i;
+            }
+        }
+        for (i = 0; i < n2; ++i) {
+            if (um.find(list2[i]) != um.end()) {
+                um[list2[i]] += i;
+            }
+        }
+        
+        int min_sum = n1 + n2;
+        for (auto &p: um) {
+            min_sum = min(min_sum, p.second);
+        }
+        
+        vector<string> res;
+        for (auto &p: um) {
+            if (p.second == min_sum) {
+                res.push_back(p.first);
+            }
+        }
+        um.clear();
+        
+        return res;
+    }
+};

non-negative-integers-without-consecutive-ones_1_AC.cpp

@@ -0,0 +1,58 @@
+// That was an ugly one.
+#include <string>
+#include <vector>
+using std::string;
+using std::vector;
+
+class Solution {
+public:
+    int findIntegers(int num) {
+        if (num <= 1) {
+            return num + 1;
+        }
+        
+        vector<int> v;
+        v.push_back(1);
+        v.push_back(1);
+        v.push_back(1);
+        
+        int i;
+        for (i = 3; i <= 31; ++i) {
+            v.push_back(v[i - 1] + v[i - 2]);
+        }
+        
+        string s = "";
+        while (num > 0) {
+            s.push_back('0' + (num & 1));
+            num >>= 1;
+        }
+        
+        int ls = s.size();
+        int j;
+        i = ls - 1;
+        while (i > 0) {
+            if (s[i] == '1' && s[i - 1] == '1') {
+                s[i - 1] = '0';
+                j = i - 2;
+                while (j >= 0) {
+                    if (s[j] == '0') {
+                        s[j] = '1';
+                    }
+                    --j;
+                }
+            }
+            --i;
+        }
+        
+        int res = 1;
+        i = ls;
+        while (i > 0) {
+            if (s[i - 1] == '1') {
+                res += v[i + 1];
+            }
+            --i;
+        }
+        
+        return res;
+    }
+};

range-addition-ii_1_AC.cpp

@@ -0,0 +1,23 @@
+// Brainteaser
+#include <algorithm>
+#include <vector>
+using std::min;
+using std::vector;
+
+class Solution {
+public:
+    int maxCount(int m, int n, vector<vector<int>>& ops) {
+        int rm, rn;
+        
+        rm = m;
+        rn = n;
+        for (auto &op: ops) {
+            if (op[0] == 0 || op[1] == 0) {
+                continue;
+            }
+            rm = min(rm, op[0]);
+            rn = min(rn, op[1]);
+        }
+        return rm * rn;
+    }
+};

tag-validator_1_AC.cpp

@@ -0,0 +1,34 @@
+// https://discuss.leetcode.com/topic/91381/short-python-accepted-but-not-sure-if-correct
+// I don't know how I'm gonna deal with it without using RE matching.
+// Don't you think this kind of problems are a bit too complicated?
+// Besides, C++ regex is slow.
+#include <regex>
+#include <string>
+using std::regex;
+using std::regex_replace;
+using std::string;
+
+class Solution {
+public:
+    bool isValid(string code) {
+        if (code == "t") {
+            return false;
+        }
+        
+        regex rt("<([A-Z]{1,9})>[^<]*</\\1>");
+        regex rc("<!\\[CDATA\\[.*?\\]\\]>");
+        string code1;
+        
+        code = regex_replace(code, rc, "c");
+        while (true) {
+            code1 = regex_replace(code, rt, "t");
+            if (code != code1) {
+                code = code1;
+            } else {
+                break;
+            }
+        }
+        
+        return code == "t";
+    }
+};