埃及数字(迭代深搜)

题目描述 Description

在古埃及,人们使用单位分数的和(形如1/a的, a是自然数)表示一切有理数。 如:2/3=1/2+1/6,但不允许2/3=1/3+1/3,因为加数中有相同的。 对于一个分数a/b,表示方法有很多种,但是哪种最好呢? 首先,加数少的比加数多的好,其次,加数个数相同的,最小的分数越大越 好。 如: 19/45=1/3 + 1/12 + 1/180 19/45=1/3 + 1/15 + 1/45 19/45=1/3 + 1/18 + 1/30, 19/45=1/4 + 1/6 + 1/180 19/45=1/5 + 1/6 + 1/18. 最好的是最后一种,因为1/18比1/180,1/45,1/30,1/180都大。 给出a,b(0<a<b<1000),编程计算最好的表达方式。

输入描述 Input Description

a b

输出描述 Output Description

若干个数,自小到大排列,依次是单位分数的分母。

样例输入 Sample Input

19 45

样例输出 Sample Output

5 6 18

一个迭代加深模版题,然而我默默地打了一个晚上。。

主要注意剪枝和数据要开longlong,因为没开longlong在codves上最后一个点爆了

#include<bits/stdc++.h>
#define ll long long
using namespace std;

ll a,b,maxd,ans[1010],tmp[1010];

ll gcd(ll x,ll y){
    return y?gcd(y,x%y):x;
}

bool dfs(ll a,ll b,ll step){
    if(step==maxd){
      if(a==1){
          if(b>tmp[step-1]){
              tmp[step]=b;
            if(tmp[step]<ans[step]){
                for(int i=1;i<=step;i++) ans[i]=tmp[i];
            }
          }
          return 1;
      }
      else return 0;
    }
    if(a/(b*(maxd-step+1))>ans[maxd]) return 0;
    bool ok=0;
    for(int i=max(tmp[step-1]+1,b/a);i<=b*(maxd-step+1)/a;i++){
        if(b>a*i) continue;
        tmp[step]=i;
        ll c=gcd(a*i-b,b*i);
        if(dfs((a*i-b)/c,(b*i)/c,step+1)) ok=1;
    }
    if(!ok)return 0;return 1;
}

int main(){
    scanf("%lld%lld",&a,&b);
    ll c=gcd(a,b);
    a/=c;b/=c;
    if(a==1){
        printf("%lld",b);
        return 0;
    }
    for(int i=1;i<=1000;i++) ans[i]=10000000;
    for(maxd=2;;maxd++){
        memset(tmp,0,sizeof(tmp));tmp[0]=1;
        if(dfs(a,b,1)){
            for(int i=1;i<=maxd;i++) printf("%d ",ans[i]);return 0;
        }
    }
}

原文地址:https://www.cnblogs.com/plysc/p/10321420.html

时间: 2024-10-28 14:47:53

埃及数字(迭代深搜)的相关文章

UVA1374 - Power Calculus(迭代深搜+剪枝)

题目链接 题意:给出x和正整数n,问最少需要几次乘除法 可以得到n = x^m 思路:其实是关于指数的操作,即从1到m最少的步数.我们可以先确定最少步数m,然后进行迭代,迭代的过程也就是判断通过相加减所得到的数可以在m次操作中等于n,如果符合,m即为最小步数,如果不符合,m++,进行下一次迭代.迭代过程中要注意剪枝,即剩余的次数如果每次都是取最大值相加还是比n小的话,就直接跳出. 代码: #include <iostream> #include <cstdio> #include

bzoj 1085骑士精神 迭代深搜

题目传送门 题目大意:给出一幅棋盘,问能否复原,中文题面,不做解释. 思路:第一次写迭代深搜的题目,这道题还是挺经典的.这道题的状态很明显的每多搜一层就是多八倍,非常的多,而且又是t组输入,所以必定有很多点是在深层次的,所以用迭代深搜,这就是很多组数据在很浅的层就得到了答案,不需要多做了,而有一些样例则是确实会重复计算(答案层次比较深的时候),但是此时浪费的时间和之前节约的时间已经不是一个数量级的了,故用迭代深搜,这也是迭代深搜的标志性功能. 但是光迭代深搜没有用,还需要一个估价函数来剪枝,这里

