bfs 非常可乐

#include<iostream>
#include<queue>
using namespace std;
struct cola { int s, n, m;int  ans; }a;
int vis[101][101][101];
int main() {
	int  s, n, m;
	while (cin >> s >> n >> m) { 
		bool judge = 0;
		if (s == 0 && n == 0 && m == 0)break;
		queue <cola> c;
		a.s = s, a.n = 0, a.m = 0, a.ans = 0;
		c.push(a);
		for (int i = 0; i < 100; i++) {
			for (int j = 0; j <= 100; j++) {
				for (int k = 0; k <= 100; k++) { vis[i][j][k] = 0; }
			}
		}cola bef, next;

		vis[s][0][0] = 1;
		if (s % 2 == 1) judge = 0;
		else {
			while (!c.empty()) {
				bef = c.front();//储存根节点

				c.pop();//去除
				if ((bef.s ==(s/2)&& bef.n==(s/2) ) || ((bef.s == (s / 2) && bef.m == (s / 2)))){
					judge = 1; break;
				}
				int left_s = s - bef.s, left_n = n - bef.n, left_m = m - bef.m;
				if (bef.s >= left_n) { next.s = bef.s - left_n; next.n = n; next.m = bef.m; }//添加子节点
				else { next.s = 0; next.n = bef.n + bef.s; next.m = bef.m; }
				if (vis[next.s][next.n][next.m] == 0) {
					next.ans = bef.ans + 1; 
					vis[next.s][next.n][next.m] = 1;
					c.push(next); 
				}//s->n 1

				if (bef.s >= left_m) { next.s = bef.s - left_m; next.m = m; next.n = bef.n; }//添加子节点
				else { next.s = 0; next.m = bef.m + bef.s; next.n = bef.n; }
				if (vis[next.s][next.n][next.m] == 0) {
					next.ans = bef.ans + 1; 
					vis[next.s][next.n][next.m] = 1;
					c.push(next); 
				}//s->m 2
				if (bef.n >= left_m) { next.n = bef.n - left_m; next.m = m; next.s = bef.s; }
				else { next.n = 0; next.m = bef.m + bef.n; next.s = bef.s; }
				if (vis[next.s][next.n][next.m] == 0) {
					next.ans = bef.ans + 1;
					vis[next.s][next.n][next.m] = 1; 
					c.push(next); 
				}//n->m 3
				if (bef.n < left_s) { next.n = 0; next.s = bef.n + bef.s; next.m = bef.m; }
				if (vis[next.s][next.n][next.m] == 0) {
					next.ans = bef.ans + 1; 
					vis[next.s][next.n][next.m] = 1;
					c.push(next);
				}//n->s 4
				if (bef.m >= left_n) { next.n = n; next.m = bef.m - left_n; next.s = bef.s; }
				else { next.m = 0; next.n = bef.m + bef.n; next.s = bef.s; }
				if (vis[next.s][next.n][next.m] == 0) {
					next.ans = bef.ans + 1;
					vis[next.s][next.n][next.m] = 1;
					c.push(next); 
				}//m->n
				if (bef.m < left_s) { next.m = 0; next.s = bef.m + bef.s; next.n = bef.n; }
				if (vis[next.s][next.n][next.m] == 0) {
					next.ans = bef.ans + 1;
					vis[next.s][next.n][next.m] = 1;
					c.push(next);
				}
			}
		}
		if (judge)cout << bef.ans << endl;
		else cout << "NO" << endl;
	}
}

