tiankonguse blog

leetcode 周赛 518

2026-09-08T12:13:00+08:00

零、背景

这次比赛比较简单，但是我小错误比较多，没进去前百名。

本场题型概览如下。

A 题：模拟。
B 题：前缀和。
C 题：贪心。
D 题：网格DP。

一、恰好有 K 对相等相邻字符的循环移位数量

题意：给一个字符串，循环右移可以得到 n 个不同的字符串，问有多少个字符串恰好有 k 个相邻位置相等。

思路：模拟

按题意循环右移，然后暴力判断相邻位置相等的数量。
复杂度：O(n^2)

优化：复用上一次的信息。

每次右移，只有最左边与最右边的相邻位置发生变化。
具体来说，左边少了一个元素，可能会少一个相等的相邻位置。
右边多了一个元素，可能会多一个相等的相邻位置。
进行判断即可。
复杂度：O(n)

int countRotations(string s, const int K) {
  int n = s.size();
  s = s + s;
  int k = 0;
  for (int i = 1; i < n; i++) {
    if (s[i] == s[i - 1]) k++;
  }
  int ans = 0;
  for (int i = 0; i < n; i++) {
    if (s[i] == s[i + 1]) k--;
    if (s[i + n] == s[i + n - 1]) k++;
    if (k == K) ans++;
  }
  return ans;
}

二、统计好循环移位的数量

题意：给一个数组，循环右移可以得到 n 个不同的数组，问有多少个数组左一半的元素和严格大于后一半的元素和。

思路：前缀和

与第一题一样，数组翻倍，计算出前缀和。
然后枚举所有循环右移的数组，计算左右区间和，比较即可。

int ans = 0;
for (int i = 0; i < n; i++) {
  if (2 * (preSum[i + n / 2] - preSum[i]) > sum) ans++;
}
return ans;

三、统计机器人组数

题意：给 n 个机器人的起始位置和向右的速度，以及一个合并最大间距 D，问最后剩余几个机器人。
合并条件：如果两个机器人距离小于等于 D，则进行合并，合并后位置和速度继承右侧的机器人。
同时满足条件时，同时进行合并，没有先后顺序。

思路：贪心

同时满足条件时需要同时合并，从而可以推导出，合并必须从左到右进行。
可以先按距离对初始条件合并一轮，剩下的机器人在第 0 时刻就不满足合并条件了。

vector<pair<ll, ll>> sta1;
for (int i = 0; i < n; i++) {
  const ll p = position[i];
  const ll s = speed[i];
  while (!sta1.empty() && sta1.back().first + D >= p) {
    sta1.pop_back();
  }
  sta1.push_back({p, s});
}

可以思考：对于剩下的机器人，什么时候两个机器人才会发生合并？
答案是左边的机器人速度大于右边的机器人时，必然会触发合并。
如果左边机器人的速度不大于右边机器人的速度，则永远无法触发合并。

vector<pair<ll, ll>> sta2;
for (const auto [p, s] : sta1) {
  while (!sta2.empty() && sta2.back().second > s) {
    sta2.pop_back();
  }
  sta2.push_back({p, s});
}
return sta2.size();

四、至多 K 次转向的最小路径代价

题意：给一个网格，最多转向 k 次，问从左上角到达右下角的最小代价。
代价：路径之和，同一个位置经过多次时需叠加多次。

思路：网格DP

状态定义：dp[x][y][k][dir]
含义：从左上角到达位置 (x,y) 累计转向了 k 次，当前方向为 dir 的最小代价。

状态转移方程：枚举四个方向。

min_queue<tuple<int, int, int, int, int>> que;  // <cost, x, y, k, dir>
int ans = INT_MAX;
auto Add = [&](int cost, int x, int y, int k, int dir) {
  if (x < 0 || x >= n || y < 0 || y >= m || k > K) return;
  int& ret = flag[x][y][k][dir];
  cost += grid[x][y];
  if (ret != -1 && ret <= cost) return;
  ret = cost;
  que.push(make_tuple(ret, x, y, k, dir));
  if (x == n - 1 && y == m - 1) ans = min(ans, ret);
};
for (int i = 0; i < 4; i++) {
  Add(0, 0, 0, 0, i);
}
while (!que.empty()) {
  auto [cost, x, y, k, dir] = que.top();
  que.pop();
  for (int i = 0; i < 4; i++) {
    if (i == dir) {
      Add(cost, x + Next[i][0], y + Next[i][1], k, i);
    } else {
      Add(cost, x + Next[i][0], y + Next[i][1], k + 1, i);
    }
  }
}
if (ans == INT_MAX) ans = -1;
return ans;

五、最后

这次比赛比较简单，第三题贪心的特征很容易发现，第四题就是最初级的网格DP。

《完》

-EOF-

本文公众号：天空的代码世界
个人微信号：tiankonguse
公众号 ID：tiankonguse-code

leetcode 周赛 517 - 分组背包

2026-08-30T12:13:00+08:00

零、背景

这次比赛比较简单，最后两道题还一模一样，核心算法不变，输入的构造调整下就可以通过了。

本场题型概览如下。

A 题：统计。
B 题：快速幂。
C 题：背包。
D 题：BFS+背包。

一、统计特殊整数个数

题意：给一个数组，问哪些数字在数组中的位置是连续的。

思路：统计

分别统计每个值出现的个数、左边界、右边界。
然后计算左右边界内的数字是否等于出现的个数。

for (int i = 0; i < n; i++) {
  cnt[nums[i]]++;
  if (leftPos.find(nums[i]) == leftPos.end()) {
    leftPos[nums[i]] = i;
  }
  rightPos[nums[i]] = i;
}
int ans = 0;
for (auto [v, c] : cnt) {
  int l = leftPos[v];
  int r = rightPos[v];
  if (r - l + 1 == c) {
    ans++;
  }
}
return ans;

二、解码值之和

题意：给一个数组，每个值都是二元组 (x,y) 编码后的值。
编码规则：假设数组的值为 v，最低位为宽度 w=v%10，其余位为 d=floor(v / 10)。
x 的值为 d 的前 w 个数字，即 x = d[0:w]。
y 的值为 d 的其余数字，即 y=d[w:]。
求解码后所有 x^y 的之和。

思路：快速幂

按题意解码出 x 与 y，然后计算快速幂。

const ll w = v % 10;
const ll d = floor(v / 10);
const string s = to_string(d);
ll bit = s.size();
ll x = 0; // [0,w)
for (int i = 0; i < w; i++) {
  x = x * 10 + (s[i] - '0');
}
ll y = 0; // [w,bit)
for (int i = w; i < bit; i++) {
  y = y * 10 + (s[i] - '0');
}
ll V = qpow(x, y, mod);
ans = (ans + V) % mod;

三、构造子集和的最少操作次数 I

题意：给一个数组，每个数字可以操作变为其他数字，问最少操作多少次才能使得数组的一个子集之和等于 sum。

操作： 1）选择一个数字乘以2。
2）选择一个数字除2取整。

要求：对于同一个位置，如果有乘法与除法，乘法必须在前面。

数据范围：
数组大小：100
值大小：500
sum 大小：5000

思路：分组背包

首先注意要求，乘法在除法前面，乘与除抵消，意味着只能乘或者只能除，从而扩展出所有数字。
故，一个数字最多可以扩展出 log(V) 个数字。

g.resize(n);
for (int i = 0; i < n; i++) {
  const int v = nums[i];
  g[i].push_back({v, 0});
  for (int V = v * 2, t = 1; V <= sum; V *= 2, t++) {
    g[i].push_back({V, t});
  }
  for (int V = v / 2, t = 1; V > 0; V /= 2, t++) {
    g[i].push_back({V, t});
  }
  sort(g[i].begin(), g[i].end());
}

之后就是经典的分组背包了。
背包大小为 sum，每个数字一个分组，分组内有 log(V) 个数字。

状态定义：dp[i][sum]
含义：前 i 个分组，得到 sum 的最少操作次数。

状态转移方程：

dp(i,sum) = min(dp(i-1,sum), dp(i-1, sum - vj) + tj);  

解释：这个分组最多选择一个，所以分为不选择与选择某一个。
不选择就是 dp(i-1, sum)。
选择一个 (vj, tj)，其中 vj 是数字，tj 是得到这个数字的操作次数，则只能从上个状态 dp(i-1, sum-vj) 转移过来。

复杂度：O(n*sum*log(V))

vector<vector<int>> dp;
vector<vector<pair<int, int>>> g;  // <val, times>
// dp[0][0] = 0;

int Dfs(int i, int sum) {
  int& ret = dp[i][sum];
  if (ret != -1) return ret;
  ret = MaxVal;
  if (i == 0) {
    return ret;  // 只有 dp[0][0] 合法
  }
  // 不选择
  ret = min(ret, Dfs(i - 1, sum));
  for (auto [v, t] : g[i - 1]) {
    if (v > sum) break;
    ret = min(ret, Dfs(i - 1, sum - v) + t);
  }
  return ret;
}

四、构造子集和的最少操作次数 II

题意：同第三题，没有乘法在除法前面的限制。

思路：BFS + 分组背包。

可以发现，解除限制后，只是得到每组数字的方法变了。
原先数字是向上乘2与向下除2，得到的是一条链。

解除限制后，奇数向下除二后再向上乘二可以得到新的数字。
所以不断扩展，得到的是一个树。

