add 6 problems

Author: zhuli19901106

course-schedule-iii_1_AC.cpp

@@ -0,0 +1,42 @@
+#include <algorithm>
+#include <queue>
+#include <vector>
+using std::priority_queue;
+using std::sort;
+using std::vector;
+
+bool comparator(const vector<int> &v1, const vector<int> &v2)
+{
+    return v1[1] < v2[1];
+}
+
+class Solution {
+public:
+    int scheduleCourse(vector<vector<int>>& courses) {
+        auto &vc = courses;
+        sort(vc.begin(), vc.end(), comparator);
+        
+        priority_queue<int> pq;
+        int now = 0;
+        int tp;
+        for (auto &c: vc) {
+            if (now + c[0] <= c[1]) {
+                now += c[0];
+                pq.push(c[0]);
+                continue;
+            }
+            
+            tp = pq.top();
+            if (c[0] >= tp) {
+                continue;
+            }
+            
+            now += c[0] - tp;
+            pq.pop();
+            pq.push(c[0]);
+        }
+        
+        int res = pq.size();
+        return res;
+    }
+};

design-log-storage-system_1_AC.cpp

@@ -0,0 +1,110 @@
+// I think the problem is poorly specified.
+// If it's supposed to be an OO or system design problem, much more have to be said.
+#include <cstdint>
+#include <cstdio>
+#include <map>
+#include <string>
+#include <vector>
+using std::map;
+using std::sscanf;
+using std::string;
+using std::vector;
+
+class LogSystem {
+public:
+    LogSystem() {
+        string legend = "Year:Month:Day:Hour:Minute:Second";
+        vl = split(legend, ':');
+        
+        int n = vl.size();
+        int i;
+        for (i = 0; i < n; ++i) {
+            gi[vl[i]] = i;
+        }
+        
+        int64_t conv[] = {366, 31, 24, 60, 60, 1};
+        n = sizeof(conv) / sizeof(int64_t);
+        for (i = 0; i < n; ++i) {
+            vc.push_back(conv[i]);
+        }
+        
+        n = vc.size();
+        vc_pro.resize(n);
+        vc_pro[n - 1] = vc[n - 1];
+        for (i = n - 2; i >= 0; --i) {
+            vc_pro[i] = vc_pro[i + 1] * vc[i];
+        }
+    }
+    
+    void put(int id, string timestamp) {
+        int64_t ts = getTimestamp(timestamp);
+        logs[ts] = id;
+    }
+    
+    vector<int> retrieve(string s, string e, string gra) {
+        int gra_idx = gi[gra];
+        int64_t g = vc_pro[gra_idx];
+        int64_t ts = getTimestamp(s) / g * g;
+        int64_t te = (getTimestamp(e) / g + 1) * g;
+        
+        map<int64_t, int>::iterator it1, it2;
+        it1 = logs.lower_bound(ts);
+        it2 = logs.lower_bound(te);
+        vector<int> res;
+        for (auto it = it1; it != it2; ++it) {
+            res.push_back(it->second);
+        }
+        
+        return res;
+    }
+private:
+    vector<string> vl;
+    vector<int64_t> vc;
+    vector<int64_t> vc_pro;
+    unordered_map<string, int> gi;
+    map<int64_t, int> logs;
+     
+    vector<string> split(const string &s, char del) {
+        vector<string> vs;
+        string ss;
+        int ls = s.size();
+        int i;
+        for (i = 0; i < ls; ++i) {
+            if (s[i] != del) {
+                ss.push_back(s[i]);
+            } else {
+                if (ss.size() > 0) {
+                    vs.push_back(ss);
+                    ss.clear();
+                }
+            }
+        }
+        if (ss.size() > 0) {
+            vs.push_back(ss);
+            ss.clear();
+        }
+        
+        return vs;
+    }
+    
+    int64_t getTimestamp(const string &s) {
+        vector<string> vs = split(s, ':');
+        int64_t res = 0;
+        int n = vs.size();
+        int i;
+        int64_t val;
+        for (i = 0; i < n; ++i) {
+            sscanf(vs[i].data(), "%lld", &val);
+            res += val * vc_pro[i];
+        }
+        
+        return res;
+    }
+};
+
+/**
+ * Your LogSystem object will be instantiated and called as such:
+ * LogSystem obj = new LogSystem();
+ * obj.put(id,timestamp);
+ * vector<int> param_2 = obj.retrieve(s,e,gra);
+ */

k-inverse-pairs-array_1_AC.cpp