07-20
非常抱歉!你说得对 —— 上面的解法虽然逻辑清晰,但**在某些情况下并不正确**,因为它**没有正确模拟兑换和喝可乐的顺序**,也没有处理兑换之间的**最优路径问题**。 我们来**重新分析这个问题**,并给出一个**真正正确的解法**。 --- ## 🧠 正确解法思路:BFS + 状态压缩 + 剪枝 ### 问题重述: - 初始有 `N` 瓶可乐,0 个空瓶,0 个贴纸。 - 每次操作可以是: - 喝一瓶可乐 → 空瓶数 +1 - 用 `A_i` 个空瓶换 `B_i` 瓶可乐 + 1 贴纸 - 目标是最大化贴纸数。 --- ## ✅ 正确建模方式:BFS / Dijkstra(状态搜索) 我们可以将这个问题建模为一个**状态空间搜索问题**: ### 状态定义: - `state = (empty, cola)`:当前有多少空瓶、有多少可乐 ### 操作定义: - **喝可乐**:`cola > 0` → `empty += 1`, `cola -= 1` - **兑换**:`empty >= A_i` → `empty -= A_i`, `cola += B_i`, `sticker += 1` ### 状态转移: - 每个状态可以转移到喝之后的状态或兑换之后的状态 --- ## 🚀 优化策略 - 使用 **Dijkstra 算法** 或 **优先队列 BFS**,以贴纸数最大化为目标 - 每个状态记录最大贴纸数 - 使用哈希表记录已访问状态的最大贴纸数,剪枝无效状态 --- ## ✅ 正确 C++ 实现(BFS + Dijkstra) ```cpp #include <bits/stdc++.h> using namespace std; using ll = long long; using P = pair<ll, ll>; const ll MAX = 1e6; // 用于剪枝的哈希表大小 int main() { ios::sync_with_stdio(false); cin.tie(0); ll N; int M; cin >> N >> M; vector<pair<ll, ll>> exchanges(M); for (int i = 0; i < M; ++i) { ll A, B; cin >> A >> B; exchanges[i] = {A, B}; } // 状态:(empty, cola) → 最大贴纸数 map<pair<ll, ll>, ll> dp; priority_queue<tuple<ll, ll, ll>> pq; // (stickers, empty, cola) // 初始状态:0 empty, N cola, 0 sticker dp[{0, N}] = 0; pq.emplace(0, 0, N); ll ans = 0; while (!pq.empty()) { auto [sticker, empty, cola] = pq.top(); pq.pop(); // 如果当前状态已经不是最优的,跳过 if (dp.find({empty, cola}) == dp.end() || dp[{empty, cola}] > sticker) { continue; } ans = max(ans, sticker); // 操作1:喝一瓶可乐 if (cola > 0) { ll new_empty = empty + 1; ll new_cola = cola - 1; ll new_sticker = sticker; if (dp.find({new_empty, new_cola}) == dp.end() || dp[{new_empty, new_cola}] < new_sticker) { dp[{new_empty, new_cola}] = new_sticker; pq.emplace(new_sticker, new_empty, new_cola); } } // 操作2:尝试每种兑换 for (auto [A, B] : exchanges) { if (empty >= A) { ll new_empty = empty - A; ll new_cola = cola + B; ll new_sticker = sticker + 1; if (dp.find({new_empty, new_cola}) == dp.end() || dp[{new_empty, new_cola}] < new_sticker) { dp[{new_empty, new_cola}] = new_sticker; pq.emplace(new_sticker, new_empty, new_cola); } } } } cout << ans << '\n'; return 0; } ``` --- ## 📌 代码解释 - 使用 `priority_queue` 模拟 Dijkstra 算法,优先扩展贴纸多的状态 - 每次尝试喝可乐或兑换 - 使用 `map` 记录 `(empty, cola)` → `max sticker`,避免重复搜索 - 最终输出最大贴纸数 --- ## 🧪 示例分析 ### Sample Input 1: ``` 5 3 5 1 4 3 3 1 ``` - 初始状态:(0,5,0) - 最终状态可达:(1,0,3),兑换3次,获得3贴纸 - 输出:`3` --- ## ⚠️ 为什么贪心错误? 贪心策略的问题在于: - 它**不能处理兑换顺序不同带来的状态差异** - 某些兑换方式可能在某个状态下更好,但贪心无法回溯 - 举例:兑换 A 后喝可乐得到的空瓶可以兑换 B,但贪心可能直接选择兑换 B 而错过最优路径 --- ## ✅ 时间复杂度分析 - 每个状态 `(empty, cola)` 最多出现一次 - 每个状态最多有两个转移(喝/兑换) - 最坏情况下状态数约为 `O(N * M)`,但由于剪枝,实际运行很快 --- ## 📚 相关问题
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值