要得到这些数字，并计算每个数字的最小操作次数，最简单的方法是使用 BFS 来搜索。

int maxVal;
void Bfs(const int i, const int v, const int sum) {
  queue<pair<int, int>> que;
  auto Add = [&](int V, int t) {
    if (V == 0 || V > maxVal) return;
    if (lastPos[V] == i) return;
    lastPos[V] = i;
    g[i].push_back({V, t});
    que.push({V, t});
  };
  Add(v, 0);
  while (!que.empty()) {
    auto [v, t] = que.front();
    que.pop();
    Add(v * 2, t + 1);
    Add(v / 2, t + 1);
  }
}

实际上，根据这个图，我们也可以直接不重不漏的构造出所有数字。
即向下除2时，判断是否是奇数，是奇数了，乘2就可以得到新的分支。

void Add(int i, int v, int sum, int t) {
  if (v == 0) return;
  for (int V = v; V <= sum; V *= 2, t++) {
    g[i].push_back({V, t});
  }
}
for (int i = 0; i < n; i++) {
  const int v = nums[i];
  Add(i, v * 2, sum, 1);
  for (int V = v, t = 0; V > 0; V /= 2, t++) {
    g[i].push_back({V, t});
    if (V % 2 == 1) {
      Add(i, V / 2 * 2, sum, t + 2);
    }
  }
  sort(g[i].begin(), g[i].end());
}

五、最后

这次比赛题目比较简单，最后两道题算法还一样，算是只有三道题了。

《完》

-EOF-

本文公众号：天空的代码世界
个人微信号：tiankonguse
公众号 ID：tiankonguse-code

leetcode 周赛 516 - 分块莫队与子数组不同元素个数

2026-08-29T12:13:00+08:00

零、背景

这次比赛的那几天我请假回老家了，所以就没参加比赛。
回来后，工作一直比较忙，所以直到周六才有时间把题目做了一遍。

最近几周我一直有一个感受，Leetcode 最后一题的难度升高了。
也许是我年纪大了，变菜了吧。

本场题型概览如下。

A 题：模拟。
B 题：枚举、二分、双指针、贪心。
C 题：分享两种滑动窗口与求质因子。
D 题：哈希前缀和、莫队、树状数组、滑动窗口等。

一、判断 ASCII 值回文

题意：给一个字符串，问把每个字符当做 ASCII 整数转化为 8 位的二进制，最终得到的字符串是否是回文串。

思路：模拟判断

按题意转为二进制字符串，前后双指针判断是否是回文串即可。

string ret;
ret.reserve(s.size() * 8);
for (int c : s) {
  for (int i = 0; i < 8; i++) {
    ret += (c & (1 << i)) ? '1' : '0';
  }
}
return CheckPalindromic(ret);

二、找到所有数组中消失的数字 II

题意：给一个数组，以及一个区间，问区间内的数字，有哪些不在数组内。
最终按递增顺序返回缺失的连续区间列表。
数据范围：10^5

方法一：枚举

数组存到哈希表中，然后从小到大枚举区间内的数字，判断是否存在。
不存在的追加到连续区间列表中。

vector<vector<int>> ret;
for (; lower <= upper; lower++) {
  if (s.count(lower)) continue;
  if (!ret.empty() && ret.back().back() == lower - 1) {
    ret.back().back() = lower;
  } else {
    ret.push_back({lower, lower});
  }
}
return ret;

方法二：二分

假设我们找到一个起始的缺失数字，如何找到这个区间有多大呢？
直接进行二分，即可找到下个数字的位置。
所以，可以不断压缩 lower，从而找到所有的缺失区间。

复杂度：O(n log(n))

vector<vector<int>> ret;
while (lower <= upper) {
  auto it = lower_bound(nums.begin(), nums.end(), lower);
  if (it == nums.end() || *it > upper) {
    ret.push_back({lower, upper});
    break;
  } else {
    const int val = *it;
    if (val != lower) {
      ret.push_back({lower, val - 1});
    }
    lower = val + 1;
  }
}
return ret;

方法三：双指针

方法二没有利用上次操作的结果，每次都是二分的。
而查看整个过程，可以发现查询结果是按顺序查找到的。

故可以维护一个游标，来代替二分。

sort(nums.begin(), nums.end());
vector<vector<int>> ret;
int n = nums.size();
int i = 0;
while (lower <= upper) {
  while (i < n && nums[i] < lower) i++;
  if (i == n || nums[i] > upper) {
    ret.push_back({lower, upper});
    break;
  } else {
    const int val = nums[i];
    if (val != lower) {
      ret.push_back({lower, val - 1});
    }
    lower = val + 1;
  }
}
return ret;

方法四：左右连续性判断

假设没有区间的限制，直接问数组中空洞的区间有哪些，该怎么判断呢？
显然是排序后，看相邻元素之差是否大于 1。

有了区间限制后，区间的左右边界处理比较麻烦。
此时可以在区间前和区间后加入一个桩，从而解决边界问题。

nums.push_back(lower - 1);
nums.push_back(upper + 1);
sort(nums.begin(), nums.end());

vector<vector<int>> ret;
auto l = lower_bound(nums.begin(), nums.end(), lower) - nums.begin();
auto r = lower_bound(nums.begin(), nums.end(), upper) - nums.begin();
for (auto i = l; i <= r; i++) {
  if (nums[i] - nums[i - 1] > 1) {
    ret.push_back({nums[i - 1] + 1, nums[i] - 1});
  }
}
return ret;

三、至多 K 个不同质因数集合的最长子数组

题意：给一个数组，求最长的子数组，使得子数组中所有元素的不同质因子个数不超过 K。

思路：滑动窗口

对于质因子，提前筛选素数表，然后循环判断即可。

vector<int> factPrimes;
void GetFactPrime(ll v) {
  factPrimes.clear();
  for (int i = 0; prm[i] * prm[i] <= v; i++) {
    if (v % prm[i] == 0) {
      const ll a = prm[i];
      factPrimes.push_back(a);
      while (v % a == 0) {
        v /= a;
      }
    }
  }
  if (is[v]) {  // 最后剩余一个质数不满足 prm[i] * prm[i] <= v
    factPrimes.push_back(v);
  }
}

对于滑动窗口，如果是求不大于，固定右区间，游标维护左区间代码会简洁一些。

InitPrimes();
int n = nums.size();
int l = 0;
int ans = 0;
for (int i = 0; i < n; i++) {
  Add(nums[i]);
  while (mp.size() > k) {
    Remove(nums[l]);
    l++;
  }
  ans = max(ans, i - l + 1);  // [l, i]
}
return ans;

如果固定左区间，游标为右区间，就需要特殊判断当前的游标是开区间还是闭区间，很容易被坑。

int ans = 0;
for (int i = 0; i < n; i++) {
  while (r < n && mp.size() <= k) {
    Add(nums[r]);
    r++;
  }
  if (mp.size() <= k) {
    ans = max(ans, r - i);
  } else {
    ans = max(ans, r - i - 1);
  }
  Remove(nums[i]);
}
return ans;

四、有效 K 个不同元素子数组 I

题意：给一个数组，问指定子数组是否恰好包含 k 个不同的数字，且每个数字出现的频率都是偶数个。

思路：随机哈希、莫队、树状数组

首先可以发现两个条件互相独立，所以可以分别来判断是否满足。

先来看每个数字是否都出现偶数次。

最容易想到的就是前缀异或。
但是很容易构造出一些数据，来使得异或得到错误的答案。
所以，需要对数据进行随机映射，之后就很难构造出 hack 数据了。

所以，第一个解法是随机数+前缀异或。
直接通过 prefixXor[r] == prefixXor[l - 1] 判断是否都是偶数。

ll Rand() {
  // 随机生成一个 64 位的随机数
  return rand() | ((ll)rand() << 32);
}
unordered_map<int, ll> mp;
vector<ll> prefixXor;
void InitXor(const vector<int>& nums) {
  const int n = nums.size();
  prefixXor.resize(n + 1);
  for (int i = 1; i <= n; i++) {
    const int v = nums[i - 1];
    if (mp.count(v) == 0) {
      mp[v] = Rand();
    }
    prefixXor[i] = prefixXor[i - 1] ^ mp[v];
  }
}

对于区间统计问题，如果没有其他高效算法，那就上离线莫队算法来暴力计算。

莫队算法是对查询的区间进行排序，然后暴力对区间左边界或者右边界加减一次，直到与询问区间一致。

这时候很容易怀疑，难道不会超时吗？
这就需要使用分块的思想来排序，使得最坏情况下，复杂度依旧不超过 n sqrt(n)。

具体来说，按其中一个边界来划分为 B=sqrt(N) 块，每个块内有 sqrt(N) 个元素。

排序时，先按块排序，之后按另一个边界排序。
这里不妨假设是按左边界分块，其次右边界排序。

由于左边界是按分块排序的，这导致块内的左边界是乱序的。
所以，块内 sqrt(N) 个元素每次对齐左边界都最多移动 sqrt(N) 次，综合移动 N 次。
对于右边界，由于是有序的，累计也是最多移动 N 次。
综合起来，一个块最多移动 2*N 次。

总共分了 sqrt(N) 块，故综合复杂度为 N sqrt(N)。

