Educational Codeforces Round 129 (Rated for Div. 2)

A. Game with Cards

题意

两个人，每个人手上有一些牌，牌上写有数字。两个人轮流出牌，其中一个人先出，后面如果要出牌，牌上的数字必须比前一张牌要大。第一个不能出牌的人就输。

问两个人是否是先手必胜？

每个人牌的数量至多为$50$。

思路

答案只和两个人手上最大的牌有关。先手必胜当且仅当先手手上最大牌大于等于后手手上的最大牌。

AC代码

// Problem: A. Game with Cards
// Contest: Codeforces - Educational Codeforces Round 129 (Rated for Div. 2)
// URL: https://codeforces.com/contest/1681/problem/A
// Memory Limit: 256 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);
#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;

  int ma = 0;
  for (int i = 1; i <= n; ++i) {
    int x;
    std::cin >> x;
    ma = std::max(ma, x);
  }

  int m;
  std::cin >> m;
  int mb = 0;
  for (int i = 1; i <= m; ++i) {
    int x;
    std::cin >> x;
    mb = std::max(mb, x);
  }

  std::cout << (ma >= mb ? "Alice" : "Bob") << "\n";
  std::cout << (ma > mb ? "Alice" : "Bob") << "\n";
}

B. Card Trick

题意

给长度为$n$的数组$a$，长度为$m$的数组$b$。

执行$m$次操作，每次将$a$中前$b_j$个元素移动到末尾，相对顺序不变。

问执行完操作之后，$a$的首元素。

$n, m$至多为$2 \times 10^5$。

思路

第$j$次操作相当于将$a_i$替换为$a_{(i + b_j) \mod n}$。

AC代码

// Problem: B. Card Trick
// Contest: Codeforces - Educational Codeforces Round 129 (Rated for Div. 2)
// URL: https://codeforces.com/contest/1681/problem/B
// Memory Limit: 256 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);
#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::vector<int> a(n);
  for (int& v : a)
    std::cin >> v;

  int m;
  std::cin >> m;
  std::vector<int> b(m);
  for (int& v : b)
    std::cin >> v;

  int p = 0;
  for (int i = 0; i < m; ++i) {
    p = (p + b[i]) % n;
  }

  std::cout << a[p] << "\n";
}

C. Double Sort

题意

给定两个长度为$n$的数组$a$和$b$。每次可以选择两个下标$i$和$j$，然后交换$a_i$和$a_j$，交换$b_i$和$b_j$。

问是否能在$10^4$次操作内将$a$和$b$都变有序。

$n$至多为$100$。

思路

对$a$选择排序。

然后再尝试对$b$选择排序。假设当前位于$i$，后面的最小值位于$p$，由于$a$已经有序了，想把后面的值换到前面只能是$a_i = a_p$。

最差情况下，选择排序交换$\frac{n^2}{2}$次，排两次也不会超出限制。

AC代码

// Problem: C. Double Sort
// Contest: Codeforces - Educational Codeforces Round 129 (Rated for Div. 2)
// URL: https://codeforces.com/contest/1681/problem/C
// Memory Limit: 256 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);
#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::vector<std::pair<int, int>> a(n);
  for (int i = 0; i < n; ++i)
    std::cin >> a[i].first;
  for (int i = 0; i < n; ++i)
    std::cin >> a[i].second;

  std::vector<std::pair<int, int>> ans;
  for (int i = 0; i < n; ++i) {
    int p = i;
    for (int j = i + 1; j < n; ++j) {
      if (a[j].first < a[p].first) {
        p = j;
      }
    }
    if (p != i) {
      std::swap(a[i], a[p]);
      ans.push_back({i, p});
    }
  }

  for (int i = 0; i < n; ++i) {
    int p = i;
    for (int j = i + 1; j < n; ++j) {
      if (a[j].second < a[p].second) {
        p = j;
      }
    }
    if (p != i) {
      if (a[i].first == a[p].first) {
        std::swap(a[i], a[p]);
        ans.push_back({i, p});
      } else {
        std::cout << "-1\n";
        return;
      }
    }
  }
  std::cout << ans.size() << "\n";
  for (auto [x, y] : ans)
    std::cout << x + 1 << " " << y + 1 << "\n";
}

D. Required Length

题意

给一个数$x$，每次你可以选择$x$的一个十进制数位，然后将$x$替换为$y \times x$。

问把$x$变成$n$为十进制数的最小操作。

思路

记忆化爆搜，证明不会，复杂度$O(\text{能过})$。

爆搜+剪枝也能过。

记忆化代码

