NOIP 2024 简要题解

从这里开始

Problem A 编辑字符串
Problem B 遗失的赋值
Problem C 树的遍历
Problem D 树上查询

　　啥？你问我为啥没事做个 noip？这是工作一部分（摊手手）

Problem A 编辑字符串

　　两个都不能动的字符直接判断。其中一个能动的话，优先进行匹配。如果它不在最优解中匹配，那么显然可以通过调整使得它能匹配上，同时总匹配数不变。

　　剩下从左到右依次考虑两个串中都能动的字符。如果能在 $i$ 处匹配那么就在 $i$ 处匹配。原因类似于上面，反正总可以拆一个匹配来满足 $i$ 处的匹配。

　　然后就是匹配 0，还是匹配 1 的问题。但其实这个是无所谓的，不妨我们设能匹配 0 的时候优先匹配 0。因为如果两个颜色都剩了，那么 0 和 1 的数量和是刚好等于当前连通块和另一个串前一个相交的和后一个相交的重叠的部分的长度（ $x + y = u + v$ ），并且同时有 $a + b = u$ （不然前面的连通块至少有一个颜色被耗完）。（假设中间没有多余的连通块）

如果在 $u$ 这一部分，有一个 $s_1$ 中的 0 没有被匹配，那么 $v$ 中会多一个 $0$ 。拆一对 $0$ 拿过来，匹配数不变，但是满足我们分配的规则。
如果在 $v$ 这一部分，显然填 0 还是填 1 都是无所谓的。

Code

#include <bits/stdc++.h>
using namespace std;
 
const int N = 1e5 + 5;
 
#define pii pair<int, int>
 
int T, n;
char sa[N], sb[N];
char ta[N], tb[N];
int sid_a[N], sid_b[N];
vector<pii> segments;
 
void label(int& seg_cnt, char* s, char* t, int* sid) {
  for (int i = 0; i < n; i++) {
    if (i == 0 || (t[i - 1] == '0' && t[i] == '1')) {
      seg_cnt++;
      segments.emplace_back(0, 0);
    }
    if (t[i] == '1') {
      sid[i] = seg_cnt - 1;
      if (s[i] == '0') {
        segments.back().first++;
      } else {
        segments.back().second++;
      }
    } else {
      sid[i] = -1;
    }
  }
}
 
bool check(int pos, int* sid, char col) {
  auto& seg = segments[sid[pos]];
  auto& rest = (col == '0' ? seg.first : seg.second);
  if (rest) {
    --rest;
    return true;
  }
  return false;
}
 
int collect(pii& a, pii& b) {
  if (a.first && b.first) {
    --a.first, --b.first;
    return true;
  }
  if (a.second && b.second) {
    --a.second, --b.second;
    return true;
  }
  return false;
}
 
void solve() {
  scanf("%d", &n);
  scanf("%s", sa);
  scanf("%s", sb);
  scanf("%s", ta);
  scanf("%s", tb);
   
  int seg_cnt = 0;
  label(seg_cnt, sa, ta, sid_a);
  label(seg_cnt, sb, tb, sid_b);
 
  int ans = 0;
  for (int i = 0; i < n; i++) {
    if (ta[i] == '0' && tb[i] == '0') {
      ans += sa[i] == sb[i];
    } else if (ta[i] == '0') {
      ans += check(i, sid_b, sa[i]);
    } else if (tb[i] == '0') {
      ans += check(i, sid_a, sb[i]);
    }
  }
  for (int i = 0; i < n; i++) {
    if (ta[i] == '1' && tb[i] == '1') {
      ans += collect(segments[sid_a[i]], segments[sid_b[i]]);
    }
  }
  segments.clear();
  printf("%d\n", ans);
}
 
int main() {
  scanf("%d", &T);
  while (T--) {
    solve();
  }
  return 0;
}

Problem B 遗失的赋值

　　容易注意到，对于值未确定的 $x_i$ ，施加在 $x_i$ 和 $x_{i + 1}$ 上的限制一定可以让其不生效。

　　设 $f_{i, 0/1}$ 表示考虑了前 $i-1$ 个限制， $x_i$ 的值是否是确定的，此时的方案数。

