Weekly Contest 237 and misc

Author: MaskRay

bricks-falling-when-hit.cc

@@ -0,0 +1,44 @@
+// Bricks Falling When Hit
+#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 {
+  static constexpr int dx[] = {-1,0,1,0}, dy[] = {0,1,0,-1};
+  int m, n, num = 0;
+public:
+  void dfs(vector<vector<int>> &g, int x, int y) {
+    g[x][y] = 2;
+    num++;
+    REP(i, 4) {
+      unsigned x1 = x+dx[i], y1 = y+dy[i];
+      if (x1 < m && y1 < n && g[x1][y1] == 1)
+        dfs(g, x1, y1);
+    }
+  }
+  vector<int> hitBricks(vector<vector<int>> &g, vector<vector<int>> &hits) {
+    vector<int> ans(hits.size());
+    m = g.size();
+    n = g[0].size();
+    for (auto &h: hits)
+      g[h[0]][h[1]]--;
+    REP(i, n)
+      if (g[0][i] == 1)
+        dfs(g, 0, i);
+    for (int i = hits.size(); i--; ) {
+      int old = num;
+      int x = hits[i][0], y = hits[i][1];
+      if (g[x][y]++) continue;
+      bool f = !x;
+      REP(d, 4) {
+        unsigned x1 = x+dx[d], y1 = y+dy[d];
+        if (x1 < m && y1 < n && g[x1][y1] == 2)
+          f = true;
+      }
+      if (f) {
+        dfs(g, x, y);
+        ans[i] = num-old-1;
+      }
+    }
+    return ans;
+  }
+};

check-if-the-sentence-is-pangram.cc

@@ -0,0 +1,11 @@
+// Check if the Sentence Is Pangram
+class Solution {
+public:
+  bool checkIfPangram(string sentence) {
+    int s[26] = {}, cnt = 0;
+    for (char c: sentence)
+      if (!s[c-'a']++)
+        cnt++;
+    return cnt == 26;
+  }
+};

find-xor-sum-of-all-pairs-bitwise-and.cc

@@ -0,0 +1,8 @@
+// Find XOR Sum of All Pairs Bitwise AND
+class Solution {
+public:
+  int getXORSum(vector<int>& a, vector<int>& b) {
+    return accumulate(a.begin(), a.end(), 0, bit_xor()) &
+      accumulate(b.begin(), b.end(), 0, bit_xor());
+  }
+};

max-value-of-equation.cc

@@ -0,0 +1,22 @@
+// Max Value of Equation
+/// monotonicity
+#define ALL(x) (x).begin(), (x).end()
+
+class Solution {
+public:
+  int findMaxValueOfEquation(vector<vector<int>>& points, int k) {
+    deque<pair<int, int>> q;
+    int ans = INT_MIN;
+    for (auto &p: points) {
+      int x = p[0], y = p[1];
+      while (q.size() && x-q[0].first > k)
+        q.pop_front();
+      if (q.size())
+        ans = max(ans, x+y+q[0].second);
+      while (q.size() && q.back().second < y-x)
+        q.pop_back();
+      q.emplace_back(x, y-x);
+    }
+    return ans;
+  }
+};

maximum-ice-cream-bars.cc

@@ -0,0 +1,14 @@
+// Maximum Ice Cream Bars
+#define ALL(x) (x).begin(), (x).end()
+
+class Solution {
+public:
+  int maxIceCream(vector<int>& a, int coins) {
+    sort(ALL(a));
+    int s = 0;
+    for (int x: a)
+      if (coins >= x)
+        coins -= x, s++;
+    return s;
+  }
+};

minimum-number-of-operations-to-make-string-sorted.cc

