巧克力

巧克力棒(chocolate)
Time Limit:1000ms Memory Limit:64MB
题目描述
LYK 找到了一根巧克力棒,但是这根巧克力棒太长了,LYK 无法一口吞进去。
具体地,这根巧克力棒长为 n,它想将这根巧克力棒折成 n 段长为 1 的巧克力棒,然后
慢慢享用。
它打算每次将一根长为 k 的巧克力棒折成两段长为 a 和 b 的巧克力棒,此时若 a=b,则
LYK 觉得它完成了一件非常困难的事,并会得到 1 点成就感。
LYK 想知道一根长度为 n 的巧克力棒能使它得到最多几点成就感。
输入格式(chocolate.in)
第一行一个数 n。
输出格式(chocolate.out)
一个数表示答案。
输入样例
7
输出样例
4
数据范围
对于 20%的数据 n<=5。
对于 50%的数据 n<=20。
对于 80%的数据 n<=2000。
对于 100%的数据 n<=1000000000。

 

没想到

贪心做法

#include<iostream>
#include<cstdio>
#include<queue>
#include<vector>
#include<cstring>
#include<algorithm>
using namespace std;
long long n,ans;
int main()
{
    freopen("chocolate.in","r",stdin);
    freopen("chocolate.out","w",stdout);
    cin>>n;
    ans=n;
    while(n)
    {
        ans-=n%2;
        n/=2;
    } 
    cout<<ans;
    return 0;
}

还有一个归纳

我们对c(n)进行归纳。

当c(n)=1时,即n=2^k,ans(n)显然=(n-1)。

我们假设c(n)<=x的情况下ans(n)=n-c(n)都成立。

当c(n)=x+1时,我们要证明ans(n)=n-c(n)。

令j为不超过n的2的幂次的最大值,有ans(n)=ans(n-j)+ans(j)=n-j-(c(n)-1)+j-1=n-c(n)。

即ans(n)的下界为n-c(n)。 将ans(n)分成两个数i,j时有c(i)+c(j)>=c(n)。

当i不等于j时,有ans(n)<=i-c(i)+j-c(j)<=n-c(n)。当i=j时,有c(i)+c(j)=2*c(n),ans(n)<=i-c(i)+j-c(j)+1<=n-c(n)*2+1,c(n)是正整数。

综上,ans(n)的上界也为n-c(n)。假设成立。

 

转载于:https://www.cnblogs.com/CLGYPYJ/p/7634981.html

