垃圾ACMer的暑假训练220713

垃圾ACMer的暑假训练220713

BIT

5.8 Yet Another Problem About Pairs Satisfying an Inequality

题意 ($2\mathrm{s}$)

原题指路:https://codeforces.com/contest/1703/problem/F

有$t(1\le t\le 1000)$组测试数据.给定一个元素在$[0,1\mathrm{e}9]$内的、长度为$n(2\le n\le 2\mathrm{e}5)$的序列$a[]$.求$(i,j)(1\le i,j\le n)s.t.a_i<i<a_j<j$.所有测试数据的$n$之和不超过$2\mathrm{e}5$.注意答案可能爆int.

思路I

将$a_i<i<a_j<j$拆为三部分:①$a_i<i$;②$i<a_j$;③$a_j<j$.其中①和③扫一遍序列检查即可,则只需统计满足②的数的个数.

可用指针$j$扫一遍序列,用一个vector存在$j$之前出现的下标$i$,则每个$j$对答案的贡献是vector中满足$i<a_j$的数的个数,可用二分求得.最后将当前下标$j$插入vector中即可.

代码I

const int MAXN = 2e5 + 5;
int n;
int a[MAXN];

int main() {
	CaseT{
		cin >> n;
		for (int i = 1; i <= n; i++) cin >> a[i];

		ll ans = 0;
		vi tmp;
		for (int i = 1; i <= n; i++) {
			if (a[i] >= i) continue;
			ans += (ll)(lower_bound(all(tmp), a[i]) - tmp.begin());  // 求使得i<a_j的个数
			tmp.push_back(i);
		}
		cout << ans << endl;
	}
}

---

思路II

统计满足$i<a_j$的$i$的个数可用BIT实现.

代码II

const int MAXN = 2e5 + 5;
int n;
int a[MAXN];
int BIT[MAXN];
ll pre[MAXN];  // 存BIT求得的前缀和

void add(int x, int v) {  // a[x]+=v
	for (int i = x; i <= n; i += lowbit(i)) BIT[i] += v;
}

ll query(int x) {
	ll res = 0;
	for (int i = x; i; i -= lowbit(i)) res += BIT[i];
	return res;
}

int main() {
	CaseT{
		cin >> n;
		for (int i = 0; i <= n; i++) BIT[i] = 0;

		ll ans = 0;
		for (int i = 1; i <= n; i++) {
			int x; cin >> x;
			if (x < i) {
				if (x - 1 >= 0) ans += pre[x - 1];  // 满足i<a_j的i的个数是BIT[0...(x-1)]的前缀和
				add(x + 1, 1);  // x的下标从1开始
			}
			pre[i] = query(i);  // 记录前缀和
		}
		cout << ans << endl;
	}
}

---

---

DP

9.1 Good Key, Bad Key $(3\mathrm{s})$

题意

原题指路:https://codeforces.com/contest/1703/problem/G

有编号$1\sim n$的$n$个箱子,其中第$i(1\le i\le n)$个箱子有$a_i$个金币.

有两种钥匙可以开箱子:①好钥匙,价值$k$个金币;②坏钥匙,无需花费,但包括当前准备打开的箱子在内的之后的箱子中的金币数都会变为原来的一半(下取整).严格地说,用坏钥匙打开第$i$个箱子,会让$a_i=\lfloor \frac{a_i}{2}\rfloor ,a_{i+1}=\lfloor \frac{a_{i+1}}{2}\rfloor ,\cdots ，a_n=\lfloor \frac{a_n}{2}\rfloor$.每把钥匙只能用一次.

初始时,你没有钥匙和金币.现你要依次打开所有箱子.规定途中你的金币数可以为负.求打开所有箱子后剩余的金币的最大值.

有$t(1\le t\le 1\mathrm{e}4)$组测试数据.每组测试数据第一行输入两整数$n,k(1\le n\le 1\mathrm{e}5,0\le k\le 1\mathrm{e}9)$,分别表示箱子数和一把好钥匙的价格.第二行输入$n$个数$a_i(0\le a_i\le 1\mathrm{e}9)$,分别表示每个箱子的金币数.数据保证所有测试数据的$n$之和不超过$1\mathrm{e}5$.

对每组测试数据,输出打开所有箱子剩余的金币的最大值,注意答案可能爆int.

思路I

显然开到第$i$个箱子时使用的坏钥匙不超过$\min (i,31)$把.$dp[i][j]$表示开到第$i$个箱子、用了$j$把坏钥匙的后剩余金币的最大值,则$ans=\underset{1\le j\le 31}{\max }dp[n][j]$.

因用坏钥匙会将后面的箱子的收益减半,则可在输入$a[i]$时预处理出$a[i][]$,其中$a[i][j]=a[i][0]>>j$.

枚举当前所用的坏钥匙数 j    ( 0 ≤ j ≤ min ⁡ { i , 31 } ) j\ \ (0\leq j\leq \min\{i,31\}) j  (0≤j≤min{i,31}).对每个$j$,按第$i$个箱子用好钥匙还是坏钥匙分类:

​ ①用好钥匙:$dp[i][j]=dp[i-1][j]-k+a[i][j]$.