当转移到一个非确定的 $x$ 时，转移矩阵如下：
$\left ( \begin{matrix} v^2 & 0 \\ v(v-1) & v \end{matrix} \right )$
当转移到一个确定的 $x$ 时，由于 $f_{i, 0} = 0$ ，只需要确定一下 $f_{i, 1}$ 。容易得到 $f_{i, 1} = f_{i-1, 0} v^2 + f_{i - 1, 1}(v(v-1) + 1)$

　　对于前一部分简单推一下式子可以得到， $L$ 个矩阵相乘的结果为：
$\left ( \begin{matrix} v^{2L} & 0 \\ v^L(v^L-1) & v^L \end{matrix} \right )$
　　从一个确定的 $x_i$ 转移到另一个确定的 $x_j$ ，首先通过第一种转移走 $j - i - 1$ 步，再通过第二种转移走 1 步。

　　对于答案为 0 的情况需要特判。

Code

100

101

102

103

104

105

106

107

108

#include <bits/stdc++.h>
using namespace std;
 
class Input {
  public:
} in;
 
#define _isdigit(_x) ((_x) >= '0' && (_x) <= '9')
 
Input& operator >> (Input& in, int& x) {
  char u;
  while (~(u = getchar()) && !_isdigit(u));
  for (x = u - '0'; ~(u = getchar()) && _isdigit(u); x = x * 10 + u - '0');
  return in;
} 
 
#define ll long long
 
const int Mod = 1e9 + 7;
 
class Zi {
  public:
    int v;
 
    Zi(int v = 0) : v(v) {  }
    Zi(ll x) : v(x % Mod) { }
 
    friend Zi operator + (Zi a, Zi b) {
      int x = a.v + b.v;
      return (x >= Mod) ? (x - Mod) : x;      
    }
    friend Zi operator - (Zi a, Zi b) {
      int x = a.v - b.v;
      return (x < 0) ? (x + Mod) : x;      
    }
    friend Zi operator * (Zi a, Zi b) {
      return 1ll * a.v * b.v;
    }
};
 
Zi qpow(Zi a, int p) {
  Zi rt = 1;
  for ( ; p; p >>= 1, a = a * a) {
    if (p & 1) {
      rt = rt * a;
    }
  }
  return rt;
}
 
int T;
int n, m, v;
vector<pair<int, int>> raw_input;
vector<int> a;
 
void solve() {
  raw_input.clear();
  a.clear();
 
  in >> n >> m >> v;
  for (int i = 1, c, d; i <= m; i++) {
    in >> c >> d;
    raw_input.emplace_back(c, d);
  }
  sort(raw_input.begin(), raw_input.end());
  for (int i = 1; i < m; i++) {
    if (raw_input[i].first == raw_input[i - 1].first && raw_input[i].second != raw_input[i - 1].second) {
      puts("0");
      return;
    }
  }
  for (int i = 0; i < m; i++) {
    if (!i || raw_input[i].first != raw_input[i - 1].first) {
      a.push_back(raw_input[i].first);
    }
  }
 
  Zi v2 = Zi(v) * v, v3 = Zi(v) * (v - 1);
  Zi f0 = 0, f1 = qpow(v2, a[0] - 1), g0, g1;
  for (int i = 1; i < (signed) a.size(); i++) {
    int L = a[i] - a[i - 1];
    if (L == 1) {
      g0 = 0;
      g1 = f0 * v2 + f1 * (v3 + 1); 
    } else {
      // (L - 1) steps
      auto vL = qpow(v, L - 1);
      g0 = f0 * qpow(v2, L - 1) + f1 * vL * (vL - 1);
      g1 = f1 * vL;
      f0 = g0, f1 = g1;
 
      g0 = 0;
      g1 = f0 * v2 + f1 * (v3 + 1);
    }
    f0 = g0, f1 = g1;
  }
  int an = a.back();
  Zi ans = (f0 + f1) * qpow(v2, n - an);
  printf("%d\n", ans.v);
}
 
int main() {
  in >> T;
  while (T--) {
    solve();
  }
  return 0;
}

Problem C 树的遍历

　　先考虑 $k = 1$ 的情况，我们将边视为一个点，在原树上有公共点的边在新图上有边相连。题目问的是在这个新图的上的 dfs 生成树。

　　假设从橘色边开始，加入先选择了遍历和 $2$ 相邻的点的边，假如接下来是 $(2, 3)$ ，那么需要把剩下所有和 2 相连的边全部遍历完才能从 $(2, 3)$ 回溯。最终与 $2$ 相邻的边在 dfs 生成树上会构成一条链。

