7.19

check-divisibility-by-digit-sum-and-product/answer.cpp

@@ -0,0 +1,11 @@
+class Solution {
+public:
+  bool checkDivisibility(int n) {
+    int p = 1, sum = 0;
+    for (int m = n; m > 0; m /= 10) {
+      sum += m % 10;
+      p *= m % 10;
+    }
+    return n % (sum + p) == 0;
+  }
+};

count-islands-with-total-value-divisible-by-k/answer.cpp

@@ -0,0 +1,34 @@
+class Solution {
+public:
+  int countIslands(vector<vector<int>> &a, int k) {
+    int n = a.size(), m = a[0].size();
+    vector<vector<bool>> vis(n, vector<bool>(m, 0));
+
+    function<void(int, int, int &)> dfs = [&](int x, int y, int &mod) {
+      vis[x][y] = 1;
+      assert(a[x][y] > 0);
+      mod = (mod + a[x][y]) % k;
+      if (y + 1 < m and !vis[x][y + 1] and a[x][y + 1] > 0)
+        dfs(x, y + 1, mod);
+      if (y > 0 and !vis[x][y - 1] and a[x][y - 1] > 0)
+        dfs(x, y - 1, mod);
+      if (x + 1 < n and !vis[x + 1][y] and a[x + 1][y] > 0)
+        dfs(x + 1, y, mod);
+      if (x > 0 and !vis[x - 1][y] and a[x - 1][y] > 0)
+        dfs(x - 1, y, mod);
+    };
+
+    int ans = 0;
+    for (int i = 0; i < n; i++) {
+      for (int j = 0; j < m; j++) {
+        if (!vis[i][j] and a[i][j] > 0) {
+          int mod = 0;
+          dfs(i, j, mod);
+          if (mod == 0)
+            ans++;
+        }
+      }
+    }
+    return ans;
+  }
+};

count-number-of-trapezoids-i/answer.cpp

@@ -0,0 +1,147 @@
+template <int MOD_> struct modnum {
+  typedef long long int64;
+
+  static constexpr int MOD = MOD_;
+  static_assert(MOD_ > 0, "MOD must be positive");
+
+private:
+  int v;
+  static int minv(int a, int m) {
+    a %= m;
+    assert(a);
+    return a == 1 ? 1 : int(m - int64(minv(m, a)) * int64(m) / a);
+  }
+
+public:
+  modnum() : v(0){};
+  modnum(int64 v_) : v(int(v_ % MOD)) {
+    if (v < 0)
+      v += MOD;
+  }
+  explicit operator int() const { return v; }
+  friend std::ostream &operator<<(std::ostream &out, const modnum &n) {
+    return out << int(n);
+  }
+  friend std::istream &operator>>(std::istream &in, modnum &n) {
+    int64 v_;
+    in >> v_;
+    n = modnum(v_);
+    return in;
+  }
+  friend bool operator==(const modnum &a, const modnum &b) {
+    return a.v == b.v;
+  }
+  friend bool operator!=(const modnum &a, const modnum &b) {
+    return a.v != b.v;
+  }
+
+  modnum inv() const {
+    modnum res;
+    res.v = minv(v, MOD);
+    return res;
+  }
+  friend modnum inv(const modnum &m) { return m.inv(); }
+  modnum neg() const {
+    modnum res;
+    res.v = v ? MOD - v : 0;
+    return res;
+  }
+  friend modnum neg(const modnum &m) { return m.neg(); }
+
+  modnum pow(int64 m) {
+    assert(m >= 0);
+    modnum res = 1, p = modnum(*this);
+    while (m) {
+      if (m & 1)
+        res *= p;
+      p *= p;
+      m /= 2;
+    }
+    return res;
+  }
+
+  modnum operator-() const { return neg(); }
+  modnum operator+() const { return modnum(*this); }
+
+  modnum &operator++() {
+    ++v;
+    if (v == MOD)
+      v = 0;
+    return *this;
+  }
+  modnum &operator--() {
+    if (v == 0)
+      v = MOD;
+    --v;
+    return *this;
+  }
+  modnum &operator+=(const modnum &o) {
+    v += o.v;
+    if (v >= MOD)
+      v -= MOD;
+    return *this;
+  }
+  modnum &operator-=(const modnum &o) {
+    v -= o.v;
+    if (v < 0)
+      v += MOD;
+    return *this;
+  }
+  modnum &operator*=(const modnum &o) {
+    v = int(int64(v) * int64(o.v) % MOD);
+    return *this;
+  }
+  modnum &operator/=(const modnum &o) { return *this *= o.inv(); }
+
+  friend modnum operator++(modnum &a, int) {
+    modnum r = a;
+    ++a;
+    return r;
+  }
+  friend modnum operator--(modnum &a, int) {
+    modnum r = a;
+    --a;
+    return r;
+  }
+  friend modnum operator+(const modnum &a, const modnum &b) {
+    return modnum(a) += b;
+  }
+  friend modnum operator-(const modnum &a, const modnum &b) {
+    return modnum(a) -= b;
+  }
+  friend modnum operator*(const modnum &a, const modnum &b) {
+    return modnum(a) *= b;
+  }
+  friend modnum operator/(const modnum &a, const modnum &b) {
+    return modnum(a) /= b;
+  }
+};
+using mint = modnum<1000000007>;
+// using mint = modnum<998244353>;
+
+class Solution {
+public:
+  int countTrapezoids(vector<vector<int>> &points) {
+    unordered_map<int, int> ycnt;
+    for (auto p : points)
+      ycnt[p[1]]++;
+
+    mint total = 0;
+    for (auto [y, cnt] : ycnt) {
+      if (cnt == 1)
+        continue;
+      mint val = mint(cnt) * (cnt - 1) / 2;
+      total += val;
+    }
+
+    mint ans = 0;
+    for (auto [y, cnt] : ycnt) {
+      if (cnt == 1)
+        continue;
+      mint val = mint(cnt) * (cnt - 1) / 2;
+      ans += val * (total - val);
+    }
+    ans /= 2;
+    return int(ans);
+  }
+};