@@ -0,0 +1,34 @@
+// Minimum Number of Operations to Make String Sorted
+#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)
+#define ROF(i, a, b) for (remove_cv<remove_reference<decltype(b)>::type>::type i = (b); --i >= (a); )
+
+class Solution {
+  static const int MOD = 1000000007;
+  int inv(int x) {
+    long s = 1;
+    for (; x > 1; x = MOD%x)
+      s = s*(MOD-MOD/x)%MOD;
+    return s;
+  }
+public:
+  int makeStringSorted(string s) {
+    int n = s.size(), cnt[26] = {};
+    vector<int> fac(n+1), invfac(n+1);
+    fac[0] = invfac[0] = 1;
+    FOR(i, 1, n+1) {
+      fac[i] = long(fac[i-1])*i%MOD;
+      invfac[i] = inv(fac[i]);
+    }
+    long ans = 0;
+    ROF(i, 0, n) {
+      int ch = s[i]-'a';
+      long c = accumulate(cnt, cnt+ch, 0L)*fac[n-1-i]%MOD;
+      cnt[ch]++;
+      REP(j, 26)
+        c = c*invfac[cnt[j]]%MOD;
+      ans = (ans+c)%MOD;
+    }
+    return ans;
+  }
+};

minimum-number-of-operations-to-make-string-sorted.rs

@@ -0,0 +1,34 @@
+// Minimum Number of Operations to Make String Sorted
+const MOD: i64 = 1000000007;
+
+impl Solution {
+    fn inv(mut x: i32) -> i32 {
+        let mut s = 1;
+        while x > 1 {
+            s = s * (MOD-MOD/x as i64) % MOD;
+            x = MOD as i32 % x;
+        }
+        return s as i32;
+    }
+    pub fn make_string_sorted(s: String) -> i32 {
+        let n = s.len();
+        let mut fac = vec![1; n+1];
+        let mut invfac = vec![1; n+1];
+        for i in 1..=n {
+            fac[i] = (fac[i-1] as i64 * i as i64 % MOD) as i32;
+            invfac[i] = Self::inv(fac[i]);
+        }
+        let mut cnt: Vec<usize> = vec![0; 26];
+        let mut ans = 0;
+        for i in (0..n).rev() {
+            let ch = (s.as_bytes()[i]-b'a') as usize;
+            let mut c = cnt[0..ch].iter().sum::<usize>() as i64 * fac[n-1-i] as i64 % MOD;
+            cnt[ch] += 1;
+            for j in 0..26 {
+                c = c * invfac[cnt[j]] as i64 % MOD;
+            }
+            ans = (ans+c)%MOD;
+        }
+        ans as i32
+    }
+}

next-permutation.cc

@@ -4,7 +4,6 @@
 class Solution {
 public:
   void nextPermutation(vector<int> &num) {
-    if (num.size() <= 1) return;
     ROF(i, 0, num.size()-1)
       if (num[i] < num[i+1]) {
         int j = num.size();

permutation-sequence.rs

@@ -0,0 +1,15 @@
+impl Solution {
+    pub fn get_permutation(n: i32, mut k: i32) -> String {
+        let f = [1,1,2,6,24,120,720,5040,40320];
+        let mut a = 0x987654321u64;
+        k -= 1;
+        let mut s = String::new();
+        for i in (0..n as usize).rev() {
+            let t = k/f[i];
+            k %= f[i];
+            s.push(std::char::from_digit((a >> 4*t & 15) as u32, 10).unwrap());
+            a = a&(1u64<<4*t)-1 | a>>4*(t+1)<<4*t;
+        }
+        s
+    }
+}

single-threaded-cpu.cc

@@ -0,0 +1,38 @@
+// Single-Threaded CPU
+#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)
+
+struct Node {
+  int bgn, dur, idx;
+  bool operator>(const Node &r) const {
+    return tie(dur, idx) > tie(r.dur, r.idx);
+  }
+};
+
+class Solution {
+public:
+  vector<int> getOrder(vector<vector<int>>& tasks) {
+    vector<Node> a;
+    REP(i, tasks.size())
+      a.push_back(Node{tasks[i][0], tasks[i][1], (int)i});
+    sort(ALL(a), [](const Node &l, const Node &r) {
+      return l.bgn != r.bgn ? l.bgn < r.bgn : l.idx < r.idx;
+    });
+    priority_queue<Node, vector<Node>, greater<Node>> b;
+    int n = a.size(), i = 0;
+    long tick = 0;
+    vector<int> ans;
+    while (i < n || b.size()) {
+      if (i < n && a[i].bgn <= tick)
+        b.push(a[i++]);
+      else if (!b.empty()) {
+        ans.push_back(b.top().idx);
+        tick += b.top().dur;
+        b.pop();
+      } else
+        tick = a[i].bgn;
+    }
+    return ans;
+  }
+};