misc

Author: MaskRay

3sum-closest.cc

@@ -5,7 +5,7 @@ class Solution {
 public:
   int threeSumClosest(vector<int> &a, int target) {
     int n = a.size(), opt = INT_MAX, opts;
-    sort(a.begin(), a.end());
+    ranges::sort(a);
     REP(i, n) {
       int j = i+1, k = n-1, t = target-a[i];
       while (j < k) {

3sum.cc

@@ -1,24 +1,22 @@
 // 3Sum
 class Solution {
 public:
-  vector<vector<int> > threeSum(vector<int> &a) {
+  vector<vector<int>> threeSum(vector<int>& a) {
     int n = a.size();
     vector<vector<int>> r;
-    sort(a.begin(), a.end());
+    ranges::sort(a);
     for (int i = 0; i < n; ) {
-      int j = i+1, k = n-1, s = -a[i], old;
+      int j = i+1, k = n-1, s = -a[i];
       while (j < k) {
-        if (a[j]+a[k] < s) j++;
-        else if (a[j]+a[k] > s) k--;
-        else {
-          r.push_back(vector<int>{a[i], a[j], a[k]});
-          old = a[j];
-          while (++j < k && a[j] == old);
+        if (a[j]+a[k] > s)
           k--;
+        else {
+          if (a[j]+a[k] == s)
+            r.push_back({a[i], a[j], a[k]});
+          while (++j < k && a[j] == a[j-1]);
         }
       }
-      old = a[i];
-      while (++i < n && a[i] == old);
+      while (++i < n && a[i] == a[i-1]);
     }
     return r;
   }

4sum.cc

@@ -1,52 +1,41 @@
 // 4Sum
 class Solution {
 public:
-  vector<vector<int> > fourSum(vector<int> &a, int target) {
+  vector<vector<int>> fourSum(vector<int> &a, int target) {
     int n = a.size(), old;
+    const long tar = target;
     multimap<int, int> m;
     vector<vector<int>> r;
     sort(a.begin(), a.end());
     for (int i = 0; i < n; ) {
       // a <= b < c <= d
       for (int j = i+1; j < n; ) {
-        int t = target-a[i]-a[j];
+        long t = tar-a[i]-a[j];
         auto it = m.equal_range(t);
-        for (; it.first != it.second; ++it.first) {
-          vector<int> b{it.first->second, t-it.first->second, a[i], a[j]};
-          r.push_back(b);
-        }
-        old = a[j];
-        while (++j < n && a[j] == old);
+        for (; it.first != it.second; ++it.first)
+          r.push_back({it.first->second, (int)t-it.first->second, a[i], a[j]});
+        while (++j < n && a[j] == a[j-1]);
       }
       // a < b = b <= c
       if (i+1 < n && a[i] == a[i+1]) {
         for (int j = i+2; j < n; ) {
-          int t = target-a[i]*2-a[j];
-          auto it = lower_bound(a.begin(), a.begin()+i, t);
-          if (it != a.begin()+i && *it == t) {
-            vector<int> b{*it, a[i], a[i], a[j]};
-            r.push_back(b);
-          }
-          old = a[j];
-          while (++j < n && a[j] == old);
+          long t = tar-a[i]*2-a[j];
+          if (binary_search(a.begin(), a.begin()+i, t))
+            r.push_back({int(t), a[i], a[i], a[j]});
+          while (++j < n && a[j] == a[j-1]);
         }
       }
       // a = a = a <= b
       if (i+2 < n && a[i] == a[i+2]) {
-        int t = target-a[i]*3;
-        auto it = lower_bound(a.begin()+i+3, a.end(), t);
-        if (it != a.end() && *it == t) {
-          vector<int> b{a[i], a[i], a[i], t};
-          r.push_back(b);
-        }
+        long t = tar-a[i]*3L;
+        if (binary_search(a.begin()+i+3, a.end(), t))
+          r.push_back({a[i], a[i], a[i], int(t)});
       }
-      old = a[i];
-      while (i+1 < n && a[i+1] == old)
+      while (i+1 < n && a[i+1] == a[i])
         i++;
       for (int j = 0; j < i; ) {
         m.insert(make_pair(a[j]+a[i], a[j]));
-        old = a[j];
-        while (++j < n && a[j] == old);
+        while (++j < n && a[j] == a[j-1]);
       }
       i++;
     }

count-the-number-of-good-nodes.cc

@@ -0,0 +1,30 @@
+// Count the Number of Good Nodes
+class Solution {
+  int n = 0, res = 0;
+  vector<vector<int>> es;
+  int dfs(int u, int p) {
+    int s = 1, t0 = 0, ok = 1;
+    for (int v : es[u])
+      if (v != p) {
+        int t = dfs(v, u);
+        s += t;
+        if (t0 && t != t0)
+          ok = 0;
+        t0 = t;
+      }
+    res += ok;
+    return s;
+  }
+public:
+  int countGoodNodes(vector<vector<int>>& edges) {
+    for (auto &e : edges)
+      n = max(n, max(e[0], e[1])+1);
+    es.resize(n);
+    for (auto &e : edges) {
+      es[e[0]].push_back(e[1]);
+      es[e[1]].push_back(e[0]);
+    }
+    dfs(0, -1);
+    return res;
+  }
+};

divide-two-integers.cc

@@ -15,6 +15,8 @@ class Solution {
         p -= q;
         r += 1 << c;
       }
-    return neg ? -r : r;
+    if (r == INT_MIN && !neg)
+      return INT_MAX;
+    return neg ? -(unsigned)r : r;
   }
 };

find-the-count-of-monotonic-pairs-ii.cc

@@ -0,0 +1,32 @@
+// Find the Count of Monotonic Pairs II
+#define FOR(i, a, b) for (int i = (a); i < (b); i++)
+#define REP(i, n) for (int i = 0; i < (n); i++)
+
+const int M = 1001, P = 1000000007;
+
+class Solution {
+public:
+  int countOfPairs(vector<int>& a) {
+    int n = a.size();
+    vector<int> s0(M), s1(M);
+    fill_n(&s0[0], a[0]+1, 1);
+    REP(i, n-1) {
+      REP(j, a[i]+1) {
+        if (!s0[j])
+          continue;
+        int lo = max(j, a[i+1]-a[i]+j), hi = a[i+1]+1;
+        if (lo < hi) {
+          (s1[lo] += s0[j]) %= P;
+          if (hi < M) (s1[hi] -= s0[j]) %= P;
+        }
+      }
+      s0[0] = exchange(s1[0], 0);
+      FOR(j, 1, M)
+        s0[j] = (s0[j-1] + exchange(s1[j], 0))%P;
+    }
+    int ret = 0;
+    REP(j, M)
+      (ret += s0[j]) %= P;
+    return (ret%P+P)%P;
+  }
+};

find-the-count-of-monotonic-pairs.cc

@@ -0,0 +1,32 @@
+// Find the Count of Monotonic Pairs I
+#define FOR(i, a, b) for (int i = (a); i < (b); i++)
+#define REP(i, n) for (int i = 0; i < (n); i++)
+
+const int M = 1001, P = 1000000007;
+
+class Solution {
+public:
+  int countOfPairs(vector<int>& a) {
+    int n = a.size();
+    vector<int> s0(M), s1(M);
+    fill_n(&s0[0], a[0]+1, 1);
+    REP(i, n-1) {
+      REP(j, a[i]+1) {
+        if (!s0[j])
+          continue;
+        int lo = max(j, a[i+1]-a[i]+j), hi = a[i+1]+1;
+        if (lo < hi) {
+          (s1[lo] += s0[j]) %= P;
+          if (hi < M) (s1[hi] -= s0[j]) %= P;
+        }
+      }
+      s0[0] = exchange(s1[0], 0);
+      FOR(j, 1, M)
+        s0[j] = (s0[j-1] + exchange(s1[j], 0))%P;
+    }
+    int ret = 0;
+    REP(j, M)
+      (ret += s0[j]) %= P;
+    return (ret%P+P)%P;
+  }
+};

find-the-index-of-the-first-occurrence-in-a-string.cc

@@ -0,0 +1,10 @@
+// Find the Index of the First Occurrence in a String
+class Solution {
+public:
+  int strStr(string haystack, string needle) {
+    for (int i = 0; i <= haystack.size()-needle.size(); i++)
+      if (!haystack.compare(i, needle.size(), needle))
+        return i;
+    return -1;
+  }
+};

find-the-value-of-the-partition.cc

@@ -0,0 +1,14 @@
+// Find the Value of the Partition
+#define ALL(x) (x).begin(), (x).end()
+#define REP(i, n) for (int i = 0; i < (n); i++)
+
+class Solution {
+public:
+  int findValueOfPartition(vector<int>& a) {
+    int s = INT_MAX;
+    sort(ALL(a));
+    REP(i, a.size()-1)
+      s = min(s, a[i+1]-a[i]);
+    return s;
+  }
+};

finding-mk-average.cc

@@ -216,8 +216,9 @@ struct Treap { int lc, rc, pri, size, key; long sum; };
 unique_ptr<Treap[]> tr;
 
 void mconcat(int x) {
-  tr[x].size = tr[tr[x].lc].size + 1 + tr[tr[x].rc].size;
-  tr[x].sum = tr[tr[x].lc].sum + tr[x].key + tr[tr[x].rc].sum;
+  int l = tr[x].lc, r = tr[x].rc;
+  tr[x].size = tr[l].size + 1 + tr[r].size;
+  tr[x].sum = tr[l].sum + tr[x].key + tr[r].sum;
 }
 
 void split_by_rank(int x, int k, int &l, int &r) {
@@ -235,7 +236,7 @@ void split_by_rank(int x, int k, int &l, int &r) {
 
 void split_by_key(int x, int key, int &l, int &r) {
   if (!x) return void(l = r = 0);
-  if (key <= tr[x].key) {
+  if (key < tr[x].key) {
     r = x;
     split_by_key(tr[x].lc, key, l, tr[x].lc);
   } else {
@@ -247,52 +248,51 @@ void split_by_key(int x, int key, int &l, int &r) {
 
 int join(int x, int y) {
   if (!x || !y) return x^y;
-  if (tr[x].pri < tr[y].pri) {
+  if (tr[x].pri < tr[y].pri)
     tr[x].rc = join(tr[x].rc, y);
-    mconcat(x);
-    return x;
-  } else {
+  else {
     tr[y].lc = join(x, tr[y].lc);
-    mconcat(y);
-    return y;
+    x = y;
   }
+  mconcat(x);
+  return x;
 }
 }
 
 class MKAverage {
-  int m, k, id, root = 0;
+  int m, k, root = 0;
   deque<int> q;
-
-  int erase(int x, int k) {
-    if (k == tr[x].key) {
-      int ret = join(tr[x].lc, tr[x].rc);
-      id = x;
+  int erase(int &x, int key) {
+    if (tr[x].key == key) {
+      int ret = x;
+      x = join(tr[x].lc, tr[x].rc);
       return ret;
     }
-    if (k < tr[x].key)
-      tr[x].lc = erase(tr[x].lc, k);
+    int id;
+    if (key < tr[x].key)
+      id = erase(tr[x].lc, key);
     else
-      tr[x].rc = erase(tr[x].rc, k);
+      id = erase(tr[x].rc, key);
     mconcat(x);
-    return x;
+    return id;
   }
 public:
-  MKAverage(int m, int k) : m(m), k(k) { tr = make_unique<Treap[]>(m+1); }
+  MKAverage(int m, int k) : m(m), k(k) {
+    tr = make_unique<Treap[]>(m+1);
+  }
 
   void addElement(int num) {
-    int l, r;
-    id = q.size()+1;
+    int l, r, id = q.size()+1;
     if (q.size() == m) {
-      int key = q.front();
+      id = erase(root, q.front());
       q.pop_front();
-      root = erase(root, key);
     }
     tr[id].lc = tr[id].rc = 0;
     tr[id].pri = xor32();
     tr[id].size = 1;
     tr[id].key = tr[id].sum = num;
     split_by_key(root, num, l, r);
-    root = join(l, join(id, r));
+    root = join(join(l, id), r);
     q.push_back(num);
   }
 

median-of-two-sorted-arrays.cc

@@ -1,17 +1,17 @@
 // Median of Two Sorted Arrays
 class Solution {
 public:
-    double findMedianSortedArrays(vector<int> &a, vector<int> &b) {
-      int m = a.size(), n = b.size(), i = 0, j = 0, k = m+n-1 >> 1;
-      while (k > 0) {
-        int p = k-1 >> 1;
-        if (j+p >= n || i+p < m && a[i+p] < b[j+p])
-          i += p+1;
-        else
-          j += p+1;
-        k -= p+1;
-      }
-      int s = j >= n || i < m && a[i] < b[j] ? a[i++] : b[j++];
-      return m+n & 1 ? s : (j >= n || i < m && a[i] < b[j] ? s+a[i] : s+b[j]) * 0.5;
+  double findMedianSortedArrays(vector<int> &a, vector<int> &b) {
+    int m = a.size(), n = b.size(), i = 0, j = 0, k = m+n-1 >> 1;
+    while (k > 0) {
+      int p = k-1 >> 1;
+      if (j+p >= n || i+p < m && a[i+p] < b[j+p])
+        i += p+1;
+      else
+        j += p+1;
+      k -= p+1;
     }
+    int s = j >= n || i < m && a[i] < b[j] ? a[i++] : b[j++];
+    return m+n & 1 ? s : (j >= n || i < m && a[i] < b[j] ? s+a[i] : s+b[j]) * 0.5;
+  }
 };