Weekly Contest 98

Author: MaskRay

boats-to-save-people.cc

@@ -0,0 +1,12 @@
+// Boats to Save People
+class Solution {
+public:
+  int numRescueBoats(vector<int>& a, int limit) {
+    int i = 0, j = a.size();
+    sort(a.begin(), a.end());
+    while (i < j)
+      if (i < --j && a[i]+a[j] <= limit)
+        i++;
+    return a.size()-i;
+  }
+};

construct-binary-tree-from-preorder-and-postorder-traversal.cc

@@ -0,0 +1,20 @@
+// Construct Binary Tree from Preorder and Postorder Traversal
+class Solution {
+  vector<int> pre, post;
+  TreeNode *f(int i, int j, int n) {
+    if (!n) return 0;
+    auto* r = new TreeNode(pre[i]);
+    if (n > 1) {
+      int k = find(post.begin()+j, post.begin()+j+n, pre[i+1])-post.begin()-j+1;
+      r->left = f(i+1, j, k);
+      r->right = f(i+k+1, j+k, n-k-1);
+    }
+    return r;
+  }
+public:
+  TreeNode* constructFromPrePost(vector<int>& pre, vector<int>& post) {
+    this->pre = pre;
+    this->post = post;
+    return f(0, 0, pre.size());
+  }
+};

decoded-string-at-index.cc

@@ -0,0 +1,26 @@
+// Decoded String at Index
+#define ALL(x) (x).begin(), (x).end()
+#define FOR(i, a, b) for (remove_cv<remove_reference<decltype(b)>::type>::type i = (a); i < (b); i++)
+#define REP(i, n) FOR(i, 0, n)
+
+class Solution {
+public:
+  string decodeAtIndex(string S, int K) {
+    long n = S.size(), g = 0;
+    vector<long> a(n), b(n);
+    REP(i, n)
+      if (isalpha(S[i]))
+        a[i] = ++g;
+      else {
+        b[i] = g;
+        a[i] = g *= (S[i]-'0');
+      }
+    for (K--; K; ) {
+      long i = upper_bound(ALL(a), K) - a.begin();
+      if (!b[i])
+        string(1, S[i]);
+      K %= b[i];
+    }
+    return string(1, S[0]);
+  }
+};

fair-candy-swap.cc

@@ -0,0 +1,18 @@
+// Fair Candy Swap
+#define ALL(x) (x).begin(), (x).end()
+
+class Solution {
+public:
+  vector<int> fairCandySwap(vector<int>& A, vector<int>& B) {
+    int d = accumulate(ALL(B), 0) - accumulate(ALL(A), 0) >> 1;
+    unordered_set<int> BB(ALL(B));
+    vector<int> r;
+    for (int a: A)
+      if (BB.count(a+d)) {
+        r.push_back(a);
+        r.push_back(a+d);
+        break;
+      }
+    return r;
+  }
+};

find-and-replace-pattern.cc

@@ -0,0 +1,23 @@
+// Find and Replace Pattern
+class Solution {
+  string f(string p) {
+    int x[26], i =0;
+    fill_n(x, 26, -1);
+    for (char &c : p) {
+      if (x[c -= 'a'] < 0)
+        x[c] = i++;
+      c = x[c];
+    }
+    return p;
+  }
+
+public:
+  vector<string> findAndReplacePattern(vector<string>& words, string pattern) {
+    vector<string> r;
+    pattern = f(pattern);
+    for (auto &word : words)
+      if (f(word) == pattern)
+        r.push_back(word);
+    return r;
+  }
+};

projection-area-of-3d-shapes.cc

@@ -0,0 +1,20 @@
+// Projection Area of 3D Shapes
+#define ALL(x) (x).begin(), (x).end()
+#define FOR(i, a, b) for (remove_cv<remove_reference<decltype(b)>::type>::type i = (a); i < (b); i++)
+#define REP(i, n) FOR(i, 0, n)
+
+class Solution {
+public:
+  int projectionArea(vector<vector<int>> &grid) {
+    int ans = 0;
+    for (auto &r: grid)
+      ans += r.size()-count(ALL(r), 0) + *max_element(ALL(r));
+    REP(j, grid[0].size()) {
+      int t = 0;
+      REP(i, grid.size())
+        t = max(t, grid[i][j]);
+      ans += t;
+    }
+    return ans;
+  }
+};

reachable-nodes-in-subdivided-graph.cc

@@ -0,0 +1,35 @@
+// Reachable Nodes In Subdivided Graph
+class Solution {
+public:
+  int reachableNodes(vector<vector<int>>& edges, int M, int N) {
+    vector<vector<pair<int,int>>> g(N);
+    vector<int> d(N, M+1);
+    priority_queue<pair<int,int>, vector<pair<int,int>>, greater<pair<int,int>>> pq;
+    vector<char> vis(N);
+    int ans = 0;
+    for (auto &r : edges) {
+      g[r[0]].emplace_back(r[1], r[2] + 1);
+      g[r[1]].emplace_back(r[0], r[2] + 1);
+    }
+    pq.emplace(d[0] = 0, 0);
+    while (pq.size()) {
+      int u = pq.top().second;
+      pq.pop();
+      if (vis[u]) continue;
+      vis[u] = 1;
+      ans++;
+      for (auto &e : g[u])
+        if (d[u] + e.second < d[e.first])
+          pq.emplace(d[e.first] = d[u]+e.second, e.first);
+    }
+    for (auto &r : edges) {
+      int u = r[0], v = r[1], w = r[2];
+      if (d[u] > d[v])
+        swap(u, v);
+      int tu = M-d[u];
+      if (tu > 0)
+        ans += min(tu + max(M-d[v], 0), w);
+    }
+    return ans;
+  }
+};

sum-of-subsequence-widths.cc

@@ -0,0 +1,15 @@
+// Sum of Subsequence Widths
+class Solution {
+public:
+  int sumSubseqWidths(vector<int>& A) {
+    const int MOD = 1000000007;
+    sort(A.begin(), A.end());
+    long x = 0, c = 0, r = 0;
+    for (int a: A) {
+      r += a*c-x;
+      c = (c*2+1)%MOD;
+      (x = x*2+a) %= MOD;
+    }
+    return (r%MOD+MOD)%MOD;
+  }
+};