垃圾ACMer的暑假训练220709

垃圾ACMer的暑假训练220709

12. 贪心

12.8 Calling

题意

有$T(1\le T\le 1\mathrm{e}5)$组测试数据.有六种正方形纸片,其中边长为$i(1\le i\le 6)$的正方形有$k_i(0\le k_i\le 1\mathrm{e}4)$个.现需将它们放在至多$s(0\le s\le 1\mathrm{e}9)$个边长为$6$的正方形框内,每个框未必放满,每个框内的正方形边长未必相同.若能放下,输出"Yes",否则输出"No".

思路

用变量$need$表示放下所有纸片需要的框数的最小值,将其与$s$比较,判断是否有解.

显然$6\times 6,5\times 5,4\times 4$的纸片一个纸片需要一个框,$3\times 3$的纸片一个框可放$4$个,$2\times 2$和$1\times 1$的纸片插空放.

贪心,先放$6\times 6,5\times 5,4\times 4,3\times 3$的纸片,若还剩下$d\ne 0$个$3\times 3$纸片,分三种情况:①若$d=1$,则还能放下$5$个$2\times 2$的纸片;②若$d=2$,则还能放下$3$个$2\times 2$的纸片;③若$d=3$,则还能放下$1$个$2\times 2$的纸片.用变量$put2$记录还能放的$2\times 2$纸片数.

若还剩下$2\times 2$的纸片,则开新的框放.边长为$2\times 6$的纸片放完后用到的框的剩余面积即还能放的$1\times 1$纸片数,将其与给定的纸片数比较,判断是否有解.

代码

const int MAXN = 7;
int s;  // 6x6框数
int cnt[MAXN];  // cnt[i]表示边长为i的正方形的个数

int main() {
	CaseT{
		cin >> s;
		for (int i = 1; i <= 6; i++) cin >> cnt[i];

		int need = cnt[6] + cnt[5] + cnt[4] + ceil(cnt[3] / 4.0);

		int put2 = cnt[4] * 5;  // 还能放的2x2的个数
		if (cnt[3] % 4 != 0) {  // 3x3还有剩
			if (cnt[3] % 4 == 1) put2 += 5;
			else if (cnt[3] % 4 == 2) put2 += 3;
			else if (cnt[3] % 4 == 3) put2 += 1;
		}
		
		if (cnt[2] > put2) need += ceil((cnt[2] - put2) / 9.0);  // 还有2x2没放,开新的框

		int put1 = 6 * 6 * need;  // 剩余面积
		for (int i = 2; i <= 6; i++) put1 -= i * i * cnt[i];
		if (cnt[1] > put1) need += ceil((cnt[1] - put1) / 36.0);  // 还有1x1没放,开新的框

		cout << (need <= s ? "Yes" : "No") << endl;
	}
}

---

---

1. 递推与递归

1.4 简单斐波那契

题意

输入整数$n(0<n<46)$,输出斐波那契数列的前$n$项.如$n=5$时,前$5$项为:$01123$.

代码I

const int MAXN = 50;
int n;
int fib[MAXN];

int main() {
	cin >> n;

	fib[1] = 0, fib[2] = 1;
	for (int i = 3; i <= n; i++) fib[i] = fib[i - 1] + fib[i - 2];
	
	for (int i = 1; i <= n; i++) cout << fib[i] << ' ';
}

---

思路

注意到$fib[n](n\ge 3)$只与$fib[n-1]$和$fib[n-2]$有关,则可用变量$a=fib[n-2],b=fib[n-1]$,下一步令$a=fib[n-1],b=fib[n]$,滚动.

代码II:滚动优化空间

int main() {
	int n; cin >> n;

	int a = 0, b = 1;
	for (int i = 0; i < n; i++) {
		cout << a << ' ';
		int c = a + b;
		a = b, b = c;
	}
}

---

---

1.5 费解的开关

题意

$25$盏灯排成$5\times 5$的正方形,每盏灯有一开关,玩家可改变其状态.每一步,玩家可选择改变某一灯的状态,同时该灯上下左右的灯的状态也会改变.用$1$表示灯亮,$0$表示灯灭.给定游戏初始状态,判断$6$步内是否可使所有灯亮.

有$t(1\le t\le 500)$组测试数据,每组测试数据输入$5\times 5$的矩阵表示初始状态,各组测试数据间用空行分隔.

若能在$6$步内使所有灯亮,输出最小步数,否则输出$-1$.

思路

注意到最终每个开关的状态只与其及其上下左右的切换次数的奇偶有关,则最终结果与操作顺序无关.注意到每个灯至多切换一次状态.

