AtCoder Beginner Contest 259

咕咕咕。

D - Circumferences

题意

给定\(n\)个园\((x_i, y_i, r_i)\)以及起点\((sx, sy)\)和终点\((tx, ty)\)。

问只在给定圆的圆周上移动，能否从起点移动至终点。

其中\(1 \le n \le 3000, -{10}^9 \le x_i, y_i \le {10}^9, 1 \le r_i \le {10}^9\)。

思路

转换成图论问题，一个圆对应一个节点，如果两个圆之间有交点就在两个节点之间连边，表示可以从一个圆走到另一个圆。

两圆是否有交点就是高中数学。然后这里的可达关系是传递的，所以可以用并查集维护。

如果起点和终点在同一连通块中则可行，反之则无解。

AC代码

// Problem: D - Circumferences
// Contest: AtCoder - AtCoder Beginner Contest 259
// URL: https://atcoder.jp/contests/abc259/tasks/abc259_d
// Memory Limit: 1024 MB
// Time Limit: 2000 ms
//
// Powered by CP Editor (https://cpeditor.org)

#include <bits/stdc++.h>

#define CPPIO std::ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);
#define freep(p) p ? delete p, p = nullptr, void(1) : void(0)

#ifdef BACKLIGHT
#include "debug.h"
#else
#define logd(...) ;
#endif

using i64 = int64_t;
using u64 = uint64_t;

void solve_case(int Case);

int main(int argc, char* argv[]) {
  CPPIO;
  int T = 1;
  // std::cin >> T;
  for (int t = 1; t <= T; ++t) {
    solve_case(t);
  }
  return 0;
}

void solve_case(int Case) {
  auto dist2 = [](int sx, int sy, int tx, int ty) {
    return i64(1) * (tx - sx) * (tx - sx) + i64(1) * (ty - sy) * (ty - sy);
  };

  auto square = [](int x) { return i64(1) * x * x; };

  auto intersect = [&dist2, &square](const std::array<int, 3>& lhs, const std::array<int, 3>& rhs) {
    auto [x1, y1, r1] = lhs;
    auto [x2, y2, r2] = rhs;
    return dist2(x1, y1, x2, y2) <= square(r1 + r2) &&
           dist2(x1, y1, x2, y2) >= square(std::abs(r1 - r2));
  };

  int n;
  std::cin >> n;

  int sx, sy, tx, ty;
  std::cin >> sx >> sy >> tx >> ty;

  std::vector<int> f(n);
  std::iota(f.begin(), f.end(), 0);
  std::function<int(int)> find = [&](int x) { return x == f[x] ? x : f[x] = find(f[x]); };
  auto merge = [&](int x, int y) {
    x = find(x), y = find(y);
    if (x == y)
      return;
    f[x] = y;
  };

  std::vector<std::array<int, 3>> a(n);
  for (int i = 0; i < n; ++i) {
    int x, y, r;
    std::cin >> x >> y >> r;
    a[i] = {x, y, r};
  }

  for (int i = 0; i < n; ++i) {
    for (int j = i + 1; j < n; ++j) {
      if (intersect(a[i], a[j])) {
        merge(i, j);
      }
    }
  }

  auto belong = [&](int sx, int sy) {
    int z = -1;
    for (int i = 0; i < n; ++i) {
      auto [x, y, r] = a[i];
      if (dist2(sx, sy, x, y) == square(r)) {
        z = find(i);
        break;
      }
    }
    return z;
  };

  int sid = belong(sx, sy), tid = belong(tx, ty);
  std::cout << (sid != -1 && sid == tid ? "Yes" : "No") << "\n";
}

E - LCM on Whiteboard

题意

给定\(n\)个数字的质因数分解形式，要求将其中某一个数置成1，问操作过后这\(n\)个数可能的LCM有多少个。

其中\(1 \le n \le 2 \times {10}^{5}\)。

思路

假设操作之前，\(n\)个数字的LCM等于\(lcm\)。

根据

\[\operatorname{LCM} = \prod_i p_i^{\max_j(e_j)} \]

可以得出，如果将某个数字置成1之后，某个\(\max_j(e_j)\)发生变化，则这个数字对和一个新的LCM一一对应。

