垃圾ACMer的暑假训练220710

垃圾ACMer的暑假训练220710

蓝桥杯算法训练

2. 二分与前缀和

①二分前一个区间$A$的右端点:将$[l,r]$分为$[l,mid-1]$和$[mid,r]$.若$mid$满足$A$的性质,则$ans$在$[mid,r]$中,否则$ans$在$[l,mid-1]$中.

while(l < r) {
  int mid = l + r + 1 >> 1;  // +1避免l=r-1时死循环
  if(mid满足A的性质) l = mid;  // 判断标志
  else r = mid - 1;
}

②二分后一个区间$B$的左端点:将$[l,r]$分为$[l,mid]$和$[mid+1,r]$.若$mid$满足$B$的性质,则$ans$在$[l,m]$中,否则$ans$在$[mid+1,r]$.

while(l < r) {
  int mid = l + r >> 1;  // l=r-1时不会死循环
  if(mid满足B的性质) r = mid;  // 判断标志
  else l = mid + 1;
}

---

2.1 机器人跳跃 $(3\mathrm{s})$

题意

有编号$0\sim n(1\le n\le 1\mathrm{e}5)$的$(n+1)$个建筑从左到右排列.编号为$0$的建筑高度为$0$,编号为$i(1\le i\le n)$的建筑高度为$h_i(1\le h_i\le 1\mathrm{e}5)$.初始时机器人在编号为$0$的建筑处,每一步它将跳到右边的下一个建筑处.设机器人在第$k$个建筑处,且它当前的能量为$E$,下一步它将跳到第$(k+1)$个建筑.若$h_{k+1}>E$,则机器人失去$h_{k+1}-E$的能量,否则它得到$E-h_{k+1}$的能量.游戏目标是到达第$n$个建筑,途中能量不能为负值.求机器人至少以多少能量开始游戏才能保证成功完成游戏.

第一行输入一个$n$.第二行输入$n$个整数$h_1,\cdots ,h_n$.

输出机器人所需的最小能量,答案上取整.

思路

①$h_{k+1}>E$时,$E-(h_{k+1}-E)=2E-h_{k+1}$.

②$h_{k+1}\le E$时,$E+(E-h_{k+1})=2E-h_{k+1}$.

故两种情况的能量更新都是$2E-h_{k+1}$,

初始能量具有单调性,即若初始能量为$E_0$时满足条件,则$\forall E_0^{\prime }\ge E$也满足条件.

[证] 设初始能量为$E_0$时,机器人到达第$1\sim n$个建筑处的能量依次为$E_1,\cdots ,E_n(E_i\ge 0,1\le i\le n)$.

初始能量为$E_0^{\prime }$时,注意到$E_1^{\prime }=2E_0^{\prime }-h_1\ge 2E_0-h_1=E_1$,数归即证.

check()函数可递推一遍看中途会不会出现负值,但这样每次能量乘$2$会爆long long.设建筑物高度的最大值为$maxh$.若$E\ge maxh$,则$2E-h_i\ge E+E-h_i\ge E+(maxh-h_i)\ge E$,即能量单调增.故只需中途能量$E\ge maxh$即可返回true.

代码

const int MAXN = 1e5 + 5;
int n;
int h[MAXN];
int maxh = -INF;

bool check(int e) {
	for (int i = 1; i <= n; i++) {
		e = e * 2 - h[i];
		if (e >= maxh) return true;
		if (e < 0) return false;
	}
	return true;
}