枚举第一行的$2^5=32$种操作,考虑第二行的操作.注意到此时能影响第一行的灯的状态的只有其正下方的第二行的灯,为使所有灯亮,则第一行灭的灯的下方的灯必须切换,第一行亮的灯的下方的灯必须不切换,即第二行的操作被第一行灯的状态唯一确定.同理下一行的状态被当前行的状态唯一确定.操作完第$5$行后,第$1\sim 5$行灯全亮,若此时第$6$行灯全亮,则有解,更新最小步数;若此时第$6$行灯不全亮,则无解.

代码

const int MAXN = 6;
char graph[MAXN][MAXN], backup[MAXN];
int dx[5] = { -1,0,1,0,0 }, dy[5] = { 0,1,0,-1,0 };

void turn(int x, int y) {
	for (int i = 0; i < 5; i++) {
		int curx = x + dx[i], cury = y + dy[i];
		if (curx < 0 || curx >= 5 && cury < 0 || cury >= 5) continue;
		graph[curx][cury] ^= 1;
	}
}

int main() {
	CaseT{
		for (int i = 0; i < 5; i++) cin >> graph[i];
		
		int ans = INF;  // >6的数
		for (int op = 0; op < 32; op++) {  // 枚举第一行的状态
			memcpy(backup, graph, so(graph));
			int step = 0;
			for (int i = 0; i < 5; i++) {
				if (op >> i & 1) {
					step++;
					turn(0, i);
				}
			}

			for (int i = 0; i < 4; i++) {  // 下一行的操作由当前行完全确定
				for (int j = 0; j < 5; j++) {
					if (graph[i][j] == '0') {
						step++;
						turn(i + 1, j);
					}
				}
			}

			bool ok = true;
			for (int i = 0; i < 5; i++) {
				if (graph[4][i] == '0') {
					ok = false;
					break;
				}
			}

			if (ok) ans = min(ans, step);
			memcpy(graph, backup, so(graph));
		}

		if (ans > 6) ans = -1;
		cout << ans << endl;
	}
}

---

---

1.6 带分数

题意

$100$可表示为带分数的形式$100=3+\frac{69258}{714}=82+\frac{3546}{197}$,其中带分数中$1\sim 9$每个数字恰出现一次.类似这样的带分数,$100$有$11$种表示法.输入正整数$n(1\le n<1\mathrm{e}6)$,输出方案数.

思路

$n=a+\frac{b}{c}$,其中$a,b,c$的数码中$1\sim 9$恰出现一次.

暴力做法:枚举$1\sim 9$的全排列,时间复杂度$O(n\cdot n!)$,再枚举将哪段区间作为$a,b,c$,即枚举隔板的位置,时间复杂度$C_8^2$,最后判断等式是否成立.总时间复杂度约$9\mathrm{e}7$,但常数较小,可过.

考虑优化.注意到$1\le n\le 1\mathrm{e}6$,则$1\le a\le 1\mathrm{e}6$.又$cn=ac+b$,则可对每个枚举的$a$,再枚举$c$,最后计算出$b$.实现时,将$a$的搜索树的叶子节点扩展成一棵$c$的搜索树.

代码

const int MAXN = 10;
int n;
bool vis[MAXN];  // 记录每个数字是否被用过
int ans;

bool check(int a, int c) {
	ll b = (ll)n * c - (ll)a * c;
	if (!a || !b || !c) return false;

	static bool backup[MAXN];
	memcpy(backup, vis, so(vis));
	while (b) {
		int tmp = b % 10; b /= 10;
		if (!tmp || backup[tmp]) return false;
		backup[tmp] = true;
	}

	for (int i = 1; i <= 9; i++) 
		if (!backup[i]) return false;
	return true;
}

void dfs_c(int used, int a, int c) {  // 当前用了几个数字、a的值、当前c的值
	if (used > 9) return;

	if (check(a, c)) ans++;
	
	for (int i = 1; i <= 9; i++) {  // 枚举c的下一位
		if (!vis[i]) {
			vis[i] = true;
			dfs_c(used + 1, a, c * 10 + i);
			vis[i] = false;
		}
	}
}

void dfs_a(int used, int a) {  // 当前用了几个数字、当前a的值
	if (a >= n) return;  // a=n时b=0

	if (a) dfs_c(used, a, 0);  // a非零时,对每个a枚举c

	for (int i = 1; i <= 9; i++) {  // 枚举a的下一位
		if (!vis[i]) {
			vis[i] = true;
			dfs_a(used + 1, a * 10 + i);
			vis[i] = false;
		}
	}
}

int main() {
	cin >> n;

	dfs_a(0, 0);  // 当前用了0个数,当前a的值为0

	cout << ans;
}

---

---

1.7 飞行员兄弟

题意