// Problem: D. Required Length
// Contest: Codeforces - Educational Codeforces Round 129 (Rated for Div. 2)
// URL: https://codeforces.com/contest/1681/problem/D
// Memory Limit: 512 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);
#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;
  i64 x;
  std::cin >> n >> x;

  logd(n, x);

  auto b10 = [](i64 x) {
    i64 r = 0;
    while (x) {
      ++r;
      x = x / 10;
    }
    return r;
  };

  auto m10 = [](i64 x) {
    i64 r = 0;
    while (x) {
      r = std::max(r, x % 10);
      x = x / 10;
    }
    return r;
  };

  auto s10 = [](i64 x) {
    std::set<int> s;
    while (x) {
      if (x % 10 > 1)
        s.insert(x % 10);
      x = x / 10;
    }
    return s;
  };

  auto t10 = [](i64 x) {
    int t = 0;
    while (x) {
      t |= (1 << (x % 10));
      x = x / 10;
    }
    return t;
  };

  auto f10 = [](i64 x) {
    int f = 0;
    while (x) {
      f = x % 10;
      x = x / 10;
    }
    return f;
  };

  if (m10(x) == 1 || b10(x) > n) {
    std::cout << "-1\n";
    return;
  }

  std::unordered_map<i64, int> mp;
  std::function<int(i64)> DP = [&](i64 x) -> int {
    if (mp.count(x))
      return mp[x];

    int b = b10(x);
    if (b == n) {
      mp[x] = 0;
      return 0;
    }
    if (b > n) {
      return 0x3f3f3f3f;
    }

    auto s = s10(x);
    int mi = 0x3f3f3f3f;
    for (int y : s) {
      mi = std::min(mi, DP(x * y) + 1);
    }
    mp[x] = mi;
    return mi;
  };
  int ans = DP(x);

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

剪枝代码

// Problem: D. Required Length
// Contest: Codeforces - Educational Codeforces Round 129 (Rated for Div. 2)
// URL: https://codeforces.com/contest/1681/problem/D
// Memory Limit: 512 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);
#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;
  i64 x;
  std::cin >> n >> x;

  i64 p10[20];
  p10[0] = 1;
  for (int i = 1; i <= 19; ++i) {
    p10[i] = p10[i - 1] * 10;
  }

  int b = 0;
  while (x >= p10[b + 1])
    ++b;

  auto t10 = [](i64 x) {
    int t = 0;
    while (x) {
      t |= (1 << (x % 10));
      x = x / 10;
    }
    return t;
  };

  auto h = [&](i64 x, int n) {
    int r = 0;
    while (x < p10[n - 1]) {
      r = r + 1;
      x = x * 9;
    }
    return r;
  };

  if (x > p10[n - 1]) {
    std::cout << "-1\n";
    return;
  }

  int ans = INT_MAX;
  std::function<void(i64, int)> BF = [&](i64 x, int d) -> void {
    if (d >= ans)
      return;

    if (x >= p10[n - 1]) {
      ans = std::min(ans, d);
      return;
    }

    if (d + h(x, n) >= ans) {
      return;
    }

    int t = t10(x);
    for (int y = 9; y >= 2; --y) {
      if ((t >> y) & 1) {
        BF(y * x, d + 1);
      }
    }
  };
  BF(x, 0);
  if (ans == INT_MAX)
    ans = -1;

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

E. Labyrinth Adventures

题意

将一个$n \times n$的矩阵分成多层，点$(i, j)$位于第$\max(i, j)$层。

认为共享一条边的格子为相邻的格子。

同层内相邻点可以随意移动，跨层只能通过层与层之间的门移动。

每一层都有两个门，一个向上开，一个向右开。

要求回答$q$个询问：从$(x_1, y_1)$到$(x_2, y_2)$的最短路长度。

$n \le 10^5, q \le 2 \times 10^5$。

思路

观察1：$(x_1, y_1)$和$(x_2, y_2)$同层，答案为两点间曼哈顿距离。

观察2：假设每次是从层数小的走向层数大的，这个过程中，不会走向层数低的层。
证明：同层内要走向更高层，一定要走到层内某一个门。在矩阵中，如果没有门的限制，两点间最短距离为曼哈顿距离，而同层内移动已经能做到这个最短了，没有必要往低层走。

然后从起点走到终点的化，就可以看成是起点走到当层的门，当层的门走到终点前一层的门，最走再走到终点这三个过程。第一个和第三个都是可以直接枚举算的，而第二个过程就是相当于2行$n$列的DP，一个经典的DP问题了。

