PTYS错题

鸡魂传递

1、算法思想维度

问题类型：数学，二维偏序

误判原因：已经推出公式，没有考虑到正难则反，然后化为二维偏序。

正确思路：推出公式，然后将相交变成不相交，用离散化+树状数组计算顺序对。

2、实现细节维度

边界条件：注意 \(i\) 移动结束了也没碰到 \(j\) 开始，这种情况不是二维偏序，要单独处理。

解题框架

for (Pii o : q) {
    int t = o.first, x = o.second;
    int l = lower_bound(p.begin(), p.end(), Pii{t + x - s, -kInf}) - p.begin();
    int r = upper_bound(p.begin(), p.end(), Pii{t + s - x, kInf}) - p.begin();
    int pos = lower_bound(l_.begin(), l_.end(), x - t + s) - l_.begin() + 1;
    if (r >= 1) {
      v[r - 1].push_back({pos, 1});
    } if (l >= 1) {
      v[l - 1].push_back({pos, 0});
    }
  }

3、数学建模维度

复杂度计算：

• 构建二维偏序：\(O(n)\)
• 排序：\(O(n\log n)\)
• 二维偏序：\(O(n\log n)\)

4、改进措施

1. 要由条件思考方法，想怎样才能将式子化成相似类型。

2. 算力要加强，不能在求式子上浪费太多时间。

贤鱼爱鲲

1、算法思想维度

问题类型：二分、前缀和

误判原因：没想到一个区间延后的要求，导致只能写暴力。

正确思路：二分出第一个冲突的线段，由于延后的线段肯定是连续的，二分出最后一个延后的线段即可。

2、实现细节维度

边界条件：可以虚拟一个线段 \(\{2\times 10^9,2\times 10^9\}\)，放在 \(n + 1\)，使得代码更加简洁。

解题框架

  a[n + 1] = {2e9, 2e9};
  sort(a + 1, a + n + 1); // 按右端点排序
  for (int i = 1; i <= n; i++) {
    pre[i] = pre[i - 1] + a[i].first - a[i].second; // 计算前缀和
    t[i] = a[i + 1].second - pre[i];
  }
  for (int s, e; q--;) {
    cin >> s >> e;
    int p = lower_bound(a + 1, a + n + 1, Pii{s + 1, 0}) - a; // 找到冲突线段
    if (a[p].second >= e) { // 没有线段和他冲突
      cout << "0\n";
      continue;
    }
    cout << lower_bound(t + 1, t + n + 1, s - pre[p - 1] + e - s) - t - p + 1 << '\n'; // 找出最后一个延后的线段。
  }

3、数学建模维度

复杂度计算：

• 排序：\(n\log n\)。
• 二分：\(n\log n\)。
• 总复杂度：\(n\log n\)。

4、改进措施

1. 分析题目的性质，才能找出解法。

2. 对于求出答案困难判定简单，可以二分。

深度寻鲲

1、算法思想维度

问题类型判定：BFS、分层图。

误判原因：没计算复杂度，误以为Dijkstra可过。

正确思路：考虑值域范围很小，利用BFS性质，用 vector 存储每一层的状态，枚举层数去转移。

2、实现细节维度

边界条件：由于最优化属性最多只会增加 \(50\) 考虑只维护 \(d \mod 50\) 内的状态去转移，这样加入初始状态时需要根据当前值去动态增加，双指针即可，另外这题及其卡空需要使用 short。

解题框架

  memset(d, 0x3f, sizeof d);
  for (int d_ = 0, j = 1, c = p; c; d_++) { // 枚举最优化属性
    for (; j <= p && s[j].first == d_; e[d_ % kMaxK].push_back(s[j++].second)); // 双指针动态加入状态
    for (int i = 0; i < e[d_ % kMaxK].size(); i++) {
      Node o = e[d_ % kMaxK][i];
      if (o.x >= 1 && o.x <= n && o.y >= 1 && o.y <= m && o.t <= T && d_ < d[o.x][o.y][o.t]) { // 判断状态是否合法
        d[o.x][o.y][o.t] = d_;
        for (int i = 0; i < 4; i++, c++) {
          int nx = o.x + kD[i][0], ny = o.y + kD[i][1];
          e[(d_ + a[nx][ny]) % kMaxK].push_back({short(nx), short(ny), o.t + short(a[nx][ny] == 0)}); // 转移
        }
      }
    }
    c -= e[d_ % kMaxK].size();
    e[d_ % kMaxK].clear();
  }

3、数学建模维度

复杂度计算：

• 起始位置排序：\(O(p\log p)\)。
• 枚举最优化属性：\(O(nmv)\)。
• 双指针处理起始位置：\(O(p)\)。
• 状态数量 \(O(nmt)\)。
• 查询数量 \(O(q)\)，处理 \(O(t)\)，总共 \(O(qt)\)。
• 总复杂度：O(p\log p+nm(v+t)+q*t)。

4、解题框架提炼

1. 写完程序要计算时空复杂度，不要想当然。

2. 对于这类值域范围小的最短路，可以使用分层图，是第一次接触，平时没有举一反三，一题多解的行为。

3. 对于一些优化代码空间复杂度的 Trick 不是很了解。

天命悟鲲

1、算法思想维度

问题类型判定：最长上升子序列、回滚

误判原因：对最长上升子序列的了解不够深入，导致只能写暴力。

2、实现细节难度

边界条件：有 \(q[x] \le p[x]\) 的情况，这时答案为 \(0\)。

3、数学建模维度

复杂度计算：

• 从右往左枚举位置 \(O(n)\)。
• 求当前位置的最长下降子序列长度 \(O(\log n)\)。
• 记录长度序列中旧的信息并更新 \(O(1)\)。
• 从左往右枚举位置 \(O(n)\)。
• 求当前位置的最长上升子序列长度 \(O(\log n)\)。
• 更新左边长度序列的信息并重算贡献 \(O(1)\)。
• 回滚右边长度序列的信息并重算贡献 \(O(1)\)。
• 总时间复杂度为 \(n\log n\)。