2025-7-24 总结

1. 分享会

\(\qquad\)信息学学习如同培育参天大树，这个过程需要系统性的规划与持之以恒的努力。首先，每日的算法练习是根基所在，就像树木吸收养分一样，通过 \(\text{VJudge}\)、洛谷等平台的刷题训练，可以夯实基础数据结构与经典算法。其次，独立思考能力如同树干，需要培养对复杂问题的分析能力，例如通过拆解竞赛题目来锻炼逻辑思维。团队协作则如同枝叶的交错，参与编程竞赛或开源项目时，与队友的代码评审和思路碰撞往往能发现个人思维的盲区。老师的指导犹如园丁的修剪，能及时纠正学习路径的偏差，特别是在学习困难算法时，专业点拨往往事半功倍。
\(\qquad\)初中阶段是信息学学习的关键期，要从三方面着手：首先确立明确目标，如通过 \(CSP\) 和 \(NOIP\) 掌握 \(c++\) 算法，制定每天的编程计划；其次坚持实践训练，每天完成指定编程题，建立错题本记录调试过程；最后要拓展视野，参加一些高校的比赛、巨佬们的经验分享会，重点培养计算思维和持续学习的能力。
\(\qquad\)在竞赛训练中培养良好习惯至关重要。面对难题时，首先要保持冷静思考，尝试多种解题思路，争取独立完成。若确实无法解出，也应通过部分分策略争取更高得分，避免零分情况。赛后复盘环节尤为关键：需要系统整理错题，重点分析未掌握的知识点和算法缺陷，建立个人错题本。针对薄弱环节制定专项训练计划，通过刻意练习提升熟练度。同时要定期回顾经典题型，总结解题模板和优化技巧。这种"赛前充分准备-赛中灵活应对-赛后深度反思"的闭环训练模式，能有效提升竞赛水平，使得在正式比赛中更加从容应对各类题型，发挥最佳状态。

2. 改题（数据复习 \(2\)，贪心构造交互思维，模拟赛 \(1\)）

H - 传送（数据复习 \(2\)）

1、算法思想维度

问题类型：并查集，线段树分治
做题思路：看到一条边在某一时间段内生效的问题，第一时间想到线段树分治结合可撤销并查集求解，然后分治到叶子节点时，给 \(1\) 所在的连通块加上叶子节点的时刻即可。

2、实现细节维度

记得初始化！！！\(fa_i\) 要定义为 \(i\)！！！

核心代码

void G(int p, int l, int r, int &L, int &R, int &u, int &v) {
  if (L <= l && r <= R) {
    return e[++cnt_edge] = {u, v, head[p]}, head[p] = cnt_edge, void(0);
  }
  int mid = l + r >> 1;
  (mid >= L) && (G(p << 1, l, mid, L, R, u, v), 0);
  (mid < R) && (G(p << 1 | 1, mid + 1, r, L, R, u, v), 0);
}

void D(int p, int l, int r) {
  int x = dsu.top;
  for (int i = head[p]; i; i = e[i].nxt) {
    dsu.M(e[i].u, e[i].v);
  }
  if (l == r) {
    return dsu.tag[dsu.F(1)] += l, dsu.D(x), void(0);
  }
  int mid = l + r >> 1;
  D(p << 1, l, mid), D(p << 1 | 1, mid + 1, r), dsu.D(x);
}

3、数学建模维度

复杂度计算：

• 添加次数：\(O(m)\)
• 线段树：\(O(\log n)\)
• 查询次数：\(O(2n)\)
• 并查集：\(O(\log n)\)
• 总复杂度：\(O(n\log n)\)

I - T-Shirts（数据复习 \(2\)）

1、算法思想维度

问题类型：平衡树
做题思路：使用平衡树维护所有人之间的钱的顺序，每次将平衡树分成三部分，\([0,c)\) 不改变，\([c,2c)\) 直接暴力减去 \(c\) 插入到 \([0,c)\) 之间，\([2c,+\infty)\) 直接打上 \(−c\) 的标记。

2、实现细节维度

核心代码

void U(int x) { t[x].siz = t[t[x].r].siz + t[t[x].l].siz + 1; }

int A(int x, int id, int y) { return t[++top].siz = 1, t[top].val = x, t[top].res = y, t[top].id = id, t[top].rnk = rd(), top; }