　　可以观察到对于每个点，都可以为与它相邻的边选择它们最终构成的链的顺序，除了要求距离根最近的一条边必须为环上第一个点。

　　因此方案数为 $\prod_p (d_p - 1) !$

　　我们接着考虑怎么判定一棵生成树能否由某一条边生成。容易想到我们只需要所有点，每个点在分配周围的边的顺序的时候，将离根最近的一条边作为第一条边。

　　容易把这个结论拓展到某个边集，要求生成树能被边集中任意一条边生成。考虑两条边的情况下，要求这两条边的链上每条边在端点的环中被选择为第一个或者最后一个。因此如果边集在一条链上，那么方案数为 $\prod_p (d_p - 1 - [p 在链内部])!$

　　剩下的问题很简单了，考虑容斥。硬点一个边集要求这个边集中每个边都能以它为根得到生成树，计算这样的生成树的数量，容斥系数为 $(-1)^{边集大小 - 1}$ 。

　　这个直接树形 dp 即可。每个点有 3 种状态，当前不处于链上，当前处于链中间，子树内存在完整的链。转移的时候有一个小细节，如果当前点为链中间，当前点最后乘上的系数为 $(deg - 2)!$ 。在特殊边的时候决策这条边是否被硬点，硬点需要乘上系数 $-1$ 。

Code

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

#include <bits/stdc++.h>
using namespace std;
 
class Input {
  public:
} in;
 
#define _isdigit(_x) ((_x) >= '0' && (_x) <= '9')
 
Input& operator >> (Input& in, int& x) {
  char u;
  while (~(u = getchar()) && !_isdigit(u));
  for (x = u - '0'; ~(u = getchar()) && _isdigit(u); x = x * 10 + u - '0');
  return in;
} 
 
#define ll long long
 
const int Mod = 1e9 + 7;
 
class Zi {
  public:
    int v;
 
    Zi(int v = 0) : v(v) {  }
    Zi(ll x) : v(x % Mod) { }
 
    friend Zi operator - (Zi a) {
      return Zi(0) - a;
    }
    friend Zi operator + (Zi a, Zi b) {
      int x = a.v + b.v;
      return (x >= Mod) ? (x - Mod) : x;      
    }
    friend Zi operator - (Zi a, Zi b) {
      int x = a.v - b.v;
      return (x < 0) ? (x + Mod) : x;      
    }
    friend Zi operator * (Zi a, Zi b) {
      return 1ll * a.v * b.v;
    }
};
 
Zi qpow(Zi a, int p) {
  Zi rt = 1;
  for ( ; p; p >>= 1, a = a * a) {
    if (p & 1) {
      rt = rt * a;
    }
  }
  return rt;
}
 
const int N = 1e5 + 5;
 
int n, K;
bool is_selected[N];
vector<pair<int, int>> G[N];
 
Zi fac[N];
Zi f[N], g[N], h[N];
 
void dfs(int p, int fa, bool special) {
  f[p] = 1, g[p] = 0, h[p] = 0;
  Zi newh = 0;
  for (auto [e, id] : G[p]) {
    if (e == fa) {
      continue;
    }
    dfs(e, p, is_selected[id]);
    Zi nf = f[p] * f[e];
    Zi ng = f[p] * g[e] + g[p] * f[e];
    Zi nh = f[p] * h[e] + h[p] * f[e];
    newh = newh * f[e] + g[p] * g[e]; 
    f[p] = nf, g[p] = ng, h[p] = nh;
  }
  int deg = G[p].size();
  f[p] = f[p] * fac[deg - 1];
  if (deg >= 2) {
    g[p] = g[p] * fac[deg - 2];
    newh = newh * fac[deg - 2];
  } else {
    g[p] = 0;
    newh = 0;
  }
  h[p] = h[p] * fac[deg - 1] + newh;
 
  if (special) {
    h[p] = h[p] - f[p] - g[p];
    g[p] = -f[p];
  }
}
 
void solve() {
  in >> n >> K;
  fac[0] = fac[1] = 1;
  for (int i = 2; i <= n; i++) {
    fac[i] = fac[i - 1] * i;
  }
  for (int i = 1, u, v; i < n; i++) {
    in >> u >> v;
    G[u].emplace_back(v, i);
    G[v].emplace_back(u, i);
  }
  for (int i = 1, x; i <= K; i++) {
    in >> x;
    is_selected[x] = true;
  }
  dfs(1, 0, false);
  Zi ans = -h[1];
  printf("%d\n", ans.v);
 
  fill(is_selected, is_selected + n + 1, false);
  for (int i = 1; i <= n; i++) {
    G[i].clear();
  }
}
 