用c++ 巧克力和香草喜欢吃蛋糕。今天,蛋糕店的经理一共给了他们 $$$2^{k+1}$$$ 个蛋糕。蛋糕是平均分配的,所以他们每个人最初都收到了 $$$2^k$$$ 个蛋糕。 但是,朱古力和香草现在想重新分配蛋糕,这样朱古力最后正好得到 $$$x$$$ 个蛋糕,而香草得到剩下的 $$$2^{k+1}-x$$$ 个蛋糕。 在一个步骤中,他们可以执行以下两个操作中的一个: 1. 巧克力把一半的蛋糕分给香草。只有当 Chocola 目前拥有的蛋糕数量为偶数时,才允许进行此操作。 2. Vanilla 把自己的一半蛋糕送给 Chocola。只有当 Vanilla 当前拥有的蛋糕数量为偶数时,才允许执行此操作。 你的任务是确定达到目标分配所需的最小步数,并输出达到最小步数的任何有效操作序列。 可以证明,在给定的约束条件下,总是存在一个有效的解,而且所需的最小步数最多为 $$$120$$$ 。 **输入** 每个测试包含多个测试用例。第一行包含测试用例的数量 $$$t$$$ ( $$$1 \le t \le 1000$$$ )。测试用例说明如下。 每个测试用例的第一行包含两个整数 $$$k$$$ 和 $$$x$$$ ( $$$1 \le k \le 60$$$ , $$$1 \le x \le 2^{k+1}-1$$$ )--每个人最初收到的蛋糕数为 $$$2^k$$$ , $$$x$$$ 是重新分配后 Chocola 应该拥有的蛋糕数。 **输出** 对于每个测试用例,输出一个整数 $$$n$$$ ( $$$0\le n\le 120$$$ ) 代表它们相应重新分配蛋糕所需的最少步骤数。 在下一行中,输出 $$$n$$$ 个整数 $$$o _ 1, o _ 2, \ldots, o _ n$$$ ( $$$o _ i = \mathtt{1}$$$ 或 $$$o _ i = \mathtt{2}$$$ ),其中 $$$o _ i = \mathtt{1}$$$ 表示在 $$$i$$$ \-th 步骤中,巧克力把一半的蛋糕分给了香草(操作 1),而 $$$o _ i = \mathtt{2}$$$ 表示香草把一半的蛋糕分给了巧克力(操作 2)。
最新发布
09-10
我们的问题是,初始时巧克力和香草各自拥有 $2^k$ 个蛋糕,总共有 $2^{k+1}$ 个蛋糕。我们要通过若干次操作(操作 1 或操作 2)使得巧克力最终拥有 $x$ 个蛋糕,香草拥有 $2^{k+1} - x$ 个蛋糕。 --- ### 解题思路 我们可以将这个问题建模为一个**状态转移问题**,其中每一步操作都会改变巧克力和香草手中的蛋糕数量。目标是找到从初始状态 `(2^k, 2^k)` 到目标状态 `(x, 2^{k+1} - x)` 的**最短路径**。 由于蛋糕总数是固定的(即 $2^{k+1}$),我们只需要跟踪巧克力拥有的蛋糕数量即可(香草的蛋糕数就是总量减去巧克力的)。 --- ### 观察与优化 - 操作 1:巧克力把一半蛋糕给香草。前提:巧克力的蛋糕数为偶数。 - 操作 2:香草把一半蛋糕给巧克力。前提:香草的蛋糕数为偶数。 我们从目标状态反向推导到初始状态,这样更容易剪枝和避免重复搜索。 --- ### 算法选择:广度优先搜索 (BFS) - 状态表示:巧克力当前拥有的蛋糕数。 - 起始状态:`x` - 目标状态:`2^k` - 每一步操作可以反向执行: - 如果当前蛋糕数是偶数,可以通过操作 1 到达 `current * 2` - 如果当前蛋糕数是奇数,不能反向操作 1 - 如果 `(total - current)` 是偶数,可以通过操作 2 到达 `current - (total - current) / 2` --- ### C++ 实现 ```cpp #include <bits/stdc++.h> using namespace std; // 总蛋糕数 long long total; // 反向BFS vector<int> bfs(long long start, long long target, long long k) { long long initial = (1LL << k); // 初始每人蛋糕数 total = 2LL * initial; map<long long, pair<long long, int>> parent; queue<long long> q; q.push(start); parent[start] = { -1, -1 }; while (!q.empty()) { long long cur = q.front(); q.pop(); if (cur == target) break; long long vanilla = total - cur; // 反向操作1:cur = next * 2 (说明上一步是操作1) if (cur % 2 == 0) { long long next = cur / 2; if (parent.find(next) == parent.end()) { parent[next] = {cur, 1}; q.push(next); } } // 反向操作2:cur = next + half_vanilla if (vanilla % 2 == 0) { long long half_vanilla = vanilla / 2; long long next = cur + half_vanilla; if (parent.find(next) == parent.end()) { parent[next] = {cur, 2}; q.push(next); } } } // 构造路径 vector<int> path; long long cur = target; while (cur != start) { auto [p, op] = parent[cur]; if (op == -1) break; path.push_back(op); cur = p; } reverse(path.begin(), path.end()); return path; } int main() { int t; cin >> t; while (t--) { long long k, x; cin >> k >> x; long long initial = (1LL << k); total = 2LL * initial; long long target = initial; long long start = x; vector<int> path = bfs(start, target, k); cout << path.size() << endl; if (!path.empty()) { for (int op : path) cout << op << " "; cout << endl; } else { cout << endl; } } } ``` --- ### 代码解释 1. **bfs 函数**: - 使用广度优先搜索从目标状态反向搜索到初始状态。 - 每个状态只记录巧克力拥有的蛋糕数。 - 用 `map<long long, pair<long long, int>>` 记录每个状态的前驱状态和操作类型。 2. **主函数 main**: - 读取多个测试用例。 - 对每个测试用例调用 `bfs` 找到最短路径并输出。 3. **反向操作**: - 操作1的反向是巧克力把蛋糕翻倍。 - 操作2的反向是香草把蛋糕翻倍。 --- ### 复杂度分析 - 每个状态是巧克力拥有的蛋糕数(最多不超过 $2^{k+1}$)。 - 每个状态最多两个转移方向。 - 最多 120 步,所以 BFS 是高效的。 --- ### 相关问题
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值