还有一种可能是将某个数字置成1之后，\(\max_j(e_j)\)均未发生变化，这一部分的数字均对应\(lcm\)。

两部分之和即为答案。

AC代码

// Problem: E - LCM on Whiteboard
// Contest: AtCoder - AtCoder Beginner Contest 259
// URL: https://atcoder.jp/contests/abc259/tasks/abc259_e
// Memory Limit: 1024 MB
// Time Limit: 2000 ms
//
// Powered by CP Editor (https://cpeditor.org)

#include <bits/stdc++.h>

#define CPPIO std::ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);
#define freep(p) p ? delete p, p = nullptr, void(1) : void(0)

#ifdef BACKLIGHT
#include "debug.h"
#else
#define logd(...) ;
#endif

using i64 = int64_t;
using u64 = uint64_t;

void solve_case(int Case);

int main(int argc, char* argv[]) {
  CPPIO;
  int T = 1;
  // std::cin >> T;
  for (int t = 1; t <= T; ++t) {
    solve_case(t);
  }
  return 0;
}

void solve_case(int Case) {
  int n;
  std::cin >> n;

  std::map<int, std::pair<int, int>> mp;
  std::vector<std::vector<std::pair<int, int>>> a(n);
  for (int i = 0; i < n; ++i) {
    int m;
    std::cin >> m;
    for (int j = 0; j < m; ++j) {
      int p, e;
      std::cin >> p >> e;

      a[i].push_back({p, e});

      if (!mp.count(p)) {
        mp[p] = {e, 1};
      } else {
        if (e > mp[p].first) {
          mp[p] = {e, 1};
        } else if (e == mp[p].first) {
          ++mp[p].second;
        }
      }
    }
  }

  int ans = 0, delta = 0;
  for (int i = 0; i < n; ++i) {
    bool flag = false;
    for (auto [p, e] : a[i]) {
      if (e == mp[p].first && mp[p].second == 1) {
        flag = true;
      }
    }
    if (flag)
      ++ans;
    else
      delta = 1;
  }

  std::cout << ans + delta << "\n";
}

F - Select Edges

题意

给定一棵\(n\)个节点的树，边带权。

考虑选出一些边，要求至多选择\(d_i\)条一端为节点\(i\)的边。

问选出来的边的最大边权和。

其中\(2 \le n \le 3 \times {10}^5\)。

思路

一开始猜了个假结论，即一个类似Kruscal的贪心，然后WA了。

然后就想到了DP，不妨令节点\(1\)为根，记\(dp_{i, 0/1}\)表示以\(i\)为根的子树中，是否还有余量选择指向\(i\)父亲的边，的最大边权和。易得\(\max(dp_{1, 0}, dp_{1, 1})\)即为答案。

对于节点\(u\)，记其子节点的集合为\(V\)，则\(dp_{u,0/1}\)可以只从\(V\)转移得到。

然后这里的转移可以贪心搞。

具体就是对于\(v \in V\)，节点\(v\)可以提供两种方案：收益为\(dp_{v, 0}\)代价为0以及收益为\(w + dp_{v, 1}\)代价为1。

\(dp_{u, 0}\)可以看成至多花费\(d_u\)的代价的最大收益，\(dp_{u, 1}\)可以看成至多花费\(d_u - 1\)的代价的最大收益。

当\(d_u = 0\)时令\(dp_{u, 1}\)为\(-\infin\)。

可以先将所有\(dp_{v, 0}\)累加起来，问题转化成可以花费1的代价额外增加\(w + dp_{v, 1} - dp_{v, 0}\)的收益，然后排个序贪心搞就可以了。

AC代码

// Problem: F - Select Edges
// Contest: AtCoder - AtCoder Beginner Contest 259
// URL: https://atcoder.jp/contests/abc259/tasks/abc259_f
// Memory Limit: 1024 MB
// Time Limit: 3000 ms
//
// Powered by CP Editor (https://cpeditor.org)

#include <bits/stdc++.h>

#define CPPIO std::ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);
#define freep(p) p ? delete p, p = nullptr, void(1) : void(0)