for (auto v : nums) mp[v] = 0;
int current_cnt = 0;  // 元素偶数个的个数
auto Add = [&](int v) {
  mp[v]++;
  if (mp[v] % 2 == 0) {
    current_cnt++;  // 变成偶数
  } else {
    current_cnt--;  // 变成奇数
  }
};
auto Remove = [&](int v) {
  mp[v]--;
  if (mp[v] % 2 == 0) {
    current_cnt++;  // 变成偶数
  } else {
    current_cnt--;  // 变成奇数
  }
};
moQueAns.resize(queries.size());
int current_l = 0, current_r = -1;  // [left, right]
for (auto& [left, right, index] : sortedQueries) {
  while (current_l > left) Add(nums[--current_l]);
  while (current_l < left) Remove(nums[current_l++]);
  while (current_r < right) Add(nums[++current_r]);
  while (current_r > right) Remove(nums[current_r--]);
  moQueAns[index] = current_cnt == 0;
}

接下来看另一个条件，恰好包含 k 个不同的数字。

由于 k 固定，最容易想到的方法是滑动窗口。
预处理出每个右边界恰好包含 k 个不同数字的左边界区间，然后询问时直接判断是否在区间内。

这就和上一题很相似了，找到包含 k 个不同数字的最小数组，以及包含 k+1 个不同数字的最小数组，合起来就是目标区间。

vector<int> InitRange(const vector<int>& nums, const int K) {
  int n = nums.size();
  mp.clear();
  vector<int> left(n);
  int l = 0;
  for (int i = 0; i < n; i++) {
    mp[nums[i]]++;
    while (mp.size() >= K) {
      mp[nums[l]]--;
      if (mp[nums[l]] == 0) {
        mp.erase(nums[l]);
      }
      l++;
    }
    left[i] = l;
  }
  return left;
}

另一种思路则是构造出一种特殊的数据结构，从而可以统计区间内不同数字的个数。

例如，固定右区间时，定义每个数字最后一次出现的位置值为 1，之前出现的位置值为 0。
则求区间和，就可以统计出这个区间内有多少个数字。
对于区间和，可以使用线段树或者树状数组来实现。

auto Update = [&](const int i) {
  const int v = nums[i - 1];
  if (mp[v] != 0) {
    const int idx = mp[v];
    FenwickTree::bit_update(idx, -1);
  }
  mp[v] = i;
  FenwickTree::bit_update(i, 1);
};

由于固定了右区间，所以需要离线处理所有查询，按右区间排序。
这种算法还可以做到任意 k 都可以查询判断。

int offset = 0;
FenwickTree::bit_init(n);
for (int i = 1; i <= n && offset < Q; i++) {
  Update(i);
  while (offset < Q && get<0>(sortedQueries[offset]) == i) {
    const auto [right, left, idx] = sortedQueries[offset];
    const int k = FenwickTree::bit_query(right) - FenwickTree::bit_query(left - 1);
    if (k == K && prefixXor[right] == prefixXor[left - 1]) {
      ans[idx] = true;
    }
    offset++;
  }
}

五、最后

这次比赛最后一题其实比较难。
统计区间内不同数字出现次数，需要用到莫队算法。
统计区间内不同数字的个数，需要特殊构造，然后使用线段树或树状数组来解决。
这种构造法挺有意思的。

《完》

-EOF-

本文公众号：天空的代码世界
个人微信号：tiankonguse
公众号 ID：tiankonguse-code

NOIP 2004 提高算法题解

2026-08-18T22:13:00+08:00

零、背景

今天继续分享 2004 年 NOIP 提高题解。

一、津津的储蓄计划

题意：每个月妈妈会给津津 300 元零花钱，津津每个月有一定的花销，剩余的钱会按 100 元整的方式存到妈妈那里。
年底，妈妈会把存的钱按 20% 的利息全部返还给津津。
问是否会发生某个月津津零花钱不够花，此时输出第一个不够花的月数。
如果够花，输出最后带上利息津津共有多少钱。

思路：模拟

记录上个月把 100 元整存之后剩余的钱，加上新的 300 元，减去当月花销，就是剩下的钱。

int Process() {
  int ans = 0;
  int pre = 0;
  for (int i = 0; i < n; i++) {
    pre += 300;
    pre -= nums[i];
    if (pre < 0) {
      return -(i + 1);
    }
    ans += pre / 100 * 100;
    pre %= 100;
  }
  return ans + ans / 100 * 20 + pre;
}

二、合并果子

题意：有 n 堆果子，每次可以选择两堆合并为一堆，代价是两堆果子的个数之和。
经过 n-1 次合并后，就只剩一堆果子。
问怎么合并，总代价最小，输出总代价。

思路：哈夫曼贪心&双队列优化

这个是典型的哈夫曼合并问题，每次合并最小的两堆即可。
维护一个最小堆，模拟合并。
复杂度：O(n log(n))

ll ans = 0;
while (que.size() > 1) {
  ll a = que.top();
  que.pop();
  ll b = que.top();
  que.pop();
  ans += a + b;
  que.push(a + b);
}
printf("%lld\n", ans);

对于加强版数据，堆数为 N=10^7，模拟只能得 60 分。

分析特征，可以发现，对于合并后的果子数量是递增的。
故，如果新增一个合并后的序列，只需要把新合并的果子追加到序列后面即可。
复杂度：O(n)

ll ans = 0;
while (n > 1) {
  n--;
  ll x = PopMin();
  ll y = PopMin();
  ll cost = x + y;
  ans += cost;
  PushVal(cost);
}

双队列保持有序性即可。

ll PopMin() {
  if (q2.empty()) {
    ll x = q1.front();
    q1.pop();
    return x;
  }
  if (q1.empty()) {
    ll x = q2.front();
    q2.pop();
    return x;
  }
  if (q1.front() <= q2.front()) {
    ll x = q1.front();
    q1.pop();
    return x;
  } else {
    ll x = q2.front();
    q2.pop();
    return x;
  }
}
void PushVal(ll x) {
  if (q2.empty()) {
    q2.push(x);
  } else if (q1.empty()) {
    q1.push(x);
  } else if (q1.back() <= x) {
    q1.push(x);
  } else {
    q2.push(x);
  }
}

还有一个问题是最初的 n 堆果子怎么得到有序序列。
初始每堆果子个数不超过 V=10^5，故可以使用堆排序，把复杂度压缩到 max(N, V)。

for (int i = 0; i < n; i++) {
  int v = read();
  a[v]++;
}
for (int i = 0; i < kMaxVal; i++) {
  while (a[i]) {
    q1.push(i);
    a[i]--;
  }
}

三、合唱队形

题意：n 个同学站成一排，问至少淘汰几个同学，使得剩余同学的身高满足先升序再降序。

思路：枚举+动态规划

状态定义1：dpPre[i] i 作为最后一个同学，满足升序淘汰最少同学的数量。
状态定义2：dpSuf[i] i 作为第一个同学，满足降序淘汰最少同学的数量。

状态转移方程：

if(V[j] < V[i]){
    dpPre[i]=min(dpPre[j] + i - j -1);
}

然后枚举峰值，两边的最优值求和。

int Solver(int mid) {  // mid 为最高点
  return DfsPre(mid) + DfsSuf(mid);
}

复杂度：O(n^2)

优化：LIS 可以使用二分查找加速。
复杂度：O(n log(n))

四、虫食算

题意：给三个 n 位的 n 进制数字，两个相加等于另外一个。
现在相同的数字被相同的字母代替，求每个字母对应哪个数字。
n的数据范围： 30% 小于 10。
50% 小于 15。
100% 小于 26。

思路：搜索+剪枝

很容易想到从后到前枚举每个字母的值，判断是否是答案。

复杂度：O(n!)
得分：70分。

bool Dfs1(const int p, const int carry) {
  if (p == -1) {
    if (carry == 0) {
      return true;
    } else {
      return false;
    }
  }
  const int c1 = s1[p] - 'A';
  if (charToVal[c1] != -1) {
    return Dfs2(p, carry);
  }
  for (int i = 0; i < n; i++) {
    if (valToChar[i] == 0) {
      charToVal[c1] = i;
      valToChar[i] = c1;
      if (Dfs2(p, carry)) {
        return true;
      }
      charToVal[c1] = -1;
      valToChar[i] = 0;
    }
  }
  return false;
}

超时的原因是搜索树太大了，所以需要剪枝。
很容易想到一个剪枝：如果低位枚举一些字母后，某个高位三个字母的值也都确定时，我们可以快速判断是否合法。

例如 AAAADBA + BBBBECB = DEDFCCC。
A、B、C 三个字母确定后，很多位都可以判断是否成立的。

这个优化加上后，很可惜，只有80分。

// 不考虑进位，看高位是否冲突
bool Check(const int p) {
  for (int i = 0; i <= p; i++) {
    const int c1 = s1[i] - 'A';
    const int c2 = s2[i] - 'A';
    const int c3 = s3[i] - 'A';
    const int v1 = charToVal[c1];
    const int v2 = charToVal[c2];
    const int v3 = charToVal[c3];

    // case1: 最高位，不能进位
    if (i == 0 && v1 != -1 && v2 != -1) {
      if (v1 + v2 >= n) return false;
    }

    // case2: 进位与不进位都不行
    if (v1 != -1 && v2 != -1 && v3 != -1) {
      if ((v1 + v2) % n != v3 && (v1 + v2 + 1) % n != v3) return false;
    }

    // case3: 其中一个没有赋值，推导出来的值冲突
    if (v1 != -1 && v2 != -1 && v3 == -1) {
      const int val1 = (v1 + v2) % n;
      const int val2 = (v1 + v2 + 1) % n;  // 有进位
      if (valToChar[val1] != 0 && valToChar[val2] != 0) return false;
    }
  }
  return true;
}