void P(int k) {
  if (t[k].tag) {
    (t[k].l) && (t[t[k].l].res += t[k].tag, t[t[k].l].tag += t[k].tag, d[t[t[k].l].id] = t[t[k].l].res);
    (t[k].r) && (t[t[k].r].res += t[k].tag, t[t[k].r].tag += t[k].tag, d[t[t[k].r].id] = t[t[k].r].res);
    t[k].tag = 0;
  }
  if (t[k].cst) {
    (t[k].l) && (t[t[k].l].val -= t[k].cst, t[t[k].l].cst += t[k].cst);
    (t[k].r) && (t[t[k].r].val -= t[k].cst, t[t[k].r].cst += t[k].cst);
    t[k].cst = 0;
  }
}

void S(int cur, int& x, int& y, int v) {
  if (!cur) {
    return x = y = 0, void(0);
  }
  P(cur), (t[cur].val <= v) ? (x = cur, S(t[cur].r, t[cur].r, y, v)) : (y = cur, S(t[cur].l, x, t[cur].l, v)), U(cur);
}

void M(int& cur, int a, int b) {
  if (!a || !b) {
    return cur = a | b, void(0);
  }
  P(cur), (t[a].rnk < t[b].rnk) ? (cur = a, M(t[a].r, t[a].r, b)) : (cur = b, M(t[b].l, a, t[b].l)), U(cur);
}

void I(int& k, int x, int id, int y) {
  int a = 0, b = 0, cur = A(x, id, y);
  S(k, a, b, x), M(a, a, cur), M(k, a, b);
}

for (int i = 1, x; i <= m; i++) {
  cin >> x, I(rt, x, i, 0);
}
for (int i = 1, a = 0, b = 0, d = 0, e = 0; i <= n; i++, a = b = d = e = 0) {
  S(rt, a, b, c[i].second - 1), A(b, c[i].second), S(b, d, e, c[i].second * 2 - 1), R(a, d), M(rt, a, e);
}
L(rt);

3、数学建模维度

复杂度计算：

• 建树：\(O(n\log n)\)
• 查询次数：\(O(n)\)
• 查询：\(O(\log n)\)
• 总复杂度：\(O(n\log n)\)

I - Robotic Cow Herd P（贪心构造交互思维）

1、算法思想维度

问题类型：构造
做题思路：我们发现点 \(p\) 有三种转移情况，这样我们可以直接枚举，所以就可以做出来了。

2、实现细节维度

在操作之前，为了使结果更优，要排序。

核心代码

for (int i = 1; i <= n; i++) {
  cin >> p[i].len;
  for (int j = 1; j <= p[i].len; j++) {
    cin >> p[i].d[j];
  }
  p[i].d[p[i].len + 1] = 1e15, sort(p[i].d + 1, p[i].d + p[i].len + 1);
  p[i].val = p[i].d[2] - p[i].d[1], ans += p[i].d[1];
}
sort(p + 1, p + n + 1, [](Node x, Node y) { return x.val < y.val; });
q.push({ans - p[1].d[1] + p[1].d[2], 1, 2});
for (int i = 1; i < k; i++) {
  node u = q.top();
  q.pop(), ans += u.val, q.push({u.val - p[u.x].d[u.y] + p[u.x].d[u.y + 1], u.x, u.y + 1});
  if (u.x != n) {
    q.push({u.val - p[u.x + 1].d[1] + p[u.x + 1].d[2], u.x + 1, 2});
  }
  if (u.x != n && u.y == 2) {
    q.push({u.val - p[u.x + 1].d[1] + p[u.x + 1].d[2] - p[u.x].d[2] + p[u.x].d[1], u.x + 1, 2});
  }
}

3、数学建模维度

复杂度计算：

• 排序：\(O(n\log n)\)
• 处理：\(O(k\log n)\)
• 总复杂度：\(O(n\log n)\)

D - 非负（模拟赛 \(1\)）

1、算法思想维度

问题类型：线段树，构造
做题思路：我们发现一个区间内合法的序列最长为这个区间的长度减去这个区间的最大字段和减总和的差，所以我们只要用一个线段树维护最大子段和即可。

2、实现细节维度

注意，最大子段和可以为 \(0\)。

核心代码

node U(node x, node y) {
  node z;
  z.l = x.l, z.r = y.r;
  z.ans = max({x.ans, y.ans, x.sum2 + y.sum1});
  z.sum = x.sum + y.sum;
  z.sum1 = max(x.sum1, x.sum + y.sum1);
  z.sum2 = max(y.sum2, y.sum + x.sum2);
  return z;
}

3、数学建模维度

复杂度计算：

• 建树：\(O(n\log n)\)
• 询问次数：\(O(n)\)
• 询问/更改：\(O(\log n)\)
• 总复杂度：\(O(n\log n)\)