省队集训Ⅱ-Day4

Day4

Gp

原题: Joi 2012 Kangaroo

$300$ 个套娃, 容量 $Contain$ 一定小于体积 $Size$ , 一个匹配是指不存在还有套娃能放在另一个套娃中的情况. 给出每个套娃的 $Size$ 和 $Contain$ , 求合法的不同的匹配情况数量对 $10^9 + 7$ 取模的结果.

考场思路: 把每个套娃拆成两个点, 一个是它的 $Size$ , 一个是它的 $Contain$ , 形成一个二分图, 每个 $Size$ 点向能装下它的 $Contain$ 点连边.

排序不亏: 分别排序 $Size$ 和 $Contain$ , 由于排序后, $Size$ 自增, 所以可以直接将 $Size$ 小的点的边的后继连到相邻的 $Size$ 比它大的点的 $Fst$ 上, 这样实际连接的边数就是 $O(n)$ 条, 就能完成 $O(n^2)$ 种转移.

大暴搜: 枚举每个 $Size$ 点, 在当前能选的转移边里选一个来匹配, 当然什么都不选也是一种情况, 每次到边界的时候, 判断是否有可用的边没连, 如果有, 则匹配情况不合法, 否则统计一次.

欣赏一下考场大暴搜:

unsigned n, m, Ans(0), The(0), Sq;
char flg(0), Ed[305];
struct WN {
  unsigned Size, Contain; 
  const inline char operator<(const WN &x) const{
    return this->Size > x.Size; }
}W[305];
struct Node {
  Node *Fst, *Nxt; char Have;
}N[605];
char Judge () {
  for (register unsigned i(n); i; --i)
    if(!(N[i].Have)) {
      register Node *now(N[i].Fst);
      while (now) {
        if(!(now->Have)) return 0;
        now = now->Nxt; }
      return 1; }
  return 1;
}
unsigned long long BigDFS(Node *x) {
  if(x > N + n) return Judge();
  register unsigned long long CntCases(BigDFS(x + 1));
  register Node *now(x->Fst);
  x->Have = 1;
  while(now) {
    if(!(now->Have))
      now->Have = 1, CntCases += BigDFS(x + 1), now->Have = 0;
    now = now->Nxt; }
  x->Have = 0;
  return CntCases % MOD;
}
int main() {
  n = RD();
  for (register unsigned i(1); i <= n; ++i)
    W[i].Size = RD(), W[i].Contain = RD();
  sort(W + 1, W + n + 1);
  for (register unsigned i(1); i <= n; ++i) {
    N[i].Fst = N[i - 1].Fst;
    for (register unsigned j(1); j <= n; ++j)
      if(!Ed[j]) if(W[j].Contain > W[i].Size)
          N[j + n].Nxt = N[i].Fst, N[i].Fst = N + j + n, Ed[j] = 1; }
  printf("%llu\n", BigDFS(N + 1));
  return 0;
}

考试结束的时候发现, 由于连边单调性, 用数组代替边表, 左部点右部点分别存入不同的数组, 只存 $Size_i$ 能连接的 $Contain$ 最小的右部点.

unsigned n, m, Ans(0), The(0), Sq;
char flg(0);
struct NodeS; 
struct Node {
  NodeS *Fst; unsigned Size; char Have;
  const inline char operator <(const Node &x) const {
    return this->Size < x.Size;}
}N[305];
struct NodeS {
  unsigned Contain; char Have;
  const inline char operator <(const NodeS &x) const{
    return this->Contain < x.Contain;}
}NS[305];
char Judge () {
  for (register unsigned i(1); i <= n; ++i)
    if(!(N[i].Have)) {
      for (register NodeS *j(N[i].Fst); j <= NS + n; ++j)
        if(!(j->Have)) return 0;
      return 1; }
  return 1;
}
unsigned long long BigDFS(Node *x) {
  if(x == N) return Judge();
  register unsigned long long CntCases(BigDFS(x - 1));
  x->Have = 1;
  for (register NodeS *i(x->Fst); i <= NS + n; ++i) if(!(i->Have))
    i->Have = 1, CntCases += BigDFS(x - 1), i->Have = 0;
  x->Have = 0;
  return CntCases % MOD;
}
int main() {
  n = RD();
  for (register unsigned i(1); i <= n; ++i)
    N[i].Size = RD(), NS[i].Contain = RD();
  sort(N + 1, N + n + 1), sort(NS + 1, NS + n + 1);
  N[n + 1].Fst = NS + n + 1, NS[n + 1].Contain = 0x3f3f3f3f;
  for (register Node *i(N + n); i > N; --i) {
    i->Fst = (i + 1)->Fst;
    while((i->Fst - 1)->Contain > i->Size) --(i->Fst);
  }
  printf("%llu\n", BigDFS(N + n));
  return 0;
}