根据观察2，整个过程只会往高层走，由此第二个过程其实可以像倍增LCA那样子做优化，具体就是维护一个$dp_{i, j, k, l}$表示从第$i$层第$k$个门走到第$i + 2^j$第$l$个门的最短距离，这个可以$O(n \log n)$求出来。然后查询的时候再通过至多$O(\log n)$次跳跃求出第二个过程的答案。

AC代码

// Problem: E. Labyrinth Adventures
// Contest: Codeforces - Educational Codeforces Round 129 (Rated for Div. 2)
// URL: https://codeforces.com/contest/1681/problem/E
// Memory Limit: 512 MB
// Time Limit: 6000 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);
#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 manhattan = [](int x1, int y1, int x2, int y2) -> i64 {
    return std::abs(x1 - x2) + std::abs(y1 - y2);
  };
  int n;
  std::cin >> n;

  std::vector<std::vector<std::pair<int, int>>> door(2, std::vector<std::pair<int, int>>(n - 1));
  for (int i = 0; i < n - 1; ++i) {
    std::cin >> door[0][i].first >> door[0][i].second;
    std::cin >> door[1][i].first >> door[1][i].second;
  }

  int x = 1, lg = 0;
  while (x <= n) {
    x = x * 2;
    ++lg;
  }
  std::vector<std::vector<std::vector<std::vector<i64>>>> dis(
      n - 1, std::vector<std::vector<std::vector<i64>>>(
                 lg, std::vector<std::vector<i64>>(2, std::vector<i64>(2, 0x3f3f3f3f3f3f3f3fLL))));
  for (int i = 0; i + 1 < n - 1; ++i) {
    for (int d1 = 0; d1 < 2; ++d1) {
      for (int d2 = 0; d2 < 2; ++d2) {
        auto s = door[d1][i];
        if (d1 == 0)
          ++s.first;
        else
          ++s.second;
        auto t = door[d2][i + 1];
        dis[i][0][d1][d2] = manhattan(s.first, s.second, t.first, t.second) + 1;
      }
    }
  }
  for (int j = 1; j < lg; ++j) {
    for (int i = 0; i + 1 < n - 1; ++i) {
      if (i + (1 << (j - 1)) >= n - 2)
        break;
      for (int d1 = 0; d1 < 2; ++d1) {
        for (int d2 = 0; d2 < 2; ++d2) {
          for (int k = 0; k < 2; ++k) {
            dis[i][j][d1][d2] = std::min(
                dis[i][j][d1][d2], dis[i][j - 1][d1][k] + dis[i + (1 << (j - 1))][j - 1][k][d2]);
          }
        }
      }
    }
  }

  auto SP = [&](int x1, int y1, int x2, int y2) -> i64 {
    logd(x1, y1, x2, y2);
    i64 ans = INT64_MAX;

    int curr = std::max(x1, y1) - 1, dest = std::max(x2, y2) - 2;
    std::vector<i64> dp = {0, 0};
    for (int i = 0; i < 2; ++i) {
      dp[i] = manhattan(x1, y1, door[i][curr].first, door[i][curr].second);
      logd(x1, y1, door[i][curr].first, door[i][curr].second);
    }
    logd(curr, dp, dest);
    for (int b = lg; b >= 0; --b) {
      if (curr + (1 << b) <= dest) {
        auto temp = dp;
        dp[0] = dp[1] = INT64_MAX;
        for (int i = 0; i < 2; ++i) {
          for (int j = 0; j < 2; ++j) {
            dp[j] = std::min(dp[j], temp[i] + dis[curr][b][i][j]);
          }
        }
        curr += (1 << b);
        logd(curr, dp);
      }
    }
    assert(curr == dest);
    for (int i = 0; i < 2; ++i) {
      auto pos = door[i][dest];
      if (i == 0)
        ++pos.first;
      else
        ++pos.second;
      ans = std::min(ans, dp[i] + manhattan(pos.first, pos.second, x2, y2) + 1);
    }
    return ans;
  };

  int q;
  std::cin >> q;
  for (int _ = 0; _ < q; ++_) {
    int x1, y1, x2, y2;
    i64 ans = INT64_MAX;
    std::cin >> x1 >> y1 >> x2 >> y2;
    if (std::max(x1, y1) == std::max(x2, y2)) {
      ans = manhattan(x1, y1, x2, y2);
    } else {
      if (std::max(x1, y1) > std::max(x2, y2)) {
        std::swap(x1, x2);
        std::swap(y1, y2);
      }
      ans = std::min(ans, SP(x1, y1, x2, y2));
    }
    std::cout << ans << "\n";
  }
}

F. Unique Occurrences

题意

给一颗$n$个节点的数，树上每一条边有一个权值。