int main() {
	cin >> n;
	for (int i = 1; i <= n; i++) {
		cin >> h[i];
		maxh = max(maxh, h[i]);
	}

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

---

---

2.2 四平方和

题意

输入一个正整数$n(0<n<5\mathrm{e}6)$,求$0\le a\le b\le c\le ds.t.n=a^2+b^2+c^2+d^2$,对所有的$(a,b,c,d)$升序排列,输出字典序最小的表示法.

思路

注意到$a,b,c,d\le \sqrt{n}\le 2232$,则最多只能枚举两个数.

可先枚举较大的$c$和$d$,记录下所有$c^2+d^2$可能的取值.再枚举较小的$a$和$b$,计算$t=n-a^2-b^2$,判断$t$是否在$c^2+d^2$中出现过,可用哈希$O(1)$或二分$O(\log n)$实现,二分的时间复杂度$5\mathrm{e}6\times \lg (5\mathrm{e}6)\approx 1\mathrm{e}8$,但枚举时$a\le b\le c\le d$,故复杂度约要除以$2$,可过.

注意到$a$从$0$开始枚举,$b$从$a$开始枚举,若找到解,则$(a,b)$字典序最小.对 { c 2 + d 2 , c , d } \{c^2+d^2,c,d\} {c2+d2,c,d}升序排列即可保证解的$(c,d)$字典序最小.

总时间复杂度:①暴力枚举$O(n^3)$;②哈希$O(n^2)$;③二分$O(n^2\log n)$.实际运行中二分最快,因为哈希表常数大.

代码I:暴力枚举(TLE)

int n;

int main() {
	cin >> n;
	
	for (int a = 0; a * a <= n; a++) {
		for (int b = a; a * a + b * b <= n; b++) {
			for (int c = b; a * a + b * b + c * c <= n; c++) {
				int t = n - a * a - b * b - c * c;
				int d = sqrt(t);
				if (d * d == t) 
					return cout << a << ' ' << b << ' ' << c << ' ' << d << endl, 0;
			}
		}
	}
}

---

代码II:二分

const int MAXN = 2.5e6 + 5;  // 5e6 / 2
int n;
struct Sum {
	int s, c, d;  // s=c^2+d^2
	
	bool operator<(const Sum& p)const {
		if (s != p.s) return s < p.s;
		else if (c != p.c) return c < p.c;
		else return d < p.d;
	}
}sum[MAXN];

int main() {
	cin >> n;
	
	// 预处理出所有c^2+d^2
	int idx = 0;
	for (int c = 0; c * c <= n; c++)
		for (int d = c; c * c + d * d <= n; d++)
			sum[idx++] = { c * c + d * d,c,d };
	sort(sum, sum + idx);

	for (int a = 0; a * a <= n; a++) {
		for (int b = a; a * a + b * b <= n; b++) {
			int t = n - a * a - b * b;
			
			// 二分是否存在c^2+d^2=t
			int l = 0, r = idx - 1;
			while (l < r) {
				int mid = l + r >> 1;
				if (sum[mid].s >= t) r = mid;
				else l = mid + 1;
			}
			if (sum[l].s == t)  // 判断是否存在
				return cout << a << ' ' << b << ' ' << sum[l].c << ' ' << sum[l].d << endl, 0;
		}
	}
}

---

代码III:哈希表(TLE)

int n;
umap<int, pii> s;  // s[c^2+d^2]={c,d}

int main() {
	cin >> n;
	
	// 预处理出所有c^2+d^2
	int idx = 0;
	for (int c = 0; c * c <= n; c++) {
		for (int d = c; c * c + d * d <= n; d++) {
			int t = c * c + d * d;
			if (!s.count(t)) s[t] = { c,d };  // 只记录第一个出现的c^2+d^2
		}
	}

	for (int a = 0; a * a <= n; a++) {
		for (int b = a; a * a + b * b <= n; b++) {
			int t = n - a * a - b * b;
			
			if (s.count(t)) 
				return cout << a << ' ' << b << ' ' << s[t].first << ' ' << s[t].second << endl, 0;
		}
	}
}

---

---

2.3 分巧克力

题意

有$k(1\le k\le 1\mathrm{e}5)$个小朋友和有$n(1\le n\le 1\mathrm{e}5)$块巧克力,其中第$i(1\le i\le n)$块是$h_i\times w_i(1\le h_i\le w_i\le 1\mathrm{e}5)$的长方形.现需从$n$块巧克力中切出$k$块分给小朋友,要求巧克力形状是边长为整数的大小相同的正方形.求每个小朋友能得到的最大边长.数据保证每个小朋友至少能获得$1\times 1$的正方形.

思路

边长为$w_i\times h_i$能切出边长为$x$的正方形$\lfloor \frac{w_i}{x}\rfloor \lfloor \frac{h_i}{x}\rfloor$个.显然边长越大,能切出来的块数越小,即具有单调性.显然可二分出块数$\ge k$的最大边长.

check()函数需扫一遍$n$块巧克力.总时间复杂度 O ( n log ⁡ max ⁡ { h i , w i } ) O(n\log\max\{h_i,w_i\}) O(nlogmax{hi​,wi​}).

代码

const int MAXN = 1e5 + 5;
int n, k;  // 巧克力数、人数
int h[MAXN], w[MAXN];

bool check(int m) {
	int res = 0;
	for (int i = 0; i < n; i++) {
		res += (h[i] / m) * (w[i] / m);
		if (res >= k)return true;
	}
	return false;
}

int main() {
	cin >> n >> k;
	for (int i = 0; i < n; i++) cin >> h[i] >> w[i];

	int l = 1, r = 1e5;
	while (l < r) {
		int mid = l + r + 1 >> 1;
		if (check(mid)) l = mid;
		else r = mid - 1;
	}
	cout << l;
}

---

---

2.4 激光炸弹 ($168\mathrm{M}\mathrm{B}$)

题意

地图上有$n(1\le n\le 1\mathrm{e}4)$个目标,其中第$i(1\le i\le n)$个目标的坐标为$(x_i,y_i)(0\le x_i,y_i\le 5000)$,价值为$w_i(0\le w_i\le 1000)$,不同目标可能在同一位置.激光炸弹可摧毁$r\times r(1\le r\le 1\mathrm{e}9)$的正方形的所有目标,其中炸弹只能放在整点上,且爆炸范围的正方形的边平行于$x$、$y$轴.求一颗炸弹能炸掉的目标的最大总价值.

思路

$r$最多取$5001$即可覆盖整个地图.若地图不够$r\times r$的正方形大,则可能会出现边界问题,故让地图的行数和列数至少为$r$.

暴力枚举各以$(i,j)$为右下角的、边长为$r$的正方形内的和.

若开一个$5000\times 5000$的原数组和一个$5000\times 5000$的前缀和数组,则需$\frac{2\times 5000^2\times 4}{1024\times 1024}\approx 200\mathrm{M}\mathrm{B}$,会MLE,故只能开一个前缀和数组.

代码

const int MAXN = 5005;
int n, m;  // 行数、列数
int pre[MAXN][MAXN];

int main() {
	int cnt, r; cin >> cnt >> r;
	r = min(5001, r);

	n = m = r;  // 防边界问题

	while (cnt--) {
		int x, y, w; cin >> x >> y >> w;
		x++, y++;  // 下标从1开始
		n = max(n, x), m = max(m, y);
		pre[x][y] += w;
	}

	for (int i = 1; i <= n; i++)  // 预处理前缀和
		for (int j = 1; j <= m; j++)
			pre[i][j] += pre[i - 1][j] + pre[i][j - 1] - pre[i - 1][j - 1];

	int ans = 0;
	for (int i = r; i <= n; i++)  // 枚举以(i,j)为右下角的边长为r的正方形
		for (int j = r; j <= m; j++)
			ans = max(ans, pre[i][j] - pre[i - r][j] - pre[i][j - r] + pre[i - r][j - r]);
	cout << ans;
}

---

---

2.5 k倍区间

题意

对长度为$n(1\le n\le 1\mathrm{e}5)$的数列$a_1,\cdots ,a_n(1\le a_i\le 1\mathrm{e}5)$,若其中一段连续的子序列$a_i,\cdots ,a_j$之和是$k(1\le k\le 1\mathrm{e}5)$的倍数,则称区间$[i,j]$为$k$倍区间.求序列中$k$倍区间的个数.

思路

枚举每个区间$[l,r]$,用前缀和求区间内的和,总时间复杂度为$O(n^2)$.

考虑优化.枚举每个区间$[l,r]$,其中的数的和为$pre[r]-pre[l-1]$,即在$0\sim r$的范围求有多少个$ls.t.(pre[r]-pre[l-1])\%k=0$,亦即在$0\sim (r-1)$的范围求有多少个$ls.t.(pre[r]-pre[l])\%k=0$,即有多少个$pre[l]$与$pre[r]$模$k$的余数相等.用数组$cnt[i]$表示余数为$i$的数的个数.总时间复杂度$O(n)$.

代码

const int MAXN = 1e5 + 5;
int n, k;
ll pre[MAXN];
int cnt[MAXN];  // cnt[i]表示余数为i的数的个数

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

	ll ans = 0;
	cnt[0] = 1;  // pre[0]=0,模k余0
	for (int i = 1; i <= n; i++) {
		ans += cnt[pre[i] % k];
		cnt[pre[i] % k]++;
	}
	cout << ans;
}

---

---