接下来是正解: DP

仍然是一个套娃拆成两个独立的点, $Size$ 和 $Contain$ 分别排序.

定义 $CntAfter_{i, j, k}$ 指的是在 $[i, j]$ 中可供 $Size_k$ 选用匹配的 $Contain$ 数量, 也就是满足 $Contain_x > Size_k, x \in [i, j]$ 的 $x$ 数量.

定义 $CntBefore_{i, j, k}$ 指的是在 $[i, j]$ 中可以匹配 $Contain_{k}$ 的 $Size$ 数量, 也就是满足 $Contain_k > Size_x, x \in [i, j]$ 的 $x$ 数量.

枚举一个分界点 $Mid$ , 作为从从左到右第一个没有匹配的 $Size$ , $Size_{Mid}$ 没有任何匹配, 这时, $Contain_i > Size_{Mid}$ 都应该有匹配, 否则如果有 $Contain_i > Size_{Mid}$ 且没有匹配, 那么 $Size_{Mid}$ 和 $Contain_i$ 就可以匹配, 原方案不合法. 对于 $Size_x, x \in [1, Mid - 1]$ , 都一定有匹配, 这是 $Mid$ 的定义.

对于 $i, j \in [1, Mid - 1]$ , $Size_i$ 和 $Contain_j$ 互相匹配后的方案数可以通过 $O(Mid^2)$ 的 DP 求出, 设 $f_{i, j}$ 表示对于 $[i, Mid - 1]$ 的 $Size$ 和 $[1, Mid]$ 的 $Contain$ 一共有 $j$ 对匹配的方案数, 写出方程:

f_{i, j} = f_{i + 1, j} + f_{i + 1, j - 1} * (C n t A f t e r_{1, M i d, i} - j + 1)

$f_{i, j} = f_{i + 1, j} + f_{i + 1, j - 1} * (CntAfter_{1, Mid, i} - j + 1)$

解释: $f_{i + 1, j}$ 是第 $Size_i$ 不进行匹配的贡献, $CntAfter_{1, Mid, i} - j + 1$ 是可供选择的数量减去已经选择的数量, 也就是当前的选择数量, 乘法原理是因为不管是 $f_{i + 1, j - 1}$ 包含的哪种情况, 都有这么多选择.

接下来, 设 $Left$ 为满足 $Contain_{Left} > Size_{Mid}$ 的最小下标. 接下来是 $g_{i, j}$ 表示对于 $[Left, i]$ 的 $Contain$ 和 $[Mid + 1, n]$ 的 $Size$ 一共有 $j$ 对匹配的方案数, 写出方程:

g_{i, j} = g_{i - 1, j} + g_{i - 1, j - 1} * (C n t B e f o r e_{M i d + 1, n, i} - j + 1)

$g_{i, j} = g_{i - 1, j} + g_{i - 1, j - 1} * (CntBefore_{Mid + 1, n, i} - j + 1)$

解释: 和 $f_{i, j}$ 对称, 非常漂亮.

好了, 求得了 $f$ 和 $g$ , 接下来对于枚举到的 $Mid$ 对答案进行计算. 枚举一个 $i$ , 表示 $Size_x, x \in [1, Mid - 1]$ 匹配 $Contain_y, y \in [Left, n]$ 的对数. 这时的合法情况的数量应该是 $f_{1, Mid - i - 1} * g_{n, n - Left + 1 - i} * i!$ , 因为 $[1, Mid - 1]$ 中, 有匹配的 $Size$ 应该是 $Mid - 1$ 也就是全部匹配, 所以需要和 $Contain_x, x \in [Left, n]$ 匹配, 而这根据单调性是可以随便连的, 而 $i$ 的全排列恰好是 $i!$ , 所以加入 $Ans$ 即可.