还可以想到一个优化：先枚举出现次数多的字母。
字母出现次数越多，枚举一次被检查到冲突的概率也会更高。
得分：90分。

cnt.resize(n, 0);
maxPos.resize(n, -1);
for (int i = 0; i < n; i++) {
  cnt[s1[i] - 'A']++;
  cnt[s2[i] - 'A']++;
  cnt[s3[i] - 'A']++;
  // 如果次数相同，优先搜索后面的字符
  maxPos[s1[i] - 'A'] = max(maxPos[s1[i] - 'A'], i);
  maxPos[s2[i] - 'A'] = max(maxPos[s2[i] - 'A'], i);
  maxPos[s3[i] - 'A'] = max(maxPos[s3[i] - 'A'], i);
}

valList.resize(n);
orderChar.reserve(n);
for (int i = 0; i < n; i++) {
  valList[i] = n - 1 - i;
  orderChar.push_back({cnt[i], maxPos[i], i});
}
valNum = n;
// 逆序排序
sort(orderChar.begin(), orderChar.end(), greater<tuple<int, int, int>>());

分析前面的剪枝，其中一个没有赋值的情况有三种，而上面只实现了一种。
把另外两种补齐，就可以得到 100 分了。

// 不考虑进位，看高位是否冲突
bool CheckNoConflict() {
  int carry = 0;
  int full = 1;

  for (int i = n - 1; i >= 0; i--) {
    const int c1 = s1[i] - 'A';
    const int c2 = s2[i] - 'A';
    const int c3 = s3[i] - 'A';
    const int v1 = charToVal[c1];
    const int v2 = charToVal[c2];
    const int v3 = charToVal[c3];

    if (full == 1 && v1 != -1 && v2 != -1 && v3 != -1) {
      const int sum = v1 + v2 + carry;
      const int val3 = sum % n;
      const int carry3 = sum / n;
      if (val3 != v3) return false;
      carry = carry3;
      continue;
    }
    full = 0;
    carry = 0;

    // case1: 进位与不进位都不行
    if (v1 != -1 && v2 != -1 && v3 != -1) {
      if ((v1 + v2) % n != v3 && (v1 + v2 + 1) % n != v3) return false;
    }

    // case2: 最高位，不能进位
    if (i == 0 && v1 != -1 && v2 != -1) {
      if (v1 + v2 >= n) return false;
    }
    
    // case3: v3 没有赋值，推导出来的值冲突
    if (v1 != -1 && v2 != -1 && v3 == -1) {
      const int val1 = (v1 + v2) % n;
      const int val2 = (v1 + v2 + 1) % n;  // 有进位
      if (valToChar[val1] != 0 && valToChar[val2] != 0) return false;
    }

    // case4: V1 没有赋值，判断是否有冲突
    if (v1 == -1 && v2 != -1 && v3 != -1) {
      if (!CheckSubtractionOK(v3, v2, c1)) {
        return false;
      }
    }
    
    // case5: V2 没有赋值，判断是否有冲突
    if (v1 != -1 && v2 == -1 && v3 != -1) {
      if (!CheckSubtractionOK(v3, v1, c2)) {
        return false;
      }
    }
  }
  // 全枚举完了，最后有进位
  if (full == 1 && carry != 0) return false;
  return true;
}

五、最后

这次比赛第二题哈夫曼贪心的加强版比较难，需要把最小堆转化为双队列才能通过。
而第四题搜索，剪枝需要写完整才能通过。

《完》

-EOF-

本文公众号：天空的代码世界
个人微信号：tiankonguse
公众号 ID：tiankonguse-code

leetcode 周赛 515 - 状态压缩

2026-08-16T12:13:00+08:00

零、背景

这次比赛最后一题比较难，涉及状态压缩，比赛期间想复杂了，没有做出来。

本场题型概览如下。

A 题：枚举。
B 题：贪心枚举。
C 题：贪心枚举。
D 题：状态压缩动态规划。

一、最近的可用无人机

题意：给 n 个无人机，每个无人机有一个飞行范围。
现在给一个坐标，问在无人机飞行范围之内的最近的无人机编号是多少。
距离计算规则为曼哈顿距离。

思路：枚举

枚举每一个无人机，计算曼哈顿距离，如果在飞行范围内，判断是否更近。

int ans = -1;
int minDist = INT_MAX;
for(int i=0;i<n;i++){
  int x = drones[i][0], y = drones[i][1], d = drones[i][2];
  int dist = abs(x - tx) + abs(y - ty);
  if (dist <= d && dist < minDist) {
    ans = i;
    minDist = dist;
  }
}
return ans;

二、交通灯的最大等待时间

题意：有 n 个红绿灯都在第 0 秒变成绿灯，绿灯分别持续 lights[i] 秒，剩余的 period-lights[i] 秒为红灯时间。
现在告诉你 m 个车经过的时间，只要有一个绿灯，车就可以过，问所有车中等红灯的最长时间。

思路：贪心枚举

由于只要有一个绿灯，车就可以过，所以只需要保留时间最长的绿灯。

ll maxLight = 0;
for (int i = 0; i < lights.size(); i++) {
  maxLight = max(maxLight, (ll)lights[i]);
}

然后计算所有车等红灯的时间，取最大值。

for (ll car : arrivalTime) {
  car %= period;
  if (car >= maxLight) {
    ans = max(ans, period - car);
  }
}

三、工位的最大间隔

题意：告诉你 n 个工人的技能，以及 m 个带某个技能属性的工位。
工人按顺序选择技能匹配的工位，至少存在一种匹配方案。
问怎么进行匹配，才能使得相邻工人的最大间隔值最大。

思路：贪心枚举

一开始读错题了，看成求最小间隔值最大。
写了一个二分，样例没通过。
再读题，发现是最大值最大。

最大值最大，直接枚举贪心。
假设最大的间隔是工人 [j,j+1] 之间。
则 j 左边的工人，需要尽可能的往左边匹配，j+1右边的工人，需要尽可能的往右边匹配。

int ans = 0;
for (int i = 1; i < n; i++) {
  // 枚举 i-1 与 i 的距离
  ans = max(ans, rightPos[i] - leftPos[i - 1]);
}
return ans;

所以预处理左边贪心匹配的位置与右边贪心匹配的位置，然后枚举工人位置，计算间隔。

void GreedyLeft() {
  int ni = 0, mi = 0;
  leftPos.resize(n);
  while (ni < n && mi < m) {
    if (skill[ni] == station[mi]) {
      leftPos[ni] = mi;
      ni++;
      mi++;
    } else {
      mi++;
    }
  }
}

复杂度：O(n)

四、电梯请求 III

题意：电梯在时刻 0 位于 start 楼层，然后告诉你 n 个请求的楼层和请求时间，问如何调度电梯，可以在最短时间内处理完所有请求。
处理完成的定义：假设楼层 Li 在 t 时刻发出请求，电梯在 t 时刻或之后经过或到达 Li 即可。
数据范围：楼层 10^9，时间 10^9，请求个数 16

思路：状态压缩动态规划

状态定义：dp[i][mask] 表示 mask 中的请求都处理完，且最后一个处理的是第 i 个请求时，所需的最短时间。

状态转移方程：枚举下一个处理的请求

const auto [cost, ri, mask] = que.top();
que.pop();
if (dp[ri][mask] != cost) continue;  // 更优答案处理过了
auto floorRi = requests[ri].second;
for (int rj = 0; rj < rn; rj++) {
  if (mask & (1 << rj)) continue;
  auto [arrivalTimeRj, floorRj] = requests[rj];
  ll newCost = 0;
  if (arrivalTimeRj >= cost) {
    newCost = cost + max(abs(arrivalTimeRj - cost), abs(floorRj - floorRi));
  } else {
    newCost = cost + abs(floorRj - floorRi);
  }
  Add(rj, mask | (1 << rj), newCost);
}

这里我使用的优先队列来处理。
理论上使用递推或者递归都可以。

vector<vector<ll>> dp(rn + 1, vector<ll>(1 << rn, LLONG_MAX));
min_queue<tuple<ll, int, int>> que;
ll ans = LLONG_MAX;
auto Add = [&](int ri, int mask, ll cost) {
  ll& ret = dp[ri][mask];
  if (cost < ret) {
    ret = cost;
    que.push({cost, ri, mask});
  }
  if (mask == (1 << rn) - 1) {
    ans = min(ans, cost);
  }
};

空间复杂度：O(n * 2^n)
时间复杂度：O(n^2 * 2^n)

PS：比赛期间我把最多 16 个请求，看成楼层也最多 16 个了。
于是定义的状态是 dp[ri][li][mask]。
含义为到达第 ri 个请求的时间，位于 li 层，此时前 ri 个请求还有 mask 个请求待处理的时间。

可以发现，每个状态对应的时间是确定的，即第 ri 个请求的时间。
上个请求位于 li，下个请求位于 lj，共经过了 requests[ri] - requests[rj] 秒时间。
这个时间内，从 li 到 lj，还可以对 mask 这些待处理请求顺带处理了。

这就需要分情况来讨论。

对于下个请求 rj，如果与目标位置 lj 一致，则可以把这个最新请求一起处理了。
否则只能等以后处理。

int extMask = (1 << nextFloor);
if (lj == nextFloor) {
  extMask = 0;
}