迭代深搜

迭代深搜简单来说就是限制深度的深搜,这样就可以避免像广搜一样占用大量空间,又可以像广搜找到最佳的路径. 两道例题 1.埃及分数 #include<cstdio> #include<set> #include<cstring> using namespace std; const int N = 10; typedef long long LL; set<LL>s; LL now[N], pre[N]; bool flag; LL gcd(LL a, LL b

POJ 1129-Channel Allocation(四色定理+迭代深搜)

题目链接:传送门 题意:n个信号站,给出连接情况,要用信号覆盖所有信号站,要求相连的信号站不能用同一个信号. 等价问题==无向图染色==四色定理(每个平面地图都可以只用四种颜色来染色,而且没有两个邻接的区域颜色相同.已证明) 思路:深搜一条路(枚举颜色,判断当前点用已有的颜色能不能染,如不能则加一种颜色,判断强判就行了),搜到头答案就出来了..然后返回就可以了 注意单复数.. #include <algorithm> #include <iostream> #include <

UVA - 1374 Power Calculus 迭代深搜

题目大意:问从1变到n至少需要多少步.变换规则如下 1.变化过程中的中间结果可以任意使用 2.每次只能挑选两个数进行加减 解题思路:先算一下至少需要多少步,然后在如果在当前步数下无法到达结果的话,就当前步数加1,继续搜索下去 #include<cstdio> #include<cstring> #include<algorithm> using namespace std; #define maxn 1010 int num[maxn], cnt, n ,MIN_dep

poj 3134 Power Calculus iddfs(迭代深搜)

iddfs入门题. //poj 3134 //sep9 #include <iostream> using namespace std; int n,deep; int a[30]; bool iddfs(int pos) { int t; if(pos>deep) return false; if(a[pos]<<(deep-pos)<n) return false; if(a[pos]==n) return true; for(int i=1;i<=pos;+

埃及分数(迭代深搜)

#include<bits/stdc++.h> using namespace std; long long ch,mo; int dep; long long ans[1000],s[1000]; int gcd(long long a,long long b) { return b==0?a:gcd(b,a%b); } void outp() { if(ans[dep]>s[dep]) { for(int i=1;i<=dep;i++) ans[i]=s[i]; } } voi

算法学习笔记 二叉树和图遍历—深搜 DFS 与广搜 BFS

图的深搜与广搜 马上又要秋招了,赶紧复习下基础知识.这里复习下二叉树.图的深搜与广搜.从图的遍历说起,图的遍历方法有两种:深度优先遍历(Depth First Search), 广度优先遍历(Breadth First Search),其经典应用走迷宫.N皇后.二叉树遍历等.遍历即按某种顺序访问"图"中所有的节点,顺序分为: 深度优先(优先往深处走),用的数据结构是栈, 主要是递归实现: 广度优先(优先走最近的),用的数据结构是队列,主要是迭代实现: 对于深搜,由于递归往往可以方便的利

算法学习笔记(六) 二叉树和图遍历—深搜 DFS 与广搜 BFS

图的深搜与广搜 复习下二叉树.图的深搜与广搜. 从图的遍历说起.图的遍历方法有两种:深度优先遍历(Depth First Search), 广度优先遍历(Breadth First Search),其经典应用走迷宫.N皇后.二叉树遍历等.遍历即按某种顺序訪问"图"中全部的节点,顺序分为: 深度优先(优先往深处走),用的数据结构是栈, 主要是递归实现. 广度优先(优先走近期的).用的数据结构是队列.主要是迭代实现. 对于深搜.因为递归往往能够方便的利用系统栈,不须要自己维护栈.所以通常实