题目
bala
稳稳地超时了O_O…Time limit,Time limit exceed 。
在uDebug上找了组数据，嗯确认过眼神，算法效率太低，但是没出错哈哈，还是挺欣慰的~
（其实，就运行了173.2 s 的…哪里效率低了，比我手算快多了）//手动狗头//
果然还是得ctrl+v一个狗头，才有那味儿
Time limit
//对于整个问题，一头雾水
// 方向________________>>>>>>>>>
//那就先弄懂小规模问题： a / b 分解 成三个埃及分数。列出所有情况。
//2020/4/18
//9:00 - 21:30
//@reasonbao
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
#include <cstdio>
using namespace std;
typedef long long int ll;
ll ans[100];
ll ans_best[100];
bool g_is_ok = false;
int g_restrict[10];
int g_k = 0;
//比较 y1 / x1 与 y2 / x2 的大小
int CompareFraction(ll y1, ll x1, ll y2, ll x2) {
ll fraction_front = y1 * x2, fraction_next = y2 * x1; //通分交叉相乘，乘积可能非常大
if (fraction_front == fraction_next) return 0;
else if (fraction_front > fraction_next) return 1;
else return 2;
}
估价函数
//bool Assess(ll fenzi, ll fenmu, ll layer, ll biggest) {
// if (CompareFraction(fenzi, fenmu, layer, biggest) == 2)
// return true; //"假想最大值",至少应该要比剩余的分数大或等于
// if (CompareFraction(fenzi, fenmu, layer, biggest) == 0 && layer == 1)
// return true;
// return false; //若剩余层数 * 最大埃及分数 < 剩余的分数，" 剪枝 "
//}
//最大公约数，用于约分
ll Gcd(ll a, ll b) {
if (b == 0) return a;
else return Gcd(b, a % b);
}
//约分
void Reduce(ll &fenzi, ll &fenmu) {
if (fenzi == 0) {
fenzi = 0;
fenmu = 1;
}
else {
ll gcd = Gcd(fenzi, fenmu);
fenzi /= gcd;
fenmu /= gcd;
}
}
void Add(ll &y1, ll &x1, ll y2, ll x2) {
ll fraction_front = y1 * x2, fraction_next = y2 * x1; //通分交叉相乘，乘积可能非常大
x1 = x1 * x2;
y1 = fraction_front + fraction_next;
Reduce(y1, x1);
}
//估价函数 2.0
bool Assess(ll fenzi, ll fenmu, ll layer, ll biggest) {
if (CompareFraction(fenzi, fenmu, layer, biggest) == 0 && layer == 1)
return true;
long long int max_fenzi = 0, max_fenmu = 1;
ll from = biggest;
for (int i = 0; i < layer; i++) {
Add(max_fenzi, max_fenmu, 1, from ++ );
}
// cout << max_fenzi << " " << max_fenmu;
if (CompareFraction(fenzi, fenmu, max_fenzi, max_fenmu) == 2 || CompareFraction(fenzi, fenmu, max_fenzi, max_fenmu) == 0)
return true; //"最大值",至少应该要比剩余的分数大或等于
return false; //若剩余层数实际最大埃及分数之和 < 剩余的分数，" 剪枝 "，没必要继续深度或者广度
}
void Sub(ll &y1, ll &x1, ll y2, ll x2) {
ll fraction_front = y1 * x2, fraction_next = y2 * x1; //通分交叉相乘，乘积可能非常大
x1 = x1 * x2;
y1 = fraction_front - fraction_next;
Reduce(y1, x1);
}
//比较相同深度情况下的更优解
void Better(ll pos) {
if ( !ans_best[pos] || ans[pos] <= ans_best[pos]) {
for (int i = 0; i <= pos; i ++ )
ans_best[i] = ans[i];
}
}
void Dfs(ll remain_fenzi, ll remain_fenmu, ll from, ll cur, ll maxd) {
if (cur == maxd ) {
// cout << " cur = " << cur << endl;
if ( ! remain_fenzi) {
// cout << "数组情况：————";
// for (int m = 0; m < maxd; m ++ ) cout << ans[m] << " "; cout << endl << endl;
Better(maxd - 1);
g_is_ok = true;
}
return;
}
for (ll i = from; ; i ++ ) { //向第cur层填入埃及分数,。 注：from初始化为1，即 1 / 1
if (! Assess(remain_fenzi, remain_fenmu, maxd - cur, i)) return; //不可能事件，返回上一层 (上一层尝试其他数),不知道这算不算 ""剪枝""
while (CompareFraction(remain_fenzi, remain_fenmu, 1, i) == 2) { //等于2 表示 1/i > 剩下的分数
i ++ ; //直到找到该层可填的数 (条件：1 / i 比剩余分数 小 或者 等)
// cout << "i = " << i << endl;
// cout << "cur = " << cur << endl;
}
//判断是否在限制数组中 ,是则使用下一个 i
bool is_restrict = false;
for (int mmm = 0; mmm < g_k; mmm++) {
if (g_restrict[mmm] == i) {
is_restrict = true;
break;
}
}
if (is_restrict) continue;
//判断是佛剩余层数还不是1，直接给减没了
if (CompareFraction(remain_fenzi, remain_fenmu, 1, i) == 0 && maxd - cur != 1 ) continue;
ans[cur] = i;
// cout << "减之前："; cout << remain_fenzi << "/" << remain_fenmu << " - " << 1 << "/" << i << endl;
ll remain_fenzi_tmp = remain_fenzi;
ll remain_fenmu_tmp = remain_fenmu;
Sub(remain_fenzi_tmp, remain_fenmu_tmp, 1, i);
// cout << "减之后："; cout << remain_fenzi_tmp << "/" << remain_fenmu_tmp << endl;
Dfs(remain_fenzi_tmp, remain_fenmu_tmp, i + 1, cur + 1, maxd);
}
}
void OutputResult(ll a, ll b, ll maxd) {
// printf("%lld/%lld=", a, b);
cout << a << "/" << b << "=";
for (int i = 0; i < maxd; i ++ ) {
if (i >= 1) cout << "+";
cout << 1 << "/" << ans_best[i];
// printf("%lld/%lld", 1, ans_best[i]);
}
cout << endl;
}
int main() {
// Assess(3,4,3,4);
// freopen("in11.txt", "r", stdin); //在stdio里
// freopen("out11.txt", "w", stdout);
ll a,b;
int kase = 1;
int num;
cin >> num;
while (num -- ) {
// while (cin >> a >> b >> g_k) {
cin >> a >> b >> g_k;
memset(g_restrict, 0, sizeof(g_restrict));
for (int i = 0; i < g_k; i++) {
cin >> g_restrict[i];
}
printf("Case %d: ", kase ++ );
for (ll maxd = 1; ; maxd ++ ) { //对DFS的深度进行枚举，也就是限制深度（实现题目中：加数少的情况比多的好）
memset(ans, 0, sizeof(ans));
memset(ans_best, 0, sizeof(ans_best));
Dfs(a, b, 1, 0, maxd);
if (g_is_ok) {
OutputResult(a, b, maxd);
break;
}
}
g_is_ok = false; //记得重置
}
return 0;
}
4-23调试
今天折腾半天，看了其他博主的思路，突然发现我的算法有一个地方可以优化！！！
如下图： 深度maxd固定的前提下，最后一位数如此之大，那试问，最后一位是否有枚举的必要？？？
没必要呀，直接就是余数了呀，而我最后一位也进行枚举，所以工作量大了太多了！！！
优化思路：只用枚举填入maxd - 1层就好，最后一层用余下的分数来判断是否满足 1 / M 的形式即可。
优化后对uDebug上的100个数据进行测试，如下图：
泪目！！！不用再算170秒了！！！
然后，再去UVa提交一下，Wrong Answer。。。没事，问题不大，继续尝试，no big deal~
Wrong Answer
//运行时间很久的数据
//1 50 103 0
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
#include <cstdio>
using namespace std;
typedef long long int ll;
ll ans[100];
ll ans_best[100];
bool g_is_ok = false;
int g_restrict[10];
int g_k = 0;
//比较 y1 / x1 与 y2 / x2 的大小
int CompareFraction(ll y1, ll x1, ll y2, ll x2) {
ll fraction_front = y1 * x2, fraction_next = y2 * x1; //通分交叉相乘，乘积可能非常大
if (fraction_front == fraction_next) return 0;
else if (fraction_front > fraction_next) return 1;
else return 2;
}
//最大公约数，用于约分
ll Gcd(ll a, ll b) {
if (b == 0) return a;
else return Gcd(b, a % b);
}
//约分
void Reduce(ll &fenzi, ll &fenmu) {
if (fenzi == 0) {
fenzi = 0;
fenmu = 1;
}
else {
ll gcd = Gcd(fenzi, fenmu);
fenzi /= gcd;
fenmu /= gcd;
}
}
void Add(ll &y1, ll &x1, ll y2, ll x2) {
ll fraction_front = y1 * x2, fraction_next = y2 * x1; //通分交叉相乘，乘积可能非常大
x1 = x1 * x2;
y1 = fraction_front + fraction_next;
Reduce(y1, x1);
}
//估价函数 2.0
bool Assess(ll fenzi, ll fenmu, ll layer, ll biggest) {
if (CompareFraction(fenzi, fenmu, layer, biggest) == 0 && layer == 1)
return true;
long long int max_fenzi = 0, max_fenmu = 1;
ll from = biggest;
for (int i = 0; i < layer; i++) {
Add(max_fenzi, max_fenmu, 1, from ++ );
}
// cout << max_fenzi << " " << max_fenmu;
if (CompareFraction(fenzi, fenmu, max_fenzi, max_fenmu) == 2 || CompareFraction(fenzi, fenmu, max_fenzi, max_fenmu) == 0)
return true; //"最大值",至少应该要比剩余的分数大或等于
return false; //若剩余层数实际最大埃及分数之和 < 剩余的分数，这时候要剪枝了 ，没必要继续深度或者广度
}
void Sub(ll &y1, ll &x1, ll y2, ll x2) {
ll fraction_front = y1 * x2, fraction_next = y2 * x1; //通分交叉相乘，乘积可能非常大
x1 = x1 * x2;
y1 = fraction_front - fraction_next;
Reduce(y1, x1);
}
//比较相同深度情况下的更优解
void Better(ll pos) {
if ( ans_best[0] == 0 || ans[pos] <= ans_best[pos]) { //答案未填过 或者 碰到更优解
for (int i = 0; i <= pos; i ++ )
ans_best[i] = ans[i];
}
}
void Dfs(ll remain_fenzi, ll remain_fenmu, ll from, ll cur, ll maxd) {
// if (cur == maxd ) /*运行极度慢，问题出现在这里！！！！！！！！！！！！！2020/4/23*/
if (cur + 1 == maxd ) {
if (remain_fenzi == 1 && remain_fenmu >= from) { //满足条件，继续进一步判断
ll last = remain_fenmu;
bool is_restrict = false;
for (int mm = 0; mm < g_k; mm++) {
if (g_restrict[mm] == last) {
is_restrict = true;
break;
}
}
if (is_restrict) return; //最后一层剩下的余数是限制的数，回溯，上一层继续往下枚举
ans[cur] = last; //不是限制的数，属于备选答案
// cout << "#####备选答案数组情况###：————";
// for (int m = 0; m < maxd; m ++ ) cout << ans[m] << " "; cout << endl << endl;
Better(maxd - 1);
g_is_ok = true;
return;
}
else return; //最后一个分子分母不满足条件，回溯
}
for (ll i = from; ; i ++ ) { //向第cur层填入埃及分数,。 注：from初始化为1，即 1 / 1
if (! Assess(remain_fenzi, remain_fenmu, maxd - cur, i)) return; //不可能事件，返回上一层 (上一层尝试其他数), 剪枝
while (CompareFraction(remain_fenzi, remain_fenmu, 1, i) == 2) { //等于2 表示 1/i > 剩下的分数
i ++ ; //直到找到该层可填的数 (条件：1 / i 比剩余分数 小） eg.深度maxd = 4， 填3层的数就好，最后一层用余数直接判断！！！！！
}
//判断是否在限制数组中 ,是则使用下一个 i
bool is_restrict = false;
for (int mmm = 0; mmm < g_k; mmm++) {
if (g_restrict[mmm] == i) {
is_restrict = true;
break;
}
}
if (is_restrict) continue;
ans[cur] = i;
// cout << "减之前："; cout << remain_fenzi << "/" << remain_fenmu << " - " << 1 << "/" << i << endl;
ll remain_fenzi_tmp = remain_fenzi;
ll remain_fenmu_tmp = remain_fenmu;
Sub(remain_fenzi_tmp, remain_fenmu_tmp, 1, i);
// cout << "减之后："; cout << remain_fenzi_tmp << "/" << remain_fenmu_tmp << endl;
Dfs(remain_fenzi_tmp, remain_fenmu_tmp, i + 1, cur + 1, maxd);
}
}
void OutputResult(ll a, ll b, ll maxd) {
// printf("%lld/%lld=", a, b);
// cout << a << "/" << b << "=";
for (int i = 0; i < maxd; i ++ ) {
// if (i >= 1) cout << "+";
// cout << 1 << "/" << ans_best[i];
if (i >= 1) printf("+");
printf("1/%lld", ans_best[i]);
}
cout << endl;
}
int main() {
// freopen("in11.txt", "r", stdin); //在stdio里
// freopen("out11.txt", "w", stdout);
ll a,b;
int kase = 1;
int num;
cin >> num;
while (num -- ) {
cin >> a >> b >> g_k;
ll a_reduce = a, b_reduce = b; //这步很重要！原因是最后一层是通过计算分数的余数，而非枚举。 eg.2 / 4 ,一层就可解决，前提是要约分
Reduce(a_reduce, b_reduce);
memset(g_restrict, 0, sizeof(g_restrict));
for (int i = 0; i < g_k; i++) {
cin >> g_restrict[i];
}
printf("Case %d: ", kase ++ );
for (ll maxd = 1; ; maxd ++ ) { //对DFS的深度进行枚举，也就是限制深度（实现题目中：加数少的情况比多的好）
memset(ans, 0, sizeof(ans));
memset(ans_best, 0, sizeof(ans_best));
Dfs(a_reduce, b_reduce, 1, 0, maxd);
if (g_is_ok) {
printf("%lld/%lld=", a, b);
OutputResult(a, b, maxd);
break;
}
}
g_is_ok = false; //记得重置
}
return 0;
}
4-24调试，AC啦
早上起来，想了一下，我审题有问题O_O
重新审题了一遍，发现我的更新更优解函数Better（）有问题，只比较了最大分母，但题目要求是“项的数量应最小化，然后大分母应最小化。如果有几种解决方案，应将第二大分母减到最小，等等。” 实际上我只最小化了最大分母，没有最小化第二大、第三大…
果然！！！要科学调试！！！长点记性哟~
太感动了，我的憨憨代码，虽然效率不高，但最终是AC了，附上提交记录：
AC代码
//2020/4/24
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
#include <cstdio>
using namespace std;
typedef long long int ll;
ll ans[1000];
ll ans_best[1000];
bool g_is_ok = false;
int g_restrict[10];
int g_k = 0;
//比较 y1 / x1 与 y2 / x2 的大小
int CompareFraction(ll y1, ll x1, ll y2, ll x2) {
ll fraction_front = y1 * x2, fraction_next = y2 * x1; //通分交叉相乘，乘积可能非常大
if (fraction_front == fraction_next) return 0;
else if (fraction_front > fraction_next) return 1;
else return 2;
}
//最大公约数，用于约分
ll Gcd(ll a, ll b) {
if (b == 0) return a;
else return Gcd(b, a % b);
}
//约分
void Reduce(ll &fenzi, ll &fenmu) {
if (fenzi == 0) {
fenzi = 0;
fenmu = 1;
}
else {
ll gcd = Gcd(fenzi, fenmu);
fenzi /= gcd;
fenmu /= gcd;
}
}
void Add(ll &y1, ll &x1, ll y2, ll x2) {
ll fraction_front = y1 * x2, fraction_next = y2 * x1; //通分交叉相乘，乘积可能非常大
x1 = x1 * x2;
y1 = fraction_front + fraction_next;
Reduce(y1, x1);
}
//估价函数 2.0
bool Assess(ll fenzi, ll fenmu, ll layer, ll biggest) {
if (CompareFraction(fenzi, fenmu, layer, biggest) == 0 && layer == 1)
return true;
long long int max_fenzi = 0, max_fenmu = 1;
ll from = biggest;
for (int i = 0; i < layer; i++) {
Add(max_fenzi, max_fenmu, 1, from ++ );
}
// cout << max_fenzi << " " << max_fenmu;
if (CompareFraction(fenzi, fenmu, max_fenzi, max_fenmu) == 2 || CompareFraction(fenzi, fenmu, max_fenzi, max_fenmu) == 0)
return true; //"最大值",至少应该要比剩余的分数大或等于
return false; //若剩余层数实际最大埃及分数之和 < 剩余的分数，这时候要剪枝了 ，没必要继续深度或者广度
}
void Sub(ll &y1, ll &x1, ll y2, ll x2) {
ll fraction_front = y1 * x2, fraction_next = y2 * x1; //通分交叉相乘，乘积可能非常大
x1 = x1 * x2;
y1 = fraction_front - fraction_next;
Reduce(y1, x1);
}
//比较相同深度情况下的更优解
void Better(ll pos) {
if ( ans_best[0] == 0) { //答案未填过 或者 碰到更优解
for (int i = 0; i <= pos; i ++ )
ans_best[i] = ans[i];
}
else { //判断是否为更优解
int m;
for ( m = pos; m >= 0; m -- ) { //由于要最小化最大、第二大...的数，尾巴最大，故从尾巴开始比较
if (ans[m] != ans_best[m]) break;
}
if (ans[m] < ans_best[m]) {
for (int i = 0; i <= pos; i ++ ) //更新解
ans_best[i] = ans[i];
}
}
}
void Dfs(ll remain_fenzi, ll remain_fenmu, ll from, ll cur, ll maxd) {
// if (cur == maxd ) /*运行极度慢，问题出现在这里！！！！！！！！！！！！！2020/4/23*/
if (cur + 1 == maxd ) {
if (remain_fenzi == 1 && remain_fenmu >= from) { //满足条件，继续进一步判断
ll last = remain_fenmu;
bool is_restrict = false;
for (int mm = 0; mm < g_k; mm++) {
if (g_restrict[mm] == last) {
is_restrict = true;
break;
}
}
if (is_restrict) return; //最后一层剩下的余数是限制的数，回溯，上一层继续往下枚举
ans[cur] = last; //不是限制的数，属于备选答案
// cout << "#####备选答案数组情况###：————";
// for (int m = 0; m < maxd; m ++ ) cout << ans[m] << " "; cout << endl << endl;
Better(maxd - 1);
g_is_ok = true;
return;
}
else return; //最后一个分子分母不满足条件，回溯
}
for (ll i = from; ; i ++ ) { //向第cur层填入埃及分数,。 注：from初始化为1，即 1 / 1
if (! Assess(remain_fenzi, remain_fenmu, maxd - cur, i)) return; //不可能事件，返回上一层 (上一层尝试其他数), 剪枝
while (CompareFraction(remain_fenzi, remain_fenmu, 1, i) == 2) { //等于2 表示 1/i > 剩下的分数
i ++ ; //直到找到该层可填的数 (条件：1 / i 比剩余分数 小） eg.深度maxd = 4， 填3层的数就好，最后一层用余数直接判断！！！！！
}
//判断是否在限制数组中 ,是则使用下一个 i
bool is_restrict = false;
for (int mmm = 0; mmm < g_k; mmm++) {
if (g_restrict[mmm] == i) {
is_restrict = true;
break;
}
}
if (is_restrict) continue;
ans[cur] = i;
// cout << "减之前："; cout << remain_fenzi << "/" << remain_fenmu << " - " << 1 << "/" << i << endl;
ll remain_fenzi_tmp = remain_fenzi;
ll remain_fenmu_tmp = remain_fenmu;
Sub(remain_fenzi_tmp, remain_fenmu_tmp, 1, i);
// cout << "减之后："; cout << remain_fenzi_tmp << "/" << remain_fenmu_tmp << endl;
Dfs(remain_fenzi_tmp, remain_fenmu_tmp, i + 1, cur + 1, maxd);
}
}
void OutputResult(ll a, ll b, ll maxd) {
for (int i = 0; i < maxd; i ++ ) {
if (i >= 1) printf("+");
printf("1/%lld", ans_best[i]);
}
cout << endl;
}
int main() {
// freopen("in11.txt", "r", stdin); //头文件stdio
// freopen("out11.txt", "w", stdout);
ll a,b;
int kase = 1;
int num;
cin >> num;
while (num -- ) {
cin >> a >> b >> g_k;
ll a_reduce = a, b_reduce = b; //这步很重要！原因是最后一层是通过计算分数的余数，而非枚举。 eg.2 / 4 ,一层就可解决，前提是要约分
Reduce(a_reduce, b_reduce); //后面又意识到，其实Iuput里面提了，b > a 且 gcd(a,b) = 1，这步其实没必要。
memset(g_restrict, 0, sizeof(g_restrict));
for (int i = 0; i < g_k; i++) {
cin >> g_restrict[i];
}
printf("Case %d: ", kase ++ );
for (ll maxd = 1; ; maxd ++ ) { //对DFS的深度进行枚举，也就是限制深度（实现题目中：加数少的情况比多的好）
memset(ans, 0, sizeof(ans));
memset(ans_best, 0, sizeof(ans_best));
Dfs(a_reduce, b_reduce, 1, 0, maxd);
if (g_is_ok) {
printf("%lld/%lld=", a, b);
OutputResult(a, b, maxd);
break;
}
}
g_is_ok = false; //记得重置
}
return 0;
}
扫一扫
483
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