int main() {
  int _, T;
  in >> _ >> T;
  while (T--) {
    solve();
  }
  return 0;
}

Problem D 树上查询

　　考虑 $m$ 个点的 lca 的等于相邻两个点的 lca 的深度最低的一个。证明考虑 $m$ 点的 $lca$ 一定存在两个点在它的不同子树，从一边刚走到另一边时这对点的 lca 即是所求。

　　问题其实等价于给一个长度为 $n - 1$ 的序列，每次询问一个区间中任意长度大于等于 $k - 1$ 连续子区间的最小值最大能有多少。（需要特判 $k=1$ 的时候）

　　整体二分即可获得一个 $O(n\log^2 n )$ 的做法。

　　考虑把这些数从大到小加入进来，每加入一个数会获得一个区间， $([l', r'], d)$ ， $[l', r’]$ 是此时与之连通的数的区间， $d$ 是当前这个数的值，也就是这段数的最小值。显然总共有 $O(n)$ 个区间。

　　那么对于每个询问相当于是询问所有和 $[l, r-1]$ 的交超过长度超过 $k - 1$ 的区间，它的 $d$ 的最大值有多少。为了简洁，我们下面不再考虑这几个 $-1$ 的问题。（你也可以将上面的区间改成 $[1, n]$ ，初始再加入 $1, 2, \cdots, n$ 来不考虑这个边界问题）

　　条件等价于 $\min(r', r) - \max(l', l) + 1\geqslant k$ 。讨论 $l', l$ 的大小。

如果 $l' > l$ ，那么有 $\min(r', r) - l' + 1 \geqslant k$ 。有 $r' - l' \geqslant k - 1, r-l' \geqslant k - 1$
所以有 $l <l' \leqslant r-k+1$ ，同时有 $r' - l' \geqslant k - 1$ 。按区间长度以及 $k$ 这一维扫描线即可，用线段树维护区间最大值。
如果 $l' \leqslant l$ ，那么有 $\min(r', r) - l + 1 \geqslant k$ ， $r$ 显然是满足的，那么有 $r' - l + 1 \geqslant k$ ，即 $r' \geqslant l+k-1$ 。
按 $l$ 扫描线，用线段树维护区间最大值即可。

　　总时间复杂度 $O((n+q)\log n)$

Code

posted @ 2024-12-05 00:29 阿波罗2003 阅读(181) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· Good Bye 2022 简要题解

· AtCoder Grand Contest 057 简要题解

· NOIP 2024 题解

· 【2024.09.15】NOIP2024 赛前集训（2）

· 2024 Noip 做题记录（七）

阅读排行：
· 地球OL攻略 —— 某应届生求职总结
· 周边上新：园子的第一款马克杯温暖上架
· Open-Sora 2.0 重磅开源！
· 提示词工程——AI应用必不可少的技术
· .NET周刊【3月第1期 2025-03-02】

公告

5:18:36

星期六

Notice

部分随笔中的latex公式可能挂掉(以前是直接在在线公式编辑器上复制的图片)，如果遇到，(如果您愿意的话)请在评论区指出
一些以前的非常naive的随笔可能会被隐藏
新 blog（还在施工中，但应该不会再更算法竞赛相关的内容了）：点我跳转
个人 P 站主页（但还没几张画），欢迎来玩 [点我跳转]

一言（ヒトコト）

人生在世不称意，不如自挂东南枝

——十万个冷笑话

于2018.3.3被置于公告栏的计数器菌（不过好像 FlagCounter 现在被园子封了，现在只有被封前的数据了 /kk）

昵称：阿波罗2003
园龄： 8年8个月
粉丝： 85
关注： 19

+加关注

2025年3月

日

一

二

三

四

五

六

NOIP 2024 简要题解

从这里开始

Problem A 编辑字符串

Code

Problem B 遗失的赋值

Code

Problem C 树的遍历

Code

Problem D 树上查询

Code

公告

搜索

常用链接

我的标签

随笔分类

随笔档案

一些奇怪的网站

阅读排行榜

推荐排行榜

最新评论

千古神犇

我身边的小伙伴们

外校的朋友们