如果时间内可以处理完所有 mask，则只需要关心最新这个请求的 mask 了。

// 时间足够大，可以走遍所有 mask 的楼层
if (disTime >= 2 * (maxOffset - minOffset) - (tmpLj - tmpLi)) {
  Add(ri + 1, lj, extMask, nextArrivalTime);
  continue;
}

否则，只能枚举处理了哪些请求。

for (int offsetI = minOffset; offsetI <= tmpLi; offsetI++) {
  for (int offsetJ = tmpLj; offsetJ <= maxOffset; offsetJ++) {
    if (disTime >= 2 * (offsetJ - offsetI) - (tmpLj - tmpLi)) {
      // [offsetI, offsetJ] 中的 mask 都可以消除
      int eliminatedMask = rangeMask[offsetI][offsetJ];
      Add(ri + 1, lj, (mask & ~eliminatedMask) | extMask, nextArrivalTime);
    }
  }
}

空间复杂度：O(n^2 * 2^n)
时间复杂度：O(n^5 * 2^n)
虽然时间复杂度很大，但是由于贪心的存在，实际复杂度比较小。

提交代码后，353 / 999 个通过的测试用例，剩下的触发 MLE 了。
电梯楼层无限大后，状态中就只能有请求与 mask 了，其他的方法就都不行了。

五、最后

这次比赛第三题和第四题都看错题了。
第三题看错后，补救回来了。
第四题看错后，代码量比较大，MLE 时快结束比赛了，所以来不及纠正了。

《完》

-EOF-

本文公众号：天空的代码世界
个人微信号：tiankonguse
公众号 ID：tiankonguse-code

NOIP 2004 普及组算法题解

2026-08-14T22:13:00+08:00

零、背景

今天继续分享 2004 年 NOIP 普及组题解。

一、不高兴的津津

题意：津津每天白天上课 a 小时，然后补习班上课 b 小时。
如果当天上课总时长超过 8 小时，津津就会不高兴。
问津津在哪天会不高兴，如果存在，输出最不高兴的那一天。

思路：枚举

枚举找到上课最长的那一天，然后判断是否超过 8 小时。

int n = 7;
int maxVal = 8, day = 0;
for (int i = 1; i <= 7; i++) {
  int a, b;
  scanf("%d%d", &a, &b);
  if (a + b > maxVal) {
    maxVal = a + b;
    day = i;
  }
}
printf("%d\n", day);

二、花生采摘

题意：路边有一个矩阵花生田，某些位置的花生株有一些的花生。
路边进入花生田需要一个代价，然后花生田中上下左右移动，每移动一次也需要划分一个代价，采摘需要一个代价，从花生田边上返回路边也需要划分一个代价。
有花生的位置，花生的个数互不相同。
现在要求按花生数量从大到小一次采摘。
问在指定总代价内，路边进入花生田再返回路边，最多可以采摘多少个花生。

思路：模拟。

路边去第一个花生株，代价只需要关心行的距离。
最后一个花生株去路边，代价也是只需要关心行的距离。两个花生株之间代价是曼哈顿距离。

pair<int, int> GetGoOut(int x0, int y0, int x1, int y1) {
  int go = abs(x0 - x1) + abs(y0 - y1) + 1;
  int out = x1;
  return {go, out};
}

题目要求花生数量互不相同，而且必须从多到少的采摘，那花生株的遍历顺序就是固定的。
每次判断从当前花生株到达下个花生株后是否可以到达路边，可以了，就去下个花生株。
因此，需要计算两个值，一个是到达下个花生株并采摘的代价，一个是下个花生株到路边的代价。

// 从大到小排序，下标从 1 开始。
sort(g.begin(), g.end(), greater<tuple<int, int, int>>());
int ans = 0;
if (!g.empty()) {
  auto [_, x0, y0] = g[0];
  x0 = 0; // 对齐列，0 代表路边
  for (auto [val, x1, y1] : g) {
    auto [go, out] = GetGoOut(x0, y0, x1, y1);
    if (go + out <= k) {
      k -= go; // 到达下个花生株并采摘
      ans += val;
    } else {
      break;
    }
    x0 = x1;
    y0 = y1;
  }
}
printf("%d\n", ans);

三、FBI 树

题意：我们可以把由 0 和 1 组成的字符串分为三类：全 0 串称为 B 串，全 1 串称为 I 串，既含 0 又含 1 的串则称为 F 串。
FBI 树是一种二叉树，它的结点类型也包括 F 结点，B 结点和 I 结点三种。
给一个完全二叉树的 01 值中序遍历序列请构造方法构造出一棵 FBI 树，并输出它的后序遍历序列。

思路：递归

按照题意边构造完全二叉树，边统计 0 与 1 的个数，从而计算出子树的 FBI 值。
小技巧：利用区间大小与区间和，也可以推导出 0 与 1 的个数。

void Dfs(int l, int r) {
  if (l != r) {
    int mid = (l + r) / 2;
    Dfs(l, mid);
    Dfs(mid + 1, r);
  }
  int sum = RangeSum(l, r);
  int len = r - l + 1;
  if (sum == 0) {
    ans.push_back('B');
  } else if (sum == len) {
    ans.push_back('I');
  } else {
    ans.push_back('F');
  }
}

四、火星人

题意：给一个不重复数字的排列，求下个排列数。

思路：贪心

下个排列数，本质上是在修改尽量短的后缀，得到更大的字符串。

例如 1 2 3, 只修改 2 3 就可以得到下个字符串 1 3 2。
同理，对于 1 3 2，则需要修改 1 3 2，可以得到下个字符串 2 1 3。

由此，可以发现三个规律。

规律1：需要从后到前，找到第一个非逆向递增的位置，例如 1 3 2 的 1。
规律2：找到后缀中 1 3 2，下个大于边界值 1 的值，这里是 2。
规律3：剩余的数字，需要从小到大排列，这里是 1 3。
综合，得到序列 2 1 3。

小技巧1：处理规律1时，列表记录下逆向的数字，从而规律2可以在列表中二分查找。
小技巧2：下个值与边界进行交换，得到的依旧是有序列表，故可以直接应用到规律3。

每次不超过 O(n)，共 k 次。
综合复杂度：k O(n)

vector<int> buf;
void Process(int p) {  //
  const int oldVal = nums[p];
  auto it = upper_bound(buf.begin(), buf.end(), oldVal);
  int nextVal = *it; // 规律2，找到下个值
  *it = oldVal;
  nums[p++] = nextVal;
  for (auto v : buf) { // 规律3，剩余升序排列
    nums[p++] = v;
  }
}
void Next() {  //
  buf.clear();
  for (int i = n - 1; i >= 0; i--) {
    int v = nums[i];
    if (buf.empty() || v > buf.back()) {
      buf.push_back(v);
    } else {
      Process(i); // 规律1，找到边界
      break;
    }
  }
}

五、最后

2004年普及组的比赛还算简单。
第一题，签到题。
第二题，矩阵下标从 1 开始处理，把路边当做 0 处理，就会简单很多。
第三题，二叉树递归构造树，基础题。
第四题，下个排列数，稍微复杂一些，但是也不难。

《完》

-EOF-

本文公众号：天空的代码世界
个人微信号：tiankonguse
公众号 ID：tiankonguse-code

leetcode 周赛 514 - 高级线段树

2026-08-09T12:13:00+08:00

零、背景

这次比赛最后一题涉及线段树的复杂计算，手速比较慢，比赛内没有通过最后一题。

本场题型概览如下。

A 题：贪心匹配。
B 题：DFS。
C 题：动态规划枚举。
D 题：复杂值线段树。

一、应用折扣后的最低总价

题意：给一些商品的价格，和一些优惠折扣，每个商品用一个优惠折扣，问怎么匹配，购买所有商品的价格才会最低。

思路：贪心。

显然，最贵的商品使用优惠力度最大的折扣。
故都按逆序排序，逐个匹配即可。

小技巧：可以使用 rbegin 和 rend 来逆序排序。

sort(prices.rbegin(), prices.rend());
sort(discounts.rbegin(), discounts.rend());

二、树的加权和

题意：给一个树，节点的权重为节点值与节点高度运算得到，公式 nums[i] * (h - d + 1)。
求所有节点的权重之和。

思路：递归。

首先根据输入构造树的数据结构。

vector<vector<int>> tree(n);
for (int i = 1; i < n; i++) {
  int p = parent[i];
  tree[p].push_back(i);
}

然后递归计算每个节点的高度，与树的最大高度。

vector<ll> heights(n, 0);
ll maxHeight = 0;
auto DfsHeight = [&](auto&& self, int u, ll h) -> void {
  heights[u] = h;
  maxHeight = max(maxHeight, h);
  for (auto v : tree[u]) {
    self(self, v, h + 1);
  }
};
DfsHeight(DfsHeight, 0, 1);

最后，计算每个节点的权重，求和。

ll ans = 0;
for (int i = 0; i < n; i++) {
  ans += nums[i] * (maxHeight - heights[i] + 1);
}
return ans;

三、两个不重叠子正方形的最大面积

题意：给一个矩阵，需要划分出两个面积相等的不重叠的全 1 正方形。
求可以划分的最大正方形的面积。
数据范围：500。

思路：动态规划。

先考虑求一个最大的全 1 正方形，需要维护三个状态。