@@ -0,0 +1,54 @@
+// Actually k can be as large as O(n ^ 2).
+// Do some reduction before coding.
+// Try not to worry about boundary, it simplifies the problem.
+#include <algorithm>
+#include <vector>
+using std::max;
+using std::min;
+using std::vector;
+
+class Solution {
+public:
+    int kInversePairs(int n, int iv) {
+        if (iv == 0) {
+            return 1;
+        }
+        
+        const int MOD = 1000000007;
+        vector<vector<int>> dp(2, vector<int>(iv + 1));
+        int m, m0;
+        int i, j;
+        int f, nf;
+        
+        f = 1;
+        nf = !f;
+        dp[nf][0] = 1;
+        m0 = 0;
+        for (i = 1; i < n; ++i) {
+            m = min(i * (i + 1) / 2, iv);
+            for (j = 0; j <= m; ++j) {
+                dp[f][j] = 0;
+            }
+            
+            dp[f][0] = 1;
+            for (j = 1; j <= m; ++j) {
+                dp[f][j] = dp[f][j - 1];
+                if (j <= m0) {
+                    dp[f][j] = (dp[f][j] + dp[nf][j]) % MOD;
+                }
+                if (j - (i + 1) >= 0 && j - (i + 1) <= m0) {
+                    dp[f][j] = (dp[f][j] + MOD - dp[nf][j - (i + 1)]) % MOD;
+                }
+            }
+            m0 = m;
+            
+            f = !f;
+            nf = !f;
+        }
+        
+        int res = dp[nf][iv];
+        dp.clear();
+        
+        return res;
+    }
+};

maximum-product-of-three-numbers_1_AC.cpp

@@ -0,0 +1,49 @@
+#include <algorithm>
+#include <climits>
+#include <vector>
+using std::max;
+using std::min;
+using std::vector;
+
+class Solution {
+public:
+    int maximumProduct(vector<int>& nums) {
+        auto &a = nums;
+        int n = a.size();
+        
+        // v1 for max, v2 for min
+        vector<vector<int>> v1(2, vector<int>(n)), v2(2, vector<int>(n));
+        const int k = 3;
+        
+        int f, nf;
+        int i;
+        f = 1;
+        nf = !f;
+        v1[nf][0] = v2[nf][0] = a[0];
+        for (i = 1; i < n; ++i) {
+            v1[nf][i] = max(v1[nf][i - 1], a[i]);
+            v2[nf][i] = min(v2[nf][i - 1], a[i]);
+        }
+        
+        int p1, p2;
+        int j;
+        for (i = 1; i < k; ++i) {
+            v1[f][i - 1] = INT_MIN;
+            v2[f][i - 1] = INT_MAX;
+            for (j = i; j < n; ++j) {
+                p1 = v1[nf][j - 1] * a[j];
+                p2 = v2[nf][j - 1] * a[j];
+                v1[f][j] = max(v1[f][j - 1], max(p1, p2));
+                v2[f][j] = min(v2[f][j - 1], min(p1, p2));
+            }
+            f = !f;
+            nf = !f;
+        }
+        
+        int res = v1[nf][n - 1];
+        v1.clear();
+        v2.clear();
+        
+        return res;
+    }
+};

smallest-range_1_AC.cpp

@@ -0,0 +1,83 @@
+#include <algorithm>
+#include <utility>
+#include <vector>
+using std::make_pair;
+using std::pair;
+using std::sort;
+using std::vector;
+
+typedef pair<int, int> PII;
+bool comparator(const PII &p1, const PII &p2)
+{
+    if (p1.first != p2.first) {
+        return p1.first < p2.first;
+    }
+    if (p1.second != p2.second) {
+        return p1.second < p2.second;
+    }
+    return false;
+}
+
+class Solution {
+public:
+    vector<int> smallestRange(vector<vector<int>>& nums) {
+        vector<pair<int, int>> v;
+        int nl = nums.size();
+        int i;
+        int len;
+        for (i = 0; i < nl; ++i) {
+            for (auto &x: nums[i]) {
+                v.push_back(make_pair(x, i));
+            }
+        }
+        sort(v.begin(), v.end(), comparator);
+        
+        vector<int> c(nl, 0);
+        int cc = 0;
+        int mi, mj;
+        int j;
+        int r, min_r;
+        int idx;
+        
+        len = v.size();
+        mi = 0;
+        mj = len - 1;
+        min_r = v[mj].first - v[mi].first;
+        i = 0;
+        j = 0;
+        do {
+            while (j < len && cc < nl) {
+                // push j forward until every list is covered
+                idx = v[j].second;
+                if (c[idx] == 0) {
+                    ++cc;
+                }
+                ++c[idx];
+                ++j;
+            }
+            while (cc >= nl) {
+                // push i forward until not every list is covered
+                idx = v[i].second;
+                --c[idx];
+                ++i;
+                if (c[idx] == 0) {
+                    --cc;
+                }
+            }
+            r = v[j - 1].first - v[i - 1].first;
+            if (r < min_r) {
+                mi = i - 1;
+                mj = j - 1;
+                min_r = r;
+            }
+        } while (j < len);
+        
+        vector<int> res(2);
+        res[0] = v[mi].first;
+        res[1] = v[mj].first;
+        v.clear();
+        c.clear();
+        
+        return res;
+    }
+};

sum-of-square-numbers_1_AC.cpp

@@ -0,0 +1,16 @@
+#include <cmath>
+using std::sqrt;
+
+class Solution {
+public:
+    bool judgeSquareSum(int c) {
+        int i, j;
+        for (i = 0; 2LL * i * i <= c; ++i) {
+            j = (int)sqrt(c - i * i);
+            if (j * j == c - i * i) {
+                return true;
+            }
+        }
+        return false;
+    }
+};