第一周测试赛 & 第二周测试赛

监控

1、算法思想维度

问题类型：贪心、并查集

误判原因：并查集处理区间覆盖时直接从 \(r\) 开始，应该从 Find(r)，因为 \(r\) 可能已经被覆盖。

正确思路：考虑按右端点排序，我们肯定监视最右边的 \(k\) 个点，因为这样可以与后面区间重合的更多，考虑用树状数组维护区间和，并查集维护前一个没有被监视的点，即可。

2、实现细节维度

边界条件：排序时右端点相同按左端点从小到大排序。

数据结构：使用链表会更快。

3、数学建模维度

复杂度计算：

因为每个点只会被选择一次

• 树状数组：\(O(q \log n)\)
• 并查集：\(O((q + n) \log n)\)
• 总复杂度：\(O((q + n)\log n)\)

4、改进措施

1. 注意细节，写完代码后尽量默读一遍，找出潜在错误。
2. 不要只会使用高级算法，要一题多解，练好基本功。

age

1、算法思想维度

问题类型判定：分讨、二分

误判原因：没有时间做……

正确思路：当 \(b > 10^6\) 时，\(x\) 至多 \(3\) 位，枚举 \(x\)，二分 \(b\)，判断 \(y\) 是否满足条件，当 \(b \le 10^6\)，枚举 \(b\) 判断即可。

2、实现细节维度

边界条件：当 \(x > 100\) 时，将二分边界缩小，否则会爆 long long。

框架提炼

int W(int x, int k) {
	int val = 0, bs = 1;
	for (; x; x /= k, bs *= 10) {
		if (x % k >= 10) {
			return -1;
		}
		val += bs * (x % k);
	}
	return val;
}
int C(int x, int k) {
	return x % 10 + (x / 10 % 10) * k + (x / 100) * k * k;
}

signed main() {
	ans = 10;
	cin >> n >> m;
	for (int i = m; i <= 999; i++) {
		int l = 1, r = 1e18;
		for (; l < r;) {
			int mid = (l + r) / 2;
			C(i, mid) >= n ? r = mid : l = mid + 1;
		}
		if (C(i, r) == n) {
			ans = max(ans, r);
		}
	}
	for (int i = 1e6; i >= ans; i--) {
		if (W(n, i) >= m) {
			ans = i;
			break;
		}
	}
	cout << ans;
}

亲密度

1、算法思想维度

问题类型判定：二分。

误判原因：一眼不会就放弃了，应该在仔细思考的。

正确思路：考虑枚举判断第 \(k\) 对的亲密度是否是 \(x\)，考虑求出所有亲密度为 \(x\) 的二元组，在用双指针减去颜色相同的，很显然这个过程可以用二分优化。

2、实现细节维度

边界条件：注意要开 long long，如果所有合法二元组都没有 \(k\) 个就输出 -1。

框架提炼

int Calc(int x) {
	int p = (n - x) * x + x * (x - 1) / 2;
	for (int i = 1; i <= n; i++) {
		int l = 0;
		for (int j = 0; j < v[i].size(); j++) {
			for (; l < v[i].size() && v[i][j] - v[i][l] > x; l++);
			p -= (j - l);
		}
	}
	return p;
}

signed main() {
	cin >> n >> k;
	for (int i = 1; i <= n; i++) {
		cin >> a[i];
		v[a[i]].push_back(i);
	}
	if (Calc(n) < k) {
		return cout << -1, 0;
	}
	int l = -1, r = n + 1;
	for (; l + 1 < r;) {
		int mid = (l + r) / 2;
		Calc(mid) < k ? l = mid : r = mid;
	}
	int cnt = Calc(l), d = l + 1;
	for (int i = 1; i <= n - d; i++) {
		if (a[i] != a[i + d]) {
			cnt++;
		}
		if (cnt == k) {
			return cout << i << ' ' << i + d, 0;
		}
	}
}

3、数学建模维度

• 二分：\(O(\log n)\)，Check：\(O(n)\)
• 总共 \(O(n\log n)\)。

4、改进措施

1. 分配好时间，注意策略，昨晚前两题后在后两题里选最擅长的做。

抢红包

1、算法思想维度

问题类型判定：堆、DP

误判原因：过于浮躁，导致算法选择出现问题一个很简单的问题查了很久。

正确思路：DP，然后用按左端点排序，用堆懒删除维护。

2、实现细节维度

边界条件：\(f_{1,0}=f_{1,1}=0\)，其余为 \(10^9\)。

数据结构：开始使用没有懒标记的线段树，应该使用堆或懒标记。

框架提炼

sort(a + 1, a + k + 1, [](Node x, Node y) { return x.s < y.s; });
	fill(f[1], f[n + 2], 1e18), f[1][0] = f[1][1] = 0;
	for (int i = 1, j = 1; i <= n; i++) {
		for (; j <= k && a[j].s == i; j++) {
			q.push(a[j]);
		}
		for (; q.size() && q.top().t < i; q.pop());
		if (q.empty()) {
			for (int j = 0; j <= m; j++) {
				f[i + 1][j] = min(f[i + 1][j], f[i][j]);
			}
		} else {
			for (int j = 0; j <= m; j++) {
				f[q.top().d + 1][j] = min(f[q.top().d + 1][j], f[i][j] + q.top().w);
			}
			for (int j = 0; j < m; j++) {
				f[i + 1][j + 1] = min(f[i + 1][j + 1], f[i][j]);
			}
		}
	}

3、数学建模维度

状态定义：\(f_{i,j}\) 表示前 \(i\) 个数跳过 \(j\) 次的最小值。

转移方程：若能领红包则 \(f[q.top().d + 1][j] = min(f[q.top().d + 1][j], f[i][j] + q.top().w),f[i + 1][j + 1] = min(f[i + 1][j + 1], f[i][j]);\)，否则 \(f[i + 1][j] = min(f[i + 1][j], f[i][j])\)。

复杂度计算：

状态数量：\(nm\)。

转移复杂度：\(O(1)\) 或 \(O(\log n)\)

总复杂度 \(nm\)。

4、改进措施

1. 考试时不能浮躁，要把代码想清楚了再写。