#ifdef BACKLIGHT
#include "debug.h"
#else
#define logd(...) ;
#endif

using i64 = int64_t;
using u64 = uint64_t;

void solve_case(int Case);

int main(int argc, char* argv[]) {
  CPPIO;
  int T = 1;
  // std::cin >> T;
  for (int t = 1; t <= T; ++t) {
    solve_case(t);
  }
  return 0;
}

struct Edge {
  int v, w;
  Edge() {}
  Edge(int _v, int _w) : v(_v), w(_w) {}
  bool operator<(const Edge& e) const { return w > e.w; }
};

void solve_case(int Case) {
  int n;
  std::cin >> n;

  std::vector<int> d(n);
  for (int i = 0; i < n; ++i)
    std::cin >> d[i];

  std::vector<std::vector<Edge>> g(n);
  for (int i = 0; i < n - 1; ++i) {
    int u, v, w;
    std::cin >> u >> v >> w;
    --u, --v;
    g[u].push_back(Edge(v, w));
    g[v].push_back(Edge(u, w));
  }

  std::vector<std::vector<i64>> dp(n, std::vector<i64>(2, 0));
  std::function<void(int, int)> dfs = [&](int u, int f) {
    std::vector<i64> W;

    i64 x = 0;
    for (auto [v, w] : g[u]) {
      if (v == f)
        continue;
      dfs(v, u);

      x += dp[v][0];

      if (w > 0 && d[u] > 0 && d[v] > 0) {
        W.push_back(w + dp[v][1] - dp[v][0]);
      }
    }

    if (d[u] == 0) {
      dp[u][0] = x;
      dp[u][1] = -0x3f3f3f3f3f3f3f3f;
      return;
    }

    std::sort(W.begin(), W.end(), std::greater<int>());

    dp[u][0] = dp[u][1] = x;

    for (int i = 0; i < std::min(d[u], (int)W.size()); ++i)
      if (W[i] > 0)
        dp[u][0] += W[i];

    for (int i = 0; i < std::min(d[u] - 1, (int)W.size()); ++i)
      if (W[i] > 0)
        dp[u][1] += W[i];
  };
  dfs(1, 1);

  std::cout << dp[1][0] << "\n";
}

G - Grid Card Game

题意

给定一个\(n\)行\(m\)列的矩阵，可以选择其中些行和列，收益计算方式如下:

• 若存在\(a_{i, j} < 0\)且同时选择了第\(i\)行和第\(j\)列，则收益为\(- \infin\)。
• 否则，收益为被至少选中一次的元素之和。

问最大收益。

其中\(1 \le n, m \le 100\)。

思路

统计行元素和，记为\(r_i\)；统计列元素和，记为\(c_j\)。

由于可以全部不选从而使得收益为\(0\)，如果\(r_i < 0\)则不可能会选择这一行，列同理。

先不考虑重复部分，此时的最佳方案就是将所有收益为正的行和列都选择。但是由于所选行和列之间存在交集，还需要扣去一些重复计算的值。现在问题转化成让扣去的值最小。

根据以下规则建图：

• 若\(r_i\)大于\(0\)则从\(S\)向第\(i\)行连边，容量为\(r_i\)，表示选第\(i\)行。
• 若\(c_j\)大于\(0\)则从第\(j\)列向\(T\)连边，容量为\(c_j\)，表示选第\(j\)列。
• 若\(a_{i, j}\)大于等于\(0\)则从第\(i\)行向第\(j\)列连边，容量为\(a_{i, j}\)，表示同时选择第\(i\)行和第\(j\)列。
• 若\(a_{i, j}\)小于\(0\)则从第\(i\)行向第\(j\)列连边，容量为\(+\infin\)，表示同时选择第\(i\)行和第\(j\)列。

如果同时选了第\(i\)行和第\(j\)列，那么收益就应当扣去\(a_{i, j}\)，相当于割掉图中的一条边；如果没有选某一行，那么收益就应当扣去\(r_i\)，相当于割掉图中的一条边；列同理。问题转化为在图中删去一些边使得\(S\)和\(T\)不连通且割掉的边权和最小，这个就是最小割。

然后根据最大流最小割定理，Dinic跑个最大流完事。