​ ②用坏钥匙$(j>0)$:$dp[i][j]=\{\begin{array}{l}dp[i-1][j-1]+a[i][j],1\le j<31\\ dp[i-1][j],j=31\end{array}$.

​ 最终$dp[i][j]$为三者取$\max$.

代码I

const int MAXN = 1e5 + 5;
int n, k;  // 箱子数、钥匙数
int a[MAXN][32];  // a[i][j]=a[i][0]>>j
ll dp[MAXN][32];  // dp[i][j]表示开到第i个箱子、用j把坏钥匙的最大收益

int main() {
	CaseT{
		// memset(dp, 0, so(dp));  // 会TLE
		
		cin >> n >> k;
		for (int i = 1; i <= n; i++) {
			cin >> a[i][0];
			dp[i][0] = 0;
			for (int j = 0; j <= min(i, 31); j++) {
				dp[i][j] = 0;
				a[i][j] = a[i][0] >> j;  // 预处理a[i][]
			}
		}

		for (int i = 1; i <= n; i++) {
			for (int j = 0; j <= min(i, 31); j++) {  // 最多用i把钥匙
				dp[i][j] = dp[i - 1][j] - k + a[i][j];  // 当前用好钥匙
				if (j) dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + a[i][j]);  // 当前用坏钥匙
				if (j == 31) dp[i][j] = max(dp[i][j], dp[i - 1][j]);  // j=31时已无收益
			}
		}

		ll ans = -INFF;
		for (int j = 0; j <= 31; j++) ans = max(ans, dp[n][j]);
		cout << ans << endl;
	}
}

---

代码II:记搜

int main() {
	CaseT{
		int n,k; cin >> n >> k;
		vl a(n + 1);
		for (int i = 1; i <= n; i++) cin >> a[i];

		vector<vl> dp(n + 1, vl(32, -INFF));  // dp[i][j]表示开到第i个箱子、用j把坏钥匙的最大收益

		function<ll(int, int)> solve = [&](int i, int j)->ll {  // 记搜求dp[i][j]
			if (i > n || j == 31) return 0;
			if (dp[i][j] != -INFF) return dp[i][j];

			return dp[i][j] = max(solve(i + 1, j) - k + (a[i] >> j), solve(i + 1, j + 1) + (a[i] >> (j + 1)));
		};

		cout << solve(1, 0) << endl;  // 当前开到第1个箱子,用了0把坏钥匙
	}
}

---

---

思路II

最优策略是先对前缀用好钥匙,剩下的用坏钥匙.

[证] 考察相邻两个箱子$a_i$和$a_{i+1}$.

①若先用坏钥匙,再用好钥匙,则贡献为$\lfloor \frac{a_i}{2}\rfloor +\lfloor \frac{a_{i+1}}{2}\rfloor -k$.

②若先用好钥匙,再用坏钥匙,则贡献为$a_i+\lfloor \frac{a_{i+1}}{2}\rfloor -k$.显然后者大于前者.

代码III

int main() {
	CaseT{
		int n,k; cin >> n >> k;
		vl a(n + 1), pre(n + 1, 0);
		for (int i = 1; i <= n; i++) {
			cin >> a[i];
			pre[i] = pre[i - 1] + a[i];
		}

		ll ans = -INFF;
		for (int i = 0; i <= n; i++) {  // 枚举用好钥匙的前缀,i=0时表示全用坏钥匙
			ll res = pre[i] - (ll)k * i;  // 用了i把坏钥匙
			for (int j = i + 1; j <= min(i + 31, n); j++)  // 枚举用了几把坏钥匙
				res += a[j] >> (j - i);
			ans = max(ans, res);
		}
		cout << ans << endl;
	}
}

---

---

二分

2.6 Educational Codeforces Round 131 (Rated for Div. 2) C. Schedule Management

题意 ($2\mathrm{s}$)

原题指路:https://codeforces.com/contest/1701/problem/C

有编号$1\sim n$的$n$个工人和编号$1\sim m$的$m$项工作,每项工作有一个值$a_i$,表示擅长这项工作擅长的工人的编号.若工人做一项其擅长的工作,则需花费$1\mathrm{h}$,否则需花费$2\mathrm{h}$.每个工人同时只能做一项工作.

有$t(1\le t\le 1\mathrm{e}4)$组测试数据.每组测试数据第一行输入两整数$n,m(1\le n\le m\le 2\mathrm{e}5)$,分别表示工人数、工作数.第二行输入$m$个整数$a_i(1\le a_i\le n)$,分别表示第$i$项工作擅长的工人的编号.数据保证所有测试数据的$m$之和不超过$2\mathrm{e}5$.

对每组测试数据,输出完成所有工作的最少时间.

思路

用$cnt[i]$记录$i$号工人擅长的工作数.

二分工作时间,check当前时间内能否做完所有工作.显然最长时间不超过$2m$.

显然应让工人在给定时间内先做其擅长的工作,若还有剩余时间,再做其不擅长的工作.设给定时间$t$内能完成的净工作数为$task$,则$t$内能完成所有工作等价于$task\ge 0$.对每个工人$i$,若$t\ge cnt[i]$,则他不仅能做完擅长的工作,还能多做$\lfloor \frac{t-cnt[i]}{2}\rfloor$项工作;若$t<cnt[i]$,则他只能做完$(cnt[i]-t)$项工作.

代码

const int MAXN = 2e5 + 5;
int n, m;
int pro[MAXN];  // pro[u]记录事件u擅长的人
int cnt[MAXN];  // cnt[i]表示第i人擅长的事情的数量

bool check(int t) {  // 时间t内能否做完
	ll task = 0;
	for (int i = 1; i <= n; i++) {
		if (t >= cnt[i]) task += (ll)(t - cnt[i]) / 2;  // 1小时的都能做完,多做一些2小时的
		else task -= (ll)(cnt[i] - t);
	}
	return task >= 0;
}

int main() {
	CaseT{
		cin >> n >> m;
		for (int i = 1; i <= n; i++) cnt[i] = 0;
		
		for (int i = 1; i <= m; i++) {
			cin >> pro[i];
			cnt[pro[i]]++;
		}

		int l = 0, r = 2 * m;
		while (l < r) {
			int mid = l + r >> 1;
			if (check(mid)) r = mid;
			else l = mid + 1;
		}
		cout << l << endl;
	}
}

---

---