令$f(u, v)$为$u$到$v$的路径上，只出现过一次的边权的数量。

求所有$\sum_{1\le v < u \le n} f(u, v)$。

$n$至多为$5 \times 10^5$。

思路

对于权值为$c$的边，如果将权值非$c$的边全部保留，权值为$c$的边全部删去，那么此时权值为$c$的边$(u, v)$对答案的贡献为$sz_u \times sz_v$。

然后就是LCT维护子树大小，这是个经典问题了，不会的话指路Link Cut Tree - OI Wiki。

AC代码

// Problem: F. Unique Occurrences
// Contest: Codeforces - Educational Codeforces Round 129 (Rated for Div. 2)
// URL: https://codeforces.com/contest/1681/problem/F
// Memory Limit: 1024 MB
// Time Limit: 6000 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);
#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 LinkCutTree {
#define ls ch[x][0]
#define rs ch[x][1]
#define SIZE 500005

  int tot, sz[SIZE], sz2[SIZE], rev[SIZE], ch[SIZE][2], fa[SIZE];

  LinkCutTree() { tot = 0; }

  inline void init() { tot = 0; }

  inline void clear(int x) { ch[x][0] = ch[x][1] = fa[x] = sz[x] = sz2[x] = rev[x] = 0; }

  inline int get(int x) { return ch[fa[x]][1] == x; }

  inline int isroot(int x) { return ch[fa[x]][0] != x && ch[fa[x]][1] != x; }

  inline int newnode() {
    ++tot;
    sz[tot] = 1;
    ch[tot][0] = ch[tot][1] = fa[tot] = rev[tot] = 0;
    return tot;
  }

  inline void reverse(int x) {
    std::swap(ls, rs);
    rev[x] ^= 1;
  }

  inline void push_up(int x) { sz[x] = sz[ls] + 1 + sz[rs] + sz2[x]; }

  inline void push_down(int x) {
    if (rev[x]) {
      reverse(ls);
      reverse(rs);
      rev[x] = 0;
    }
  }

  inline void update(int x) {
    if (!isroot(x))
      update(fa[x]);
    push_down(x);
  }

  inline void rotate(int x) {
    int f = fa[x], g = fa[f], i = get(x);
    if (!isroot(f))
      ch[g][get(f)] = x;
    fa[x] = g;
    ch[f][i] = ch[x][i ^ 1];
    fa[ch[f][i]] = f;
    ch[x][i ^ 1] = f;
    fa[f] = x;
    push_up(f);
    push_up(x);
  }

  inline void splay(int x) {
    update(x);
    for (; !isroot(x); rotate(x))
      if (!isroot(fa[x]))
        rotate(get(fa[x]) == get(x) ? fa[x] : x);
  }

  inline void access(int x) {
    for (int y = 0; x; y = x, x = fa[x])
      splay(x), sz2[x] += sz[rs] - sz[y], rs = y, push_up(x);
  }

  inline void makeroot(int x) {
    access(x);
    splay(x);
    reverse(x);
  }

  inline int findroot(int x) {
    access(x);
    splay(x);
    while (ls)
      push_down(x), x = ls;
    return x;
  }

  inline void link(int x, int y) {
    makeroot(x);
    if (findroot(y) != x) {
      fa[x] = y;
      sz2[y] += sz[x];
    }
  }

  inline void cut(int x, int y) {
    makeroot(x);
    if (findroot(y) == x && fa[x] == y && ch[y][0] == x && !ch[y][1]) {
      fa[x] = ch[y][0] = 0;
      push_up(y);
    }
  }

  inline void split(int x, int y) {
    makeroot(x);
    access(y);
    splay(y);
  }
};

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

  LinkCutTree lct;
  for (int i = 1; i <= n; ++i)
    lct.newnode();

  std::vector<std::array<int, 3>> E(n - 1);
  std::vector<std::vector<int>> C(n + 1);
  for (int i = 0; i < n - 1; ++i) {
    int u, v, x;
    std::cin >> u >> v >> x;
    logd(u, v, x);
    E[i] = {u, v, x};
    C[x].push_back(i);
    lct.link(u, v);
  }

  i64 ans = 0;
  for (int c = 1; c <= n; ++c) {
    for (int eid : C[c]) {
      auto [u, v, _] = E[eid];
      lct.cut(u, v);
    }

    for (int eid : C[c]) {
      auto [u, v, _] = E[eid];
      lct.makeroot(u);
      lct.makeroot(v);
      ans += i64(1) * lct.sz[u] * lct.sz[v];
    }

    for (int eid : C[c]) {
      auto [u, v, _] = E[eid];
      lct.link(u, v);
    }
  }

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