AC代码

// Problem: G - Grid Card Game
// Contest: AtCoder - AtCoder Beginner Contest 259
// URL: https://atcoder.jp/contests/abc259/tasks/abc259_g
// Memory Limit: 1024 MB
// Time Limit: 2000 ms
//
// Powered by CP Editor (https://cpeditor.org)

#include <bits/stdc++.h>

#define CPPIO std::ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);
#define freep(p) p ? delete p, p = nullptr, void(1) : void(0)

#ifdef BACKLIGHT
#include "debug.h"
#else
#define logd(...) ;
#endif

using i64 = int64_t;
using u64 = uint64_t;

void solve_case(int Case);

int main(int argc, char* argv[]) {
  CPPIO;
  int T = 1;
  // std::cin >> T;
  for (int t = 1; t <= T; ++t) {
    solve_case(t);
  }
  return 0;
}

template <typename CapacityType>
class MaxFlowGraph {
  struct Edge {
    int from, to;
    CapacityType capacity, flow;
    Edge() {}
    Edge(int _from, int _to, CapacityType _capacity, CapacityType _flow)
        : from(_from), to(_to), capacity(_capacity), flow(_flow) {}
  };

  int n_;
  int m_;
  std::vector<Edge> edges_;
  std::vector<std::vector<int>> adjacent_;

 public:
  explicit MaxFlowGraph(int n) : n_(n), m_(0), edges_(0), adjacent_(n) {}

  void AddEdge(int from, int to, CapacityType capacity) {
    assert(0 <= from and from < n_);
    assert(0 <= to and to < n_);

    edges_.emplace_back(from, to, capacity, 0);
    adjacent_[from].push_back(m_);
    ++m_;

    edges_.emplace_back(to, from, 0, 0);
    adjacent_[to].push_back(m_);
    ++m_;
  }

  CapacityType Dinic(int src, int dst) {
    const static CapacityType INF = std::numeric_limits<CapacityType>::max();
    std::vector<int> level(n_);
    std::vector<int> start_index(n_);

    std::function<bool()> bfs = [&]() -> bool {
      std::fill(level.begin(), level.end(), -1);

      std::queue<int> q;
      q.push(src);
      level[src] = 0;

      while (!q.empty()) {
        int u = q.front();
        q.pop();

        for (int edge_id : adjacent_[u]) {
          auto [from, to, capacity, flow] = edges_[edge_id];
          CapacityType residual_capacity = capacity - flow;
          if (residual_capacity > 0 && level[to] == -1) {
            level[to] = level[u] + 1;
            if (to == dst)
              break;
            q.push(to);
          }
        }
      }

      return level[dst] != -1;
    };

    std::function<CapacityType(int, CapacityType)> dfs =
        [&](int u, CapacityType max_augment) -> CapacityType {
      if (u == dst)
        return max_augment;

      if (max_augment == 0)
        return 0;

      CapacityType total_augment = 0;
      int i = start_index[u];
      for (; i < (int)adjacent_[u].size(); ++i) {
        int edge_id = adjacent_[u][i];
        auto [from, to, capacity, flow] = edges_[edge_id];
        if (level[to] == level[u] + 1) {
          CapacityType residual_capacity = capacity - flow;
          CapacityType new_augment = dfs(to, std::min(max_augment, residual_capacity));
          if (new_augment <= 0)
            continue;

          max_augment -= new_augment;
          total_augment += new_augment;
          edges_[edge_id].flow += new_augment;
          edges_[edge_id ^ 1].flow -= new_augment;

          if (max_augment == 0)
            break;
        }
      }
      start_index[u] = i;

      if (total_augment == 0)
        level[u] = -1;

      return total_augment;
    };

    CapacityType max_flow = 0;
    while (bfs()) {
      std::fill(start_index.begin(), start_index.end(), 0);
      CapacityType new_flow = dfs(src, INF);
      logd(new_flow);
      max_flow += new_flow;
    }

    return max_flow;
  }
};