$16$个开关排成$4\times 4$的矩阵,每个开关有闭合和断开两种状态,分别用$+$和$-$表示.每一步可切换开关$(i,j)(1\le i,j\le 4)$的状态,同时第$i$行和第$j$列的开关状态都切换.求将所有开关断开的最小切换步数.

输入$4\times 4$的矩阵表示开关初始状态,数据保证至少有一开关为闭合状态.

第一行输出最小切换步数$n$,接下来$n$行输出方案,每行输出两个数$i,j(1\le i,j\le 4)$表示切换开关$(i,j)$的状态.若存在多种开冰箱的方式,则按照优先级整体从上到下、同行从左到右打开.

思路

暴力枚举$2^{16}=65536$种方案,有$16$个开关,每个开关会改变$7$个开关的状态,检查$16$个开关是否都断开,若是,扫一遍记录方案,总时间复杂度$2^{16}(16\times 7+16+16)\approx 1\mathrm{e}7$.

因要输出字典序最小的方案,当两方案的最小步数相等时,应先枚举二进制数中$1$更靠前(低位)的方案.

代码I

const int MAXN = 5;
char graph[MAXN][MAXN], backup[MAXN][MAXN];

int get(int x, int y) { return x * 4 + y; }

void turn_one(int x, int y) {
	graph[x][y] = graph[x][y] == '+' ? '-' : '+';
}

void turn_all(int x, int y) {
	for (int i = 0; i < 4; i++) turn_one(x, i), turn_one(i, y);
	turn_one(x, y);  // (x,y)被改变两次
}

int main() {
	for (int i = 0; i < 4; i++) cin >> graph[i];

	vii ans;
	for (int op = 0; op < 1 << 16; op++) {  // 枚举每个开关的操作
		vii tmp;
		memcpy(backup, graph, so(backup));

		for (int i = 0; i < 4; i++) {
			for (int j = 0; j < 4; j++) {
				if (op >> get(i, j) & 1) {
					tmp.push_back({ i,j });
					turn_all(i, j);
				}
			}
		}

		bool ok = true;
		for (int i = 0; ok && i < 4; i++) {
			for (int j = 0; j < 4; j++) {
				if (graph[i][j] == '+') {
					ok = false;
					break;
				}
			}
		}

		if (ok)
			if (ans.empty() || ans.size() > tmp.size()) ans = tmp;

		memcpy(graph, backup, so(graph));
	}

	cout << ans.size() << endl;
	for (auto item : ans) cout << item.first + 1 << ' ' << item.second + 1 << endl;
}

---

代码II:位运算优化

const int MAXN = 5;
int graph[MAXN][MAXN];

int get(int x, int y) { return x * MAXN + y; }

int main() {
	for (int i = 0; i < 4; i++) {
		for (int j = 0; j < 4; j++) {
			for (int k = 0; k < 4; k++)
				graph[i][j] += (1 << get(i, k)) + (1 << get(k, j));
			graph[i][j] -= 1 << get(i, j);
		}
	}

	int state = 0;
	for (int i = 0; i < 4; i++) {
		string line; cin >> line;
		for (int j = 0; j < 4; j++)
			if (line[j] == '+') state += 1 << get(i, j);
	}

	vii ans;
	for (int op = 0; op < 1 << 16; op++) {  // 枚举每个开关的操作
		int cur = state;
		vii tmp;

		for (int j = 0; j < 16; j++) {
			if (op >> j & 1) {
				int x = j / 4, y = j % 4;
				cur ^= graph[x][y];
				tmp.push_back({ x,y });
			}
		}

		if (!cur && (ans.empty() || ans.size() > tmp.size())) ans = tmp;
	}

	cout << ans.size() << endl;
	for (auto item : ans) cout << item.first + 1 << ' ' << item.second + 1 << endl;
}

---

---

1.8 翻硬币

题意

给定硬币的初始状态和目标状态,用$\ast$表示正面,$o$表示反面.每一步能翻转相邻两硬币,求最小翻转步数.

表示状态的字符串长度不超过$100$,数据保证一定有解.

思路

显然至多需$50$步.若用BFS,时间复杂度$50^{99}$,会TLE.

将硬币的正反看作灯泡的亮灭,在相邻两灯泡间放一个可反转它们的开关.从左往右考察初始状态与目标状态的当前位置是否相同,若不同,则必须按开关,否则必须不按开关.显然解是被唯一确定的.总时间复杂度$O(n)$.

代码

const int MAXN = 105;
string start, target;

void turn(int pos) {
	start[pos] = start[pos] == '*' ? 'o' : '*';
}

int main() {
	cin >> start >> target;
	
	int ans = 0;
	for (int i = 0; i < start.length() - 1; i++) {
		if (start[i] != target[i]) {
			turn(i), turn(i + 1);
			ans++;
		}
	}
	cout << ans;
}

---

---