count-number-of-trapezoids-ii/answer.py

@@ -0,0 +1,25 @@
+class Solution:
+    def countTrapezoids(self, A: List[List[int]]) -> int:
+        slopes = Counter()
+        lines = Counter()
+        mids = Counter()
+        midlines = Counter()
+
+        for (x1, y1), (x2, y2) in combinations(A, 2):
+            dx, dy = x2 - x1, y2 - y1
+            g = gcd(dx, dy)
+            dx, dy = dx // g, dy // g
+            if dx < 0 or (dx == 0 and dy < 0):
+                dx, dy = -dx, -dy
+
+            inter = dx * y1 - dy * x1
+            slopes[dx, dy] += 1
+            lines[dx, dy, inter] += 1
+            mids[x1 + x2, y1 + y2] += 1
+            midlines[x1 + x2, y1 + y2, dx, dy, inter] += 1
+
+        ans = sum(comb(v, 2) for v in slopes.values())
+        ans -= sum(comb(v, 2) for v in lines.values())
+        ans -= sum(comb(v, 2) for v in mids.values())
+        ans += sum(comb(v, 2) for v in midlines.values())
+        return ans

network-recovery-pathways/answer.cpp

@@ -0,0 +1,56 @@
+using int64 = long long;
+
+template <class T> bool umax(T &a, const T b) { return a < b ? a = b, 1 : 0; }
+
+class Solution {
+public:
+  int findMaxPathScore(vector<vector<int>> &edges, vector<bool> &online,
+                       long long k) {
+    int n = online.size();
+    vector<vector<pair<int, int>>> adj(n);
+    for (auto e : edges)
+      adj[e[0]].push_back({e[1], e[2]});
+
+    vector<int64> dis(n);
+    auto Test = [&](int val) -> bool {
+      dis.assign(n, LLONG_MAX);
+      using State = pair<int64, int>;
+      priority_queue<State, vector<State>, greater<State>> q;
+      dis[0] = 0;
+      q.push({0, 0});
+
+      while (!q.empty()) {
+        auto [d, u] = q.top();
+        q.pop();
+        // skip invalid node
+        if (dis[u] != d)
+          continue;
+
+        for (auto [v, weight] : adj[u]) {
+          if (!online[v])
+            continue;
+          if (weight < val)
+            continue;
+          int64 w = dis[u] + weight;
+          if (w < dis[v]) {
+            dis[v] = w;
+            q.push({dis[v], v});
+          }
+        }
+      }
+      return dis[n - 1] <= k;
+    };
+
+    int l = 0, r = 0, ans = -1;
+    for (auto e : edges)
+      umax(r, e[2]);
+    while (l <= r) {
+      int mid = (l + r) / 2;
+      if (Test(mid))
+        ans = mid, l = mid + 1;
+      else
+        r = mid - 1;
+    }
+    return ans;
+  }
+};

number-of-integers-with-popcount-depth-equal-to-k-i/answer.cpp

@@ -0,0 +1,66 @@
+#define bitCount(n) __builtin_popcountll((n))
+
+using int64 = long long;
+
+class Solution {
+public:
+  std::string toBinary(int64 n) {
+    if (n == 0)
+      return "0";
+
+    std::string s = "";
+    while (n > 0) {
+      s += (n % 2) ? '1' : '0';
+      n /= 2;
+    }
+
+    // Reverse since we built it backwards
+    std::reverse(s.begin(), s.end());
+    return s;
+  }
+
+  long long popcountDepth(long long n, int k) {
+    if (k == 0)
+      return 1;
+
+    vector<int> cnt(65, 0);
+    cnt[1] = 0;
+    for (int i = 2; i <= 64; i++)
+      cnt[i] = cnt[bitCount(i)] + 1;
+
+    string s = toBinary(n);
+    int m = s.size();
+
+    // dp[pos][ones][equal]
+    vector<vector<vector<int64>>> dp(
+        m, vector<vector<int64>>(65, vector<int64>(2, 0)));
+    dp[0][0][0] = 1;
+    dp[0][1][1] = 1;
+    for (int i = 1; i < m; i++) {
+      int d = s[i] - '0';
+      for (int j = 0; j <= i; j++) {
+        // choose 0
+        dp[i][j][0] += dp[i - 1][j][0];
+        if (d == 1)
+          dp[i][j][0] += dp[i - 1][j][1];
+        else
+          dp[i][j][1] += dp[i - 1][j][1];
+
+        // choose 1
+        dp[i][j + 1][0] += dp[i - 1][j][0];
+        if (d == 1)
+          dp[i][j + 1][1] += dp[i - 1][j][1];
+      }
+    }
+
+    int64 ans = 0;
+    for (int i = 1; i <= m; i++) {
+      if (cnt[i] != k - 1)
+        continue;
+      ans += dp[m - 1][i][0] + dp[m - 1][i][1];
+    }
+    if (k == 1)
+      return ans - 1;
+    return ans;
+  }
+};