void solve_case(int Case) {
  int n, m;
  std::cin >> n >> m;

  std::vector<std::vector<int>> a(n, std::vector<int>(m));
  std::vector<i64> r(n), c(m);
  for (int i = 0; i < n; ++i) {
    for (int j = 0; j < m; ++j) {
      std::cin >> a[i][j];
      r[i] += a[i][j];
      c[j] += a[i][j];
    }
  }

  MaxFlowGraph<i64> g(n + m + 2);
  int s = n + m, t = s + 1;

  i64 sum = 0;
  for (int i = 0; i < n; ++i) {
    if (r[i] > 0) {
      g.AddEdge(s, i, r[i]);
      sum += r[i];
    }
  }
  for (int i = 0; i < m; ++i) {
    if (c[i] > 0) {
      g.AddEdge(n + i, t, c[i]);
      sum += c[i];
    }
  }

  for (int i = 0; i < n; ++i) {
    for (int j = 0; j < m; ++j) {
      if (a[i][j] >= 0) {
        g.AddEdge(i, n + j, a[i][j]);
      } else {
        g.AddEdge(i, n + j, 1e18);
      }
    }
  }

  std::cout << sum - g.Dinic(s, t) << "\n";
}

Ex - Yet Another Path Counting

题意

给定一个\(n\)行\(n\)列的矩阵，每个格子带有一种颜色。可以从任意格子出发，但是只能往右或者往下走，可以在任意格子停止。记过程中经过的格子为一条路径，包括开头和结尾。

问满足开头和结尾颜色相同的路径有多少条。

其中\(1 \le n \le 400\)。

思路

方法1：对于某个颜色\(c\)，记颜色为\(c\)的格子的集合为\(S(c)\)，则分别枚举起点和终点，从起点走到终点的路径数其实就是经典组合数，累加起来就可以得到颜色\(c\)对答案的贡献。单词时间复杂度\(O(|S(c)|^2)\)，在格子颜色全部相同时总的复杂度为\(O(n^4)\)。

方法2：对于某个颜色\(c\)，令\(dp_{i, j}\)表示从某个颜色为\(c\)的起点开始走到格子\((i, j)\)（颜色不必为\(c\)）的路径数，颜色为\(c\)的格子的\(dp\)之和即为颜色\(c\)对答案的贡献。那么通过一个\(O(n^2)\)的DP就可以计算出颜色\(c\)对答案的贡献。单次时间复杂度\(O(n^2)\)，在格子颜色两两相异时总的时间复杂度为\(O(n^4)\)。

两个方法单独工作均可能被卡超时，但是两者结合起来就可以将时间复杂度控制在\(O(n^3)\)。具体做法就是当\(|S(c)| \le n\)时用方法1，否则用方法2。

AC代码

// Problem: Ex - Yet Another Path Counting
// Contest: AtCoder - AtCoder Beginner Contest 259
// URL: https://atcoder.jp/contests/abc259/tasks/abc259_h
// Memory Limit: 1024 MB
// Time Limit: 2000 ms
//
// Powered by CP Editor (https://cpeditor.org)

#include <bits/stdc++.h>

#define CPPIO std::ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);
#define freep(p) p ? delete p, p = nullptr, void(1) : void(0)

#ifdef BACKLIGHT
#include "debug.h"
#else
#define logd(...) ;
#endif

using i64 = int64_t;
using u64 = uint64_t;

void solve_case(int Case);

int main(int argc, char* argv[]) {
  CPPIO;
  int T = 1;
  // std::cin >> T;
  for (int t = 1; t <= T; ++t) {
    solve_case(t);
  }
  return 0;
}

template <typename ValueType, ValueType mod_, typename SupperType = int64_t>
class Modular {
 private:
  ValueType value_;

  ValueType normalize(ValueType value) const {
    if (value >= 0 && value < mod_)
      return value;
    value %= mod_;
    if (value < 0)
      value += mod_;
    return value;
  }

  ValueType power(ValueType value, size_t exponent) const {
    ValueType result = 1;
    ValueType base = value;
    while (exponent) {
      if (exponent & 1)
        result = SupperType(result) * base % mod_;
      base = SupperType(base) * base % mod_;
      exponent >>= 1;
    }
    return result;
  }

 public:
  Modular() : value_(0) {}

  Modular(const ValueType& value) : value_(normalize(value)) {}