被改得面目全非的 AC 代码:

unsigned n, Size[305], Contain[305], CntAfter[305], CntBefore[305], f[305][305], g[305][305], Left, Factorial[305];
unsigned long long Ans(0);
char flg(0);
int main() {
  n = RD(), Factorial[0] = 1;
  for (register unsigned i(1); i <= n; ++i) Size[i] = RD(), Contain[i] = RD();
  for (register unsigned i(1); i <= n; ++i) Factorial[i] = (unsigned long long)Factorial[i - 1] * i % MOD;
  sort(Size + 1, Size + n + 1); sort(Contain + 1, Contain + n + 1);
  f[n][0] = 1; 
  g[1][0] = 1;
  Contain[n + 1] = 0x3f3f3f3f;
  Left = 1;
  for (register unsigned Mid(1); Mid <= n; ++Mid) {
    memset(f, 0, sizeof(f));
    memset(g, 0, sizeof(g));
    CntAfter[Mid] = CntBefore[Left - 1] = 0;
    for (; Contain[Left] <= Size[Mid]; ++Left) {}
    for (register unsigned i(Mid - 1); i; --i) {
      CntAfter[i] = CntAfter[i + 1];
      while (Size[i] < Contain[Left - CntAfter[i] - 1]) ++CntAfter[i];
    }
    for (register unsigned i(Left); i <= n; ++i) {
      CntBefore[i] = CntBefore[i - 1];
      while(Size[Mid + 1 + CntBefore[i]] < Contain[i]) ++CntBefore[i];
    }
    f[Mid][0] = 1;
    for (register unsigned i(Mid - 1); i; --i) {
      f[i][0] = f[i + 1][0];
      for (register unsigned j(1); j <= CntAfter[i]; ++j) {
        f[i][j] = f[i + 1][j]; // 不拿 
        f[i][j] += (unsigned long long)f[i + 1][j - 1] * (CntAfter[i] - j + 1) % MOD; // 拿
        if(f[i][j] >= MOD) f[i][j] -= MOD;
      }
    }
    g[Left - 1][0] = 1;
    for (register unsigned i(Left); i <= n; ++i) {
      g[i][0] = g[i - 1][0];
      for (register unsigned j(1); j <= CntBefore[i]; ++j) {
        g[i][j] = g[i - 1][j];
        g[i][j] += (unsigned long long)g[i - 1][j - 1] * (CntBefore[i] - j + 1) % MOD;
        if(g[i][j] >= MOD) g[i][j] -= MOD;
      }
    }
    for (register unsigned i(min(n - Left + 1, Mid - 1)); i < 0x3f3f3f3f; --i)
      Ans += ((unsigned long long)f[1][Mid - 1 - i] * g[n][n - Left + 1 - i] % MOD) * Factorial[i] % MOD;
  }
  printf("%llu\n", Ans % MOD);
  return 0;
}

考后从 $19:00$ 写到 $24:00$ , 第二天从 $5:30$ 写到 $7:00$ , 中午又写了 $30min$ 才过, 本来无脑 DP 竟然有这么多细节...

其实这个题能 $O(4n^2)$ 做, 将拆点后的 $O(2n)$ 个点放到一起排序. 然后在这上面跑序列 DP, $O(n^2)$ 状态, $O(1)$ , 转移.

Of

在 $n*m$ 网格上选择尽量多的格点 (必须包含 $(0,0)$ 和 $(n, m)$ ), 依次连接形成下凸包, 求点数.

考场上一眼看到这个题可以剪枝暴搜. 正解想推式子 $O(n^2)$ 预处理, $O(1)$ 回答询问. 答案的分布看起来像是反比例函数, 可是连 $Geogebra$ 都找不到规律.

最后还是交的暴搜:

unsigned n, m, t;char flg(0);
unsigned DFS(unsigned x, unsigned y, unsigned Beforex, unsigned Beforey) {
  if(x == 1 || y == 1) if((x * (Beforey - y)) > (y * (Beforex - x)))
      return ((x * (Beforey - y)) > (y * (Beforex - x))) ? 2 : 0;
  unsigned CntPnt(2);
  for(register unsigned i(x - 1), Top(y - 1), Bot(y - 1); i; --i) {
    while (((y - Top) * x) <= ((x - i) * y)) --Top;
    while (Bot && (((x - i) * (Beforey - y)) > ((y - Bot) * (Beforex - x)))) --Bot;
    ++Bot;
    if(((x - i) * (Beforey - y)) <= ((y - Bot) * (Beforex - x))) break;
    for (register unsigned j(Bot), TmpD; j <= Top; ++j) {
      TmpD = DFS(i, j, x, y) + 1;
      if(TmpD > CntPnt) CntPnt = TmpD;
    }
  }
  return CntPnt;
}
int main() {
  t = RD();
  for (register unsigned T(1); T <= t; ++T) {
    n = RD(), m = RD();
    if(((m * (m + 1)) >> 1) <= n) {printf("%u\n", m + 1); continue;}
    printf("%u\n", DFS(n, m, n + 1, 6000));
  }
  return 0;
}

正解是枚举 $O(n^2)$ 个横纵坐标互质的二维向量, 然后枚举选择哪些向量, 让它们的和等于 $(n, m)$ , 直接写是 $O(n^4)$ . 通过剪枝将向量数量压到 $O(n^{\frac 23})$ 这样复杂度就压到了 $O(n^{\frac 73})$ .

Dls

一个序列, 两端是 $\infin$ , 每个元素有对应的点, 每个元素 $i$ 的点向它左边第一个值 $\geq a_i$ 的元素或右边第一个 $> a_i$ 的元素连无向边.

支持单点修改, 每次修改求无向图上不同的六元环个数.

由于此题难度过于离谱, 以至于手玩都不会求静态六元环, 更别说带修计数了, 所以直接就没写.

Bitset Master

一棵集合构成的树, 一开始每个节点对应的集合之有一个元素, 也就是这个点, 支持:

查询包含点 $x$ 的集合数

将树上的某条边两端的集合设为这两个集合的并

考虑一个集合 $x$ 包含点 $y$ 的条件. 必须存在一个操作序列, 依次合并 $y$ 到 $x$ 路径上每条边.

离线. 从上往下, 用 DP 求出每个点被根的集合包含的最早时间, 自己最早到根的时刻是到父亲之后, 父亲的最早的到根的操作序列的时刻.

将每个点按到根时间排序, 容易知道后代一定不会比祖先提前到达. 根不同的子树中的节点要想包含对方, 必须先到达根. 使用点分治 + 扫描线 + DFS 维护, 总复杂度 $O((n + m)log^2n)$

Cyclic Distance

边带权的树, 求一个包含 $k$ 个点的点集, 求一个点集中点的排序, 使相邻两点的距离和的最小值 (规定点 $1$ 和点 $k$ 相邻).

枚举点集的重心, 再构造出以这个点为重心的点集, 然后再求最小距离和.

考虑优化, 一个节点的子树大小超过这个点的子树的一半, 则要重心在这个子树中不会使答案更劣. 用数据结构可以优化到 $O(nlogn)$ .

posted @ 2021-06-03 23:05 Wild_Donkey 阅读(145) 评论(0) 编辑收藏举报

刷新页面返回顶部

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

阅读排行：
· winform 绘制太阳，地球，月球运作规律
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· AI 智能体引爆开源社区「GitHub 热点速览」
· Manus的开源复刻OpenManus初探
· 写一个简单的SQL生成工具

公告

昵称： Wild_Donkey
园龄： 5年9个月
粉丝： 31
关注： 11

+加关注

2025年3月

日

一

二

三

四

五

六

Wild Donkey

学 OI 4 年

省队集训Ⅱ-Day4

Day4

Gp

Of

Dls

Bitset Master

Cyclic Distance

公告

常用链接

最新随笔

我的标签

积分与排名

随笔档案 (187)

阅读排行榜

评论排行榜

推荐排行榜

最新评论

快讯：fys NOI2022 Au！！！

orz

$%%%% stO FYS Orz %%%$