状态 1：col[i][j] 在第 j 列，坐标 (i,j) 往上连续 1 的个数。
状态 2：row[i][j] 在第 i 行，坐标 (i,j) 往左连续 1 的个数。
状态 3：dp[i][j] 在坐标 (i,j) 为正方形右下角时可以组成的最大全 1 正方形的边长。

状态转移方程：

int v = nums[i][j];
if(v > 0){
  col[i][j] = 1 + col(i-1, j);
  row[i][j] = 1 + row(i, j-1);
  dp[i][j] = max(dp(i-1,j-1), col(i-1, j), row(i, j-1));
}

复杂度：O(n^2)。

现在是划分两个正方形，可以发现，两个正方形要么可以使用水平线划分，要么可以使用垂直线划分。
所以，可以枚举分割线，然后分别求分割线一侧的最大正方形，两边再取最小值即可。

int ans = 0;
// 枚举水平分割线
for (int ni = 1; ni < n; ni++) {  // [0, ni) [ni, n)
  int tmp = min(GetRightDown(ni - 1, m - 1), GetLeftUp(ni, 0));
  ans = max(ans, tmp);
}
// 枚举垂直分割线
for (int mi = 0; mi < m; mi++) {  // [0, mi) [mi, m)
  int tmp = min(GetRightDown(n - 1, mi - 1), GetLeftUp(0, mi));
  ans = max(ans, tmp);
}
return ans * ans;

上面介绍了如何求右下角的最大正方形，同样的方法，求出四个角的最大正方形即可。
复杂度：O(n^3)。

优化：再新增一个状态 dp2(i,j) 为右下角 (i,j) 到左上角 (0,0) 所有全 1 正方形的最大边长。
状态转移方程：

dp2(i,j) = max(dp2(i-1,j), dp2(i, j-1), dp(i,j));

此时，可以把复杂度降低到 O(n^2)。

四、数组中的峰值 II

题意：给一个数组，当一个子数组中存在连续的三个数字，满足中间的数字大于两边的数字时，则把这个子数组称为峰值子数组。
现在给一些修改操作，然后询问一个区间内存在多少个峰值子数组。

思路：复杂值线段树。

首先需要理解题意。
一个子数组只要有一个峰值就是峰值子数组。
假设区间内有一个峰值，峰值左边有 a 个数字，右边有 b 个数字，那么峰值子数组的个数为 a*b。

故，若查询区间内有 m 个峰值，分别是 p1,p2,...,pm。
我们需要不重复不遗漏地来统计子数组的个数。

常见的策略是枚举右端点。
此时可以发现，右端点在 (p1,p2] 的峰值子数组个数都是相同的，都是 p1-L 个。
这些右端点的峰值子数组个数为 (p2-p1)*(p1-L)。

同理，右端点在 (p2,p3] 的峰值子数组个数也是相同的，都是 p2-L 个。
这些右端点的峰值子数组个数为 (p3-p2)*(p2-L)。

最后一个区间右端点 [pm,R) 的峰值子数组个数也是相同的，都是 pm-L 个。
对应的，这些右端点峰值子数组个数为 (R-pm)*(pm-L)。

所有的右端点峰值子数组个数求和，公式展开，可以发现右侧可以抵消为 (R-p1)*L。
左侧除了最后一个区间，前面都满足 (p[i+1]-p[i])*p[i]。

故，我们需要使用线段树维护一些节点，每个节点的值为 (p[i+1]-p[i])*p[i]。
这里定义线段树中第 pi 个峰值节点的值为 (p[i+1]-p[i])*p[i]。

下面我们来看几个最难的地方。

问题 1：如何找到相邻的峰值呢？
可以存在 set 中，这样就可以通过二分查找找到下一个峰值的位置了。

问题 2：变更一个值，该如何更新线段树呢？
首先，更新一个值，例如位置 i，i-1、i、i+1 三个位置的峰值都可能发生变化。

vector<ll> ans;
ans.reserve(queries.size());
for (auto& qs : queries) {
  int op = qs[0];
  if (op == 1) {
    const int l = qs[1] + 1;
    const int r = qs[2] + 1;
    ans.push_back(Query(l, r));
  } else {
    const int index = qs[1] + 1;
    const int val = qs[2];
    Set(index, val);
    // 修改 index，影响 index-1, index, index+1
    Update(index - 1);
    Update(index);
    Update(index + 1);
  }
}
return ans;

其次，对于一个位置，如果是峰值，不仅需要更新自己的峰值，还需要更新前面一个峰值。
因为每个峰值计算的结果依赖于下个峰值的位置。

而一个位置不是峰值，可以假设是删除了峰值，此时前一个峰值的计算结果需要重新运算。

auto Update = [&](int i) {
  if (i <= 1 || i >= n) return;  // 不可能是峰值
  segTree.UpdateSet(i, 0);       // 先清空
  P.erase(i);
  if (Get(i) > Get(i - 1) && Get(i) > Get(i + 1)) {
    P.insert(i);
    auto it = P.lower_bound(i);
    if (it != P.begin()) {
      auto prev = it;
      prev--;
      segTree.UpdateSet(*it, F(*prev, *it));
    }
    auto next = it;
    next++;
    if (next != P.end()) {
      segTree.UpdateSet(*next, F(*it, *next));
    }
  } else {
    auto next = P.lower_bound(i);
    if (next != P.end() && next != P.begin()) {
      auto prev = next;
      prev--;
      segTree.UpdateSet(*next, F(*prev, *next));
    }
  }
};

查询时，按照推导的公式，加加减减即可。

auto Query = [&](ll l, ll r) -> ll {
  if (l + 1 >= r) return 0;  // 需要至少 3 个点
  auto itLeft = P.upper_bound(l);
  if (itLeft == P.end() || *itLeft >= r) return 0;
  // 此时，保证一定至少有一个峰值在 (l,r) 之间
  ll p1 = *itLeft;
  auto itRight = P.lower_bound(r);
  itRight--;
  ll p2 = *itRight;
  if (p1 == p2) {  // 只有一个峰值
    ll p = p1;
    return (p - l) * (r - p);
  }
  return segTree.QuerySum(p1 + 1, p2) + (r - p2) * p2 - (r - p1) * l;
};

处理正常的推导答案，还可以采取正难则反的思想。
即先求出所有子数组，减去不满足情况的子数组。

定义 A(a,b) 为求区间 [a,b] 内的子数组个数。

不满足情况的子数组则是在与峰值无关的区间内选择子数组。
故公式为 A(L,R) - A(L,p1) - A(p1,p2) - ... - A(pm, R) + m。

为啥要加 m 呢？
因为相邻两个区间求子数组时，交点分别多计算一次，所以需要加回来。

此时，定义线段树的节点 p1 的值为 A(p1,p2)。
剩下的就与正推的逻辑一模一样了。

auto Query = [&](ll l, ll r) -> ll {
  if (l + 1 >= r) return 0;  // 需要至少 3 个点
  auto itLeft = P.upper_bound(l);
  if (itLeft == P.end() || *itLeft >= r) return 0;
  // 此时，保证一定至少有一个峰值在 (l,r) 之间
  ll p1 = *itLeft;
  auto itRight = P.lower_bound(r);
  itRight--;
  ll p2 = *itRight;
  if (p1 == p2) {  // 只有一个峰值
    ll p = p1;
    return (p - l) * (r - p);
  }
  ll all = F(l, r);  // 所有子数组个数
  ll leftPart = F(l, p1);
  ll rightPart = F(p2, r);
  ll midPart = segTree.QuerySum(p1 + 1, p2);
  ll m = segTree.QueryTop(p1, p2);  // 分割点分别多计算一次
  return all - leftPart - rightPart - midPart + m;
};

对了，如何统计一个区间峰值的个数呢？
还是需要使用线段树来统计。
这样看来，反着来也没简单多少。

五、最后

这次比赛最后一题比较复杂，每个节点需要维护一个公式的值，而公式依赖相邻的峰值。
这就导致很容易遗漏某个峰值的更新。
最简单的方法是，对左右峰值都更新一下，只是常数复杂度，就可以确保不遗漏了。

《完》

-EOF-

本文公众号：天空的代码世界
个人微信号：tiankonguse
公众号 ID：tiankonguse-code

NOIP 2003 提高组算法题解

2026-08-04T22:13:00+08:00

零、背景

今天继续分享 2003 年 NOIP 提高组题解。

一、神经网络

题意：给一个有向无环图神经网络，告诉你所有输入节点的状态，只有一个节点的状态大于0时，才能把信号传递给所有后驱节点。
每个节点的状态由所有激活的前驱节点加权计算得到。
求所有激活的输出节点，以及对应的状态。

思路：拓扑排序

原题介绍的非常抽象，根本看不出来是啥意思。
上面是总结提炼出来的含义。

理解了题意，就简单了。
直接拓扑排序计算每个节点的状态，最后统计激活的输出节点的答案。

while (!que.empty()) {
  int u = que.front();
  que.pop();
  for (auto [v, w] : G[u]) {
    inDeg[v]--;
    if (C[u] > 0) {
      C[v] += C[u] * w;
    }
    if (inDeg[v] == 0) {
      que.push(v);
    }
  }
}
vector<pair<int, ll>> ans;
ans.reserve(n);
for (int i = 0; i < n; i++) {
  if (outDeg[i] == 0 && C[i] > 0) {
    ans.push_back({i, C[i]});
  }
}

注意事项：输入节点不需要加权计算，只有有入度的节点才需要加权计算。

二、侦探推理

题意：有一个人是罪犯，M 个人说了 P 句话，其中 N 个人说了谎话，其他人说的都是真话。
问可以判断几个人可能是罪犯。

每个人说的话有6类：
1）我是罪犯。
2）我不是罪犯。
3）XX是罪犯。
4）XX不是罪犯。
5）今天是星期几。
6）其他

思路：枚举

枚举谁是罪犯和今天是星期几，判断所有话之间是否有矛盾。
没矛盾了，判断说假话的人是否为 N 个，是的，则枚举成立。

int CheckName(const int nameId, const int guiltyId, const int day) {
  int ans = 0;  // 1 真话, 2 假话, 0 可真可假， -1 矛盾
  for (const auto& state : nameToWords[nameId]) {
    const int xxx = state.xxx;
    if (state.type == GUILTY) {
      if (xxx == guiltyId) {
        ans |= 1;
      } else {
        ans |= 2;
      }
    } else if (state.type == NOT_GUILTY) {
      if (xxx == guiltyId) {
        ans |= 2;
      } else {
        ans |= 1;
      }
    } else if (state.type == DAY) {
      if (xxx == day) {
        ans |= 1;
      } else {
        ans |= 2;
      }
    }
  }
  if (ans == 3) {
    ans = -1;
  }
  return ans;
}

特殊情况：某些人可能没说话，从而无法判断说的是真话还是假话。
此时，就需要假设这几个人由于部分人说假话，从而凑够 N 个假话。

// 假设 nameId 是 guilty ，day 是 week，判断是否成立
bool Check(const int guiltyId, const int day) {
  int ans[3] = {0, 0, 0}; // 1 真话, 2 假话, 0 可真可假
  for (int nameId = 1; nameId <= m; nameId++) {
    int ret = CheckName(nameId, guiltyId, day);
    if (ret == -1) return false;
    ans[ret]++;
  }
  return ans[2] <= n && n <= ans[0] + ans[2];
}

三、加分二叉树

题意：给一个二叉树的中序序列，问怎么构造二叉树，才能使得根的加分最大。
子树根的加分：左子树加分 * 右子树加分 + 子树根的基础分。
如果其中一个子树为空，加分按1计算。
叶子节点的两个子树都为空，加分定义为叶子的基础分。
输出根加分最大时，对于二叉树的前序序列。

思路：区间动态规划

状态定义：dp(l,r) 表示区间 [l, r] 子树可以得到的最大加分，以及树根的位置
状态转移方程：

dp(l, r) = max(dp(l, mid-1) * dp(mid+1, r) + baseVal[mid]);

完整的代码如下：

vector<vector<pair<ll, int>>> dp; 
pair<ll, int> Dfs(int l, int r) {
  if (l > r) return {1, 0};  // 空树的加分为 1
  auto& [maxVal, rootPos] = dp[l][r];
  if (maxVal != 0) return {maxVal, rootPos};

  // 叶子的加分就是叶节点本身的分数
  if (l == r) {
    maxVal = middleList[l];
    rootPos = l;
    return {maxVal, rootPos};
  }

  for (int root = l; root <= r; root++) {
    auto [leftVal, leftPos] = Dfs(l, root - 1);
    auto [rightVal, rightPos] = Dfs(root + 1, r);
    ll val = leftVal * rightVal + middleList[root];
    if (val > maxVal) {
      maxVal = val;
      rootPos = root;
    }
  }
  return {maxVal, rootPos};
}

由于记录了最大得分对应的根，再递归构造出二叉树，从而构造出前序序列。

vector<ll> preOrderList;
void DfsAns(int l, int r) {
  if (l > r) return;
  int root = dp[l][r].second;
  preOrderList.push_back(root);
  DfsAns(l, root - 1);
  DfsAns(root + 1, r);
}

四、传染病控制

题意：告诉你一个树，起始树根被染色。
每一秒染色的节点可以把相邻的节点染色。
同时，我们可以删除一条边。
最终树中未删除的就会被全部染色。
问如何操作，才能使得染色的节点个数最小，输出最小值。

思路：搜索

根据题意，可以发现，每一秒就会把树的一层全部染色，同时，我们也会从这一层删除一个节点以及对应的子树。
删除哪个节点无法确定是否是最优的，所以需要枚举所有情况。

这道题没有多项式解法，只能暴力搜索来做。
复杂度：O(能过)

搜索时，需要存每一层的节点。
我自己维护了一个栈 que，把这层的节点都压到栈 que 上，从而不需要每次申请一个数组。
由于每个节点最多入栈一次，所以栈大小最大不超过 n。

vector<int> que;
void Dfs(const int l, const int r, const int preDelNum) {
  if (l == r) {
    UpdateAns(r - preDelNum);
    return;
  }
  for (int i = l; i < r; i++) {  // [l, r)
    // 枚举删除节点 i 与父节点的边
    int p = r;
    for (int j = l; j < r; j++) {
      if (i == j) continue;
      for (auto v : G[que[j]]) {
        que[p] = v;
        p++;
      }
    }
    Dfs(r, p, preDelNum + 1);
  }
}

剪枝：显然，一层所有节点中，先删除最大的子树可能得到更小的答案。
故构造树时，可以对儿子按树大小排序。

void DfsLevel(int u, int pre) {
  childNum[u] = 1;
  for (int v : g[u]) {
    if (v == pre) continue;
    G[u].push_back(v);
    DfsLevel(v, u);
    childNum[u] += childNum[v];
  }
  // 儿子节点按子树大小降序排列，方便后续枚举删除节点时，优先删除子树大的节点
  sort(G[u].begin(), G[u].end(), [&](int a, int b) { return childNum[a] > childNum[b]; });
}

搜索时，假设这一层都可以删除，是否依旧比当前答案差，是的话就剪枝掉。
一层所有节点子树的大小定义为 forestNum。
到下一层时，删除了一个子树，减少了一层，两个重叠一个子树根，多删除了需要加回来。
故下层子树的大小为 forestNum - childNum[u] - len + 1。

void Dfs(const int l, const int r, const int preDelNum, const int forestNum) {
  if (l == r) {
    UpdateAns(preDelNum);
    return;
  }
  // 森林都删除依旧比当前答案大，则不需要继续枚举删除节点
  if (n - (preDelNum + forestNum) >= ans) return;

  int len = r - l;
  for (int i = l; i < r; i++) {  // [l, r)
    // 枚举删除节点 i 与父节点的边
    int p = r;
    for (int j = l; j < r; j++) {
      if (i == j) continue;
      for (auto v : G[que[j]]) {
        que[p] = v;
        p++;
      }
    }
    Dfs(r, p, preDelNum + childNum[que[i]], forestNum - childNum[que[i]] - len + 1);
  }
}

五、最后

这次比赛出的不好。

第一题我看了一个小时，也没看懂。
最后看题解发现就是有向图，从输入节点到同一个节点，深度都是相同的。
那直接拓扑排序即可。

第四题同样没看懂。
看了题解发现是树分层染色，暴力枚举即可。

《完》

-EOF-

本文公众号：天空的代码世界
个人微信号：tiankonguse
公众号 ID：tiankonguse-code

leetcode 周赛 513 - 离散化线段树

2026-08-02T12:13:00+08:00

零、背景

这次比赛题目不难，但是第二题与第四题一摸一样，我就把代码复制过来了，然后就被卡在第 599/601 个数据了。
比赛期间调试半小时没找到原因，赛后发现第四题返回值是 long long，int 改 long long 就过了。

本场题型概览如下。

A 题：枚举二元组。
B 题：枚举子数组。
C 题：二分。
D 题：离散化线段树。

一、数对的最大强度

题意：给一个数组，问两个不同的下标组成二元组，计算出一个强度值，求最大强度值。
数据范围：1000

思路：枚举二元组

long long maxPairStrength(vector<int>& nums) {
  ll ans = 0;
  int n = nums.size();
  for (int i = 0; i < n; i++) {
    for (int j = i + 1; j < n; j++) {
      ll a = nums[i];
      ll b = nums[j];
      ll g = gcd(a, b);
      ans = max(ans, a / g * b / g);
    }
  }
  return ans;
}

二、按奇偶比统计子数组 I

题意：给一个数组，问存在多少个子数组，满足奇数个数大于0，且偶数个数与奇数个数的比例不大于 a/b。
要求：比例需要精确计算

思路：枚举子数组

精确计算，需要把除法转换为乘法。
枚举子数组时，可以依靠前缀和来快速从前一个子数组的统计信息得到下个子数组的统计信息，转移复杂度 O(1)。

int countRatioSubarrays(vector<int>& nums, int a, int b) {
  int n = nums.size();
  ll ans = 0;
  for (int i = 0; i < n; i++) {
    int x = 0;  // 偶数的个数
    int y = 0;  // 奇数的个数
    for (int j = i; j < n; j++) {
      if (nums[j] % 2 == 0) {
        x++;
      } else {
        y++;
      }
      if (y > 0 && x * b <= y * a) {
        ans++;
      }
    }
  }
  return ans;
}

三、统计每个班次结束后的未完成任务数

题意：给一个任务数组与班次数组。
任务数组含义是每个任务的所需时间。
班次数组代表一个可用时长，只要时间可用，就可以不断的处理下个任务。

任务处理规则如下：
1）任务必须从左到右依次处理。
2）如果一个任务在一个班次没有处理完，需要记录处理进度，在下个班次接着处理。
3）如果一个班次完成了最后一个任务，则这个班次立刻结束。下个班次从第0个任务开始处理。
问每个班次结束时，剩余多少个任务待完成。

数据范围：
任务个数： 10^5
班次个数：10^5
任务时长：10^9
班次时长：10^9

思路：二分查找

很容易想到模拟。
但是一个班次的时长就很长，处理一个班次可能直接处理到最后一个任务。
复杂度：O(n^2)

优化：确定一个任务的剩余时长与班次，如何快速找到可以连续处理多少个任务了？
如果知道后续每个任务到当前任务的前缀和，则可以二分查找找到这个边界。

对于第一个任务比较特殊，可能上个班次已经处理了部分了。
所以，对于第一个任务，可以特殊判断。

剩余的就可以利用前缀和来二分查找，从而确定可以处理到第几个任务。

vector<int> ans(sn);  // 剩余未完成的任务数
int preTaskId = 0;
int preTaskLeftTime = tasks[0];
for (int i = 0; i < sn; i++) {
  ll shift = shifts[i];
  // preTaskId 可能不完整，单独计算
  if (shift < preTaskLeftTime) {
    preTaskLeftTime -= shift;
    ans[i] = tn - preTaskId;
  } else {
    shift -= preTaskLeftTime;
    ll findSum = taskPrefixSum[preTaskId] + shift;
    preTaskId = upper_bound(taskPrefixSum.begin(), taskPrefixSum.end(), findSum) - taskPrefixSum.begin();
    ans[i] = tn - preTaskId;
    if (preTaskId == tn) {
      preTaskId = 0;
      preTaskLeftTime = tasks[preTaskId];
    } else {
      preTaskLeftTime = taskPrefixSum[preTaskId] - findSum;
    }
  }
}
return ans;

四、按奇偶比统计子数组 II

题意：与第二题一摸一样。
数据范围：10^5

思路：离散化线段树

数据范围很大，又是子数组统计，显然需要利用前缀和，快速判断有多少个前缀满足答案。

假设第一个位置的奇偶个数为 (x0,y0)，第二个位置的奇偶个数为 (x1,y1)。
则子数组的奇偶个数为 (x1-x0, y1-y0)。

按照题目要求，需要满足 y > 0 && x / y <= a / b。
代入得，如下：

y1-y0 > 0
(x1-x0) / (y1-y0) <= a / b
(x1-x0) * a <= (y1-y0) * b
x1 * a - x0 * a <= y1 * b - y0 * b
y0 * b - x0 * a  <= y1 * b - x1 * a 

可以发现，左右两边公式都一样，都是 y*b-x*a。
故可以预处理前缀的 y*b-x*a, 判断前缀有多少个满足小于等于的关系。

前缀小于等于的查询，需要使用带计数的平衡树，比较复杂。
这时候，我们可以使用离散化线段树，把计数问题转化为前缀和求和。

ll countRatioSubarrays(vector<int>& nums, ll a, ll b) {
  Init(nums, a, b); // 离散化
  int n = nums.size();
  ll ans = 0;
  segTree.Init(n + 1);
  segTree.Build();
  ll val = 0;
  segTree.Add(H[0], 1); // 确保整个前缀也可以查询
  for (int i = 0; i < n; i++) {
    if (nums[i] % 2 == 0) {
      val -= b;
    } else {
      val += a;
    }
    ll offset = H[val];
    ans += segTree.QuerySum(1, offset);
    segTree.Add(offset, 1);
  }
  return ans;
}

思考：还需要满足 y1-y0 > 0，是否会导致把相等的情况计算在内。
可以证明，不存在这样的情况。

当 y1 == y0时，要满足 - x0 * a <= - x1 * a ，必须 x1 <= x0。
而前缀中，x 是递增的，且 x0 永远小于 x1，只有相同点才会 x 与 y 同时相等。

五、最后

这次比赛对我来说都不难，只看比赛的话，第三题二分，第四题离散化线段树，有点难度。
而第四题我复制第二题的代码，导致返回值是 int，从而导致倒数第二组没有通过，被坑了。

《完》

-EOF-

本文公众号：天空的代码世界
个人微信号：tiankonguse
公众号 ID：tiankonguse-code

NOIP 2003 基础组算法题解

2026-07-31T22:13:00+08:00

零、背景

今天继续分享 2003 年 NOIP 普及组题解。

一、乒乓球

题意：告诉你两个人乒乓球每个球的胜负情况。
问在 11 分制和 21 分制情况下的比分。
规则：对于 X 分制，至少打 X 个球，且需要满足分差大于或等于 2 一局才算结束。

思路：循环

这道题最难的是读懂题意。
对于 11 分制，每局结束的规则是先打 11 个球，然后看是否满足分差大于等于 2，不满足就一直打。

读懂了题意，按题意计算即可。

注意事项：由于比赛每打完，最后一局都没得分就是 0:0。

void Solver(int B) {
  int W = 0, L = 0;
  for (auto c : S) {
    if (c == 'W') {
      W++;
    } else if (c == 'L') {
      L++;
    }
    if (max(W, L) >= B && abs(W - L) >= 2) {
      printf("%d:%d\n", W, L);
      L = 0, W = 0;
    }
  }
  printf("%d:%d\n", W, L);
}

二、数字游戏

题意：n 个数字摆成一个圆圈，问将数字划分为 m 连续的部分。
每部分求和后模 10 得到 m 个非负数，最后这些非负数相乘。
求可以得到的最大值和最小值。
数据范围：n=50，m=9

思路：动态规划

数字个数很小，枚举边界起始位置，问题就转化为了 n 个数字一排分成 m 组，求最值。

状态定义：dp(n,m) 前 n 个数字分成 m 组的最值。
状态转移方程：

dpMax(n,m) = max(dpMax(n-i, m-1) * Mod(sum(n-i+1, n)));
dpMin(n,m) = min(dpMin(n-i, m-1) * Mod(sum(n-i+1, n)));

复杂度：O(n^3 * m)

pair<ll, ll> Dfs(const int l, const int r, const int m) {
  if (dp[l][r][m][0] != -1) return {dp[l][r][m][0], dp[l][r][m][1]};
  if (m == 1) {
    dp[l][r][m][0] = dp[l][r][m][1] = Sum(l, r);
    return {dp[l][r][m][0], dp[l][r][m][1]};
  }
  ll minAns = INFL, maxAns = -INFL;
  for (int i = r; i - l + 1 >= m; i--) {
    auto [minV, maxV] = Dfs(l, i - 1, m - 1);
    ll sum = Sum(i, r);
    minAns = min(minAns, minV * sum);
    maxAns = max(maxAns, maxV * sum);
  }
  dp[l][r][m][0] = minAns;
  dp[l][r][m][1] = maxAns;
  return {minAns, maxAns};
}

三、栈

题意：给 n 个数字在栈中，现在可以使用一个中转栈，最终把数字移动到第三个栈中。
问最终第三个栈有多少种不同的排列。

思路：动态规划

状态定义：dp(n) n 个不同数字最终的排列数。

状态转移方程：
第 1 个数字可以借助中转栈，位于排列的第 i 个位置。
此时，第二个到第 i 个数字都需要先到达第三个栈，剩余的数字是独立的子问题。

dp(n) = sum(dp(i-1) * dp(n-i))  

复杂度：O(n^2)

ll Dfs(int n) {
  ll& ret = dp[n];
  if (ret != -1) {
    return ret;
  }
  ret = 0;
  for (int i = 0; i < n; i++) {
    ret += Dfs(i) * Dfs(n - i - 1);
  }
  return ret;
}

四、麦森数

题意：求 2^p-1 的位数与最低 500 位数字。
p 范围 [1000,3100000]

思路：高精度乘法

如果直接使用高精度乘法，只能得 50 分。
使用快速幂与高精度乘法，只能得 60 分。

所以，我就思考为何 p 最小值是 1000 而不是 1。

首先可以发现，2^p 的个位肯定不是 0，故减一不影响位数。
而 2^p 的位数等价于 log10(2^p)，转化一下就是 p * log10(2)。
这个值就是十进制的位数。

p 太小时，会存在精度问题。
p 最小值限制为 1000，显然是大于 1000 时就没有精度问题。

故直接使用公式计算位数。
而高精度计算时，剪枝只保留最低 500 位即可。

BigNum& Smp() {
  while (data.size() > 1 && data.back() == 0) {
    data.pop_back();
  }
  while(data.size() > 500){
      data.pop_back();
  }
  return *this;
}
BigNum operator*(const BigNum& other) const {
  BigNum res;
  res.data.resize(data.size() + other.data.size() + 1, 0);
  for (int i = 0; i < data.size(); i++) {
    ll carry = 0;
    int pos = i;
    for (int j = 0; j < other.data.size(); j++) {
      res.data[pos] += data[i] * other.data[j] + carry;
      carry = res.data[pos] / 10;
      res.data[pos] %= 10;
      pos++;
    }
    while (carry) {
      res.data[pos] += carry;
      carry = res.data[pos] / 10;
      res.data[pos] %= 10;
      pos++;
    }
  }
  return res.Smp();
}

五、最后

这次比赛有点坑，直接写高精度会超时。
必须本地手动验证下 1000 左右数学公式计算的位数是否正确，然后再直接使用数学公式。

《完》

-EOF-

本文公众号：天空的代码世界
个人微信号：tiankonguse
公众号 ID：tiankonguse-code