T1：Arithmetic Progression
模拟
代码实现
a, b, d = map(int, input().split())
for i in range(a, b+1, d):
print(i, end=' ')
T2：Append
模拟
代码实现
q = int(input())
a = []
for qi in range(q):
type, x = map(int, input().split())
if type == 1:
a.append(x)
else:
print(a[-x])
T3：Divide and Divide
记忆化搜索
代码实现
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll n;
cin >> n;
unordered_map<ll, ll> memo;
auto f = [&](auto& f, ll x) -> ll {
if (x == 1) return 0;
if (memo.count(x)) return memo[x];
ll res = f(f, x/2) + f(f, x-x/2) + x;
return memo[x] = res;
};
cout << f(f, n) << '\n';
return 0;
}
T4：Super Takahashi Bros.
注意到由于图可能不是dag，所以不能dp
考虑对点 \(i\) 到点 \(i+1\) 连一条有向边且边权为 \(A_i\)，再对点 \(i\) 到点 \(X_i\) 连一条有向边且边权为 \(B_i\)，这样就得到了一张带权有向图，所以直接跑一遍最短路就能得到答案
代码实现
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
struct Edge {
int to, cost;
Edge() {}
Edge(int to, int cost): to(to), cost(cost) {}
};
int main() {
int n;
cin >> n;
vector<vector<Edge>> g(n);
rep(i, n-1) {
int a, b, x;
cin >> a >> b >> x;
--x;
g[i].emplace_back(i+1, a);
g[i].emplace_back(x, b);
}
const ll INF = 1e18;
vector<ll> dist(n, INF);
using P = pair<ll, int>;
priority_queue<P, vector<P>, greater<P>> q;
dist[0] = 0;
q.emplace(0, 0);
while (q.size()) {
auto [d, v] = q.top(); q.pop();
if (dist[v] != d) continue;
for (auto e : g[v]) {
ll nd = d+e.cost;
if (nd >= dist[e.to]) continue;
dist[e.to] = nd;
q.emplace(nd, e.to);
}
}
cout << dist[n-1] << '\n';
return 0;
}
T5：Mancala 2
- 区间更新
- 单点求值
可以用线段树或树状数组来做
树状数组的话，可以用差分来实现区间更新，用前缀和来实现单点求值
代码实现
#include <bits/stdc++.h>
#if __has_include(<atcoder/all>)
#include <atcoder/all>
using namespace atcoder;
#endif
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
int main() {
int n, m;
cin >> n >> m;
fenwick_tree<ll> d(n+1);
auto add = [&](int l, int r, ll x) {
d.add(l, x);
d.add(r, -x);
};
rep(i, n) {
int a;
cin >> a;
add(i, i+1, a);
}
rep(i, m) {
int b;
cin >> b;
ll x = d.sum(0, b+1);
add(b, b+1, -x);
ll c = x/n; x %= n;
add(0, n, c);
b++;
if (b+x < n) {
add(b, b+x, 1);
}
else {
add(b, n, 1);
add(0, b+x-n, 1);
}
}
rep(i, n) {
ll ans = d.sum(0, i+1);
cout << ans << ' ';
}
return 0;
}
T6：S = 1
由向量积的知识可知，三角形的面积等于 \(\frac{|BX-AY|}{2}\)，得到 \(|BX-AY| = 2\)，于是就转成了扩欧的板题
代码实现
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
// ai+bj=g
ll extgcd(ll a, ll b, ll& i, ll& j) {
if (b == 0) { i = 1; j = 0; return a; }
ll p = a/b, g = extgcd(b, a-b*p, j, i);
j -= p*i;
return g;
}
int main() {
ll x, y;
cin >> x >> y;
ll a, b;
ll g = extgcd(x, y, b, a);
a = -a;
if (2%g) {
puts("-1");
return 0;
}
a *= 2/g; b *= 2/g;
cout << a << ' ' << b << '\n';
return 0;
}
T7：Leaf Color
考虑枚举度数为 \(1\) 的点的颜色，然后跑树形dp即可
记 dp[v] 表示在以 \(v\) 为根的子树中合法的诱导子图的个数
然而时间复杂度是 \(O(n^2)\)
可以通过仅在虚树上dp将时间复杂度降到 \(O(n\log n)\)
代码实现
#include <bits/stdc++.h>
#if __has_include(<atcoder/all>)
#include <atcoder/all>
using namespace atcoder;
#endif
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using mint = modint998244353;
// Lowest Common Ancestor by binary lifting
template<typename T=int> // T: type of cost
struct lca {
int n, root, l;
vector<vector<int>> to;
vector<vector<T>> co;
vector<int> dep;
vector<T> costs;
vector<vector<int>> par;
lca(int n):n(n),to(n),co(n),dep(n),costs(n) {
l = 0;
while ((1<<l) < n) ++l;
par = vector<vector<int>>(n+1,vector<int>(l,n));
}
void addEdge(int a, int b, T c=0) {
to[a].push_back(b); co[a].push_back(c);
to[b].push_back(a); co[b].push_back(c);
}
void dfs(int v, int d=0, T c=0, int p=-1) {
if (p != -1) par[v][0] = p;
dep[v] = d;
costs[v] = c;
for (int i = 0; i < to[v].size(); ++i) {
int u = to[v][i];
if (u == p) continue;
dfs(u, d+1, c+co[v][i], v);
}
}
void init(int _root=0) {
root = _root;
dfs(root);
for (int i = 0; i < l-1; ++i) {
for (int v = 0; v < n; ++v) {
par[v][i+1] = par[par[v][i]][i];
}
}
}
// LCA
int up(int v, int k) {
for (int i = l-1; i >= 0; --i) {
int len = 1<<i;
if (k >= len) k -= len, v = par[v][i];
}
return v;
}
int operator()(int a, int b) {
if (dep[a] > dep[b]) swap(a,b);
b = up(b, dep[b]-dep[a]);
if (a == b) return a;
for (int i = l-1; i >= 0; --i) {
int na = par[a][i], nb = par[b][i];
if (na != nb) a = na, b = nb;
}
return par[a][0];
}
int length(int a, int b) {
int c = (*this)(a,b);
return dep[a]+dep[b]-dep[c]*2;
}
T dist(int a, int b) {
int c = (*this)(a,b);
return costs[a]+costs[b]-costs[c]*2;
}
};
int main() {
int n;
cin >> n;
vector<vector<int>> cvs(n);
vector<int> col(n);
rep(i, n) {
int a;
cin >> a;
a--;
col[i] = a;
cvs[a].push_back(i);
}
vector<vector<int>> to(n);
lca g(n);
rep(i, n-1) {
int a, b;
cin >> a >> b;
--a; --b;
g.addEdge(a, b);
to[a].push_back(b);
to[b].push_back(a);
}
g.init();
vector<int> in(n), out(n);
{
int k = 0;
auto dfs = [&](auto& f, int v, int p=-1) -> void {
in[v] = k++;
for (int u : to[v]) {
if (u == p) continue;
f(f, u, v);
}
out[v] = k;
};
dfs(dfs, 0);
}
mint ans;
vector<vector<int>> to2(n);
rep(ci, n) {
vector<int>& vs = cvs[ci];
if (vs.size() == 0) continue;
sort(vs.begin(), vs.end(), [&](int a, int b) { return in[a] < in[b]; });
int m = vs.size();
rep(i, m-1) {
vs.push_back(g(vs[i], vs[i+1]));
}
sort(vs.begin(), vs.end(), [&](int a, int b) { return in[a] < in[b]; });
vs.erase(unique(vs.begin(), vs.end()), vs.end());
{
vector<int> st;
for (int v : vs) {
while (st.size()) {
int p = st.back();
if (in[p] < in[v] and in[v] < out[p]) break;
st.pop_back();
}
if (st.size()) to2[st.back()].push_back(v);
st.push_back(v);
}
}
auto dfs = [&](auto& f, int v) -> mint {
mint res;
for (int u : to2[v]) {
mint x = f(f, u);
if (col[v] != ci) ans += res*x;
res += (res+1)*x;
}
if (col[v] == ci) {
res += 1;
ans += res;
}
return res;
};
dfs(dfs, vs[0]);
for (int v : vs) to2[v] = vector<int>();
}
cout << ans.val() << '\n';
return 0;
}