  ValueType value() const { return value_; }

  Modular inv() const { return Modular(power(value_, mod_ - 2)); }

  Modular power(size_t exponent) const { return Modular(power(value_, exponent)); }

  friend Modular operator+(const Modular& lhs, const Modular& rhs) {
    ValueType result = lhs.value() + rhs.value() >= mod_ ? lhs.value() + rhs.value() - mod_
                                                         : lhs.value() + rhs.value();
    return Modular(result);
  }

  friend Modular operator-(const Modular& lhs, const Modular& rhs) {
    ValueType result = lhs.value() - rhs.value() < 0 ? lhs.value() - rhs.value() + mod_
                                                     : lhs.value() - rhs.value();
    return Modular(result);
  }

  friend Modular operator*(const Modular& lhs, const Modular& rhs) {
    ValueType result = SupperType(1) * lhs.value() * rhs.value() % mod_;
    return Modular(result);
  }

  friend Modular operator/(const Modular& lhs, const Modular& rhs) {
    ValueType result = SupperType(1) * lhs.value() * rhs.inv().value() % mod_;
    return Modular(result);
  }
};
template <typename StreamType, typename ValueType, ValueType mod, typename SupperType = int64_t>
StreamType& operator<<(StreamType& out, const Modular<ValueType, mod, SupperType>& modular) {
  return out << modular.value();
}
template <typename StreamType, typename ValueType, ValueType mod, typename SupperType = int64_t>
StreamType& operator>>(StreamType& in, Modular<ValueType, mod, SupperType>& modular) {
  ValueType value;
  in >> value;
  modular = Modular<ValueType, mod, SupperType>(value);
  return in;
}
// using Mint = Modular<int, 1'000'000'007>;
using Mint = Modular<int, 998'244'353>;

class Binom {
 private:
  std::vector<Mint> f, g;

 public:
  Binom(int n) {
    f.resize(n + 1);
    g.resize(n + 1);

    f[0] = Mint(1);
    for (int i = 1; i <= n; ++i)
      f[i] = f[i - 1] * Mint(i);
    g[n] = f[n].inv();
    for (int i = n - 1; i >= 0; --i)
      g[i] = g[i + 1] * Mint(i + 1);
  }
  Mint operator()(int n, int m) {
    if (n < 0 || m < 0 || m > n)
      return Mint(0);
    return f[n] * g[m] * g[n - m];
  }
} binom(400 * 2 + 5);

void solve_case(int Case) {
  int n;
  std::cin >> n;

  std::vector<std::vector<int>> a(n + 1, std::vector<int>(n + 1));
  std::vector<std::vector<std::pair<int, int>>> C(n * n + 1);
  for (int i = 1; i <= n; ++i) {
    for (int j = 1; j <= n; ++j) {
      std::cin >> a[i][j];
      C[a[i][j]].push_back(std::make_pair(i, j));
    }
  }

  auto solve1 = [&](int c) {
    Mint result(0);
    int n = C[c].size();
    for (int i = 0; i < n; ++i) {
      for (int j = 0; j < n; ++j) {
        int dx = C[c][j].first - C[c][i].first;
        int dy = C[c][j].second - C[c][i].second;
        if (dx >= 0 && dy >= 0) {
          logd(C[c][i], C[c][j]);
          result = result + binom(dx + dy, dy);
        }
      }
    }
    return result;
  };

  auto solve2 = [&](int c) {
    Mint result(0);
    std::vector<std::vector<Mint>> dp(n + 1, std::vector<Mint>(n + 1, Mint(0)));
    for (int i = 1; i <= n; ++i) {
      for (int j = 1; j <= n; ++j) {
        dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
        if (a[i][j] == c) {
          dp[i][j] = dp[i][j] + Mint(1);
          result = result + dp[i][j];
        }
      }
    }
    return result;
  };

  Mint ans(0);
  for (int c = 1; c <= n * n; ++c) {
    if (C[c].size() <= n) {
      ans = ans + solve1(c);
      logd(c, 1, ans.value());
    } else {
      ans = ans + solve2(c);
      logd(c, 2, ans.value());
    }
  }

  std::cout << ans.value() << "\n";
}