埃及分数

description

         对于每一个非负有理数，我们知道它一定能划归成某些特殊真分数之和，特殊真分数要满足它们的分子为1，但是我们知道，对于无穷级数1/2+1/3+1/4…。虽然，它是发散的，但是改级数增长得极为缓慢，例如到了数百万之后，和也在18~19左右。

         若干年来，不断有人宣称发现了该级数的特殊性质，这些都对这个问题的研究起到了深远的影响。

         你的任务来了，要求给你个真分数，你需要将其化简为最少的若干特殊真分数之和，你要输出这个序列（序列按递增序）。

         如果有不同的方案，则分数个数相同的情况下使最大的分母最小。若还相同，则使次大的分母最大……以此类推。

         如：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

最好的是最后一种，因为18 比180, 45, 30,都小。

 

 

对于此类搜索问题，搜索深度没有明显的上界，而且加数的选择在理论上也是无限的，也就是说宽度搜索连一层都扩展不完。

利用迭代加深搜索（IDA*）可以解决上面的问题。一方面我们要解决，利用DFS从小到大枚举深度上限maxd，虽然理论上深度是无限的，但是只要保证有解，深度值必然在有限的时间内能枚举到。

另一方面，我们还要解决每次枚举的值无限的问题，可以借助maxd来“剪枝”，以此题为例，每一次枚举的的分母个数必然有一个结束值，否则就会出现无限下去的尴尬了。那么当扩展到第i层时，第i层分数值为1/e，那么接下来由于分母是以递增顺序进行的，那么分数值都不会大于1/e，如果c/d（前i个分数之和）+1/e*（maxd-i）<a/b，可以直接break;因为起码深度不够，要再加深度。

基本框架：

 

for（maxd=1；；maxd++）
{
      if(dfs(0,,,))
     {
         ok=1;
         break;
      }  
}

code:

 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define MAXN 20000
//一定要用64位的整数，由于里面存在化归为同分母的操作，需要相乘
using namespace std;
int64_t maxd;
int64_t v[MAXN],ans[MAXN];//v是暂时存放的满足题意的分母的数组，ans是记录满足题意的最优分母值的数组。
int64_t gcd(int64_t a,int64_t b)//求最大公约数
{
    int64_t m;
    while(a!=0)
    {
       m=b%a;
       b=a;
       a=m;
    }
    return b;
}
int64_t getfirst(int64_t a,int64_t b)//取比a/b小的最大分数，分子必须为1
{
    int64_t i,j;
    for(i=2;;i++)
    {
        if(b<a*i)
        {
                break;
        }
    }
    return i;
}
bool better(int64_t d)//必要的判断，这组分数之和是否满足最优解
{
    int64_t i;
    bool flag=true;
    if(ans[d]==-1)//由于初始化ans是-1，如果是第一次出现的满足题意的解，返回true
        return true;
    for(i=d;i>=0;i--)
    {
        if(v[i]==ans[i])//从高位进行判断大小，题意要求
            continue;
        else if(v[i]>ans[i])
        {
               //return false;
               flag=false;
               break;
        }
        else
        {
                break;
        }
    }
    if(flag==true)
        return true;
    else
        return false;
}
bool dfs(int64_t a,int64_t b,int64_t from,int64_t d)//深度为d
{
    int64_t aa,bb,g,i;
    bool ok;
   // cout<<from<<endl;
    if(d==maxd)
    {
        if(a!=1)
            return false;
        for(i=0;i<=d-1;i++)
        {
            if(v[i]==b)
            {
                return false;
            }

        }
        v[d]=b;
        sort(v,v+d);
        if(better(d))
            memcpy(ans,v,sizeof(int64_t)*(d+1));
        return true;
    }
    ok=false;
    //重要！！！
    from=max(from,getfirst(a,b));//枚举起点，去上一次加一的分母值和比a/b小的最大分数的分母中更大的。
    for(i=from;;i++)
    {
        //剪枝，如果c/d（前i个分数之和）+1/e*（maxd-i）<a/b，可以直接break;
        if(b*(maxd+1-d)<=a*i)
            break;
        v[d]=i;
        aa=a*i-b;
        bb=b*i;
        g=gcd(aa,bb);
        aa=aa/g;
        bb=bb/g;//约分
        if(dfs(aa,bb,i+1,d+1))
            ok=true;
    }
    return ok;
}
int main()
{
    int64_t a,b,aa,bb,i,g;
    while(cin>>a>>b)
    {
        if(a==0)
        {
            cout<<a<<"/"<<b<<"=0"<<endl;
            continue;
        }
        memset(ans,-1,sizeof(ans));
        g=gcd(a,b);
        aa=a/g;
        bb=b/g;
        if(aa==1)
        {
            printf("%d/%d=%d/%d\n",a,b,aa,bb);
        }
        else
        {
            for(maxd=1;;maxd++)
            {
                if(dfs(aa,bb,getfirst(aa,bb),0))
                    break;
            }
            cout<<a<<"/"<<b<<"=";
            for(i=0;i<=maxd-1;i++)
                cout<<"1/"<<ans[i]<<"+";
            cout<<"1/"<<ans[i];
            cout<<endl;
        }
    }
    return 0;
}

 

 

方法：迭代加深解答树并进行剪枝
剪枝点：

1. 要表示的分数与已经分配到分数总和的差值要大于0才继续尝试
2. 根据剩余深度和上面的差值确定每层尝试分数分母的上限，下限即前一分配好的分数的分母加1

   #include <iostream>  
   #include <math.h>  
   using namespace std;  
   #define N 10000000  
   int array[N];  
     
   double is_equal(int a, int b, int cur)  
   {  
       double sum = 0;  
       for (int i = 0; i <= cur; i++)  
           sum += (double)1 / array[i];  
       return (double)a / b - sum;  
   }  
     
   int dfs(int cur, int d, int a, int b)  
   {  
       if (cur == d)  
           return 0;  
       int start = (int)(d - cur) / (is_equal(a, b, cur - 1));  
       int end = cur == 0 ? 2 : array[cur-1] + 1;  
       for (int i = start;i>=end; i--)  
       {  
           array[cur] = i;  
           double p = is_equal(a, b, cur);  
           if (abs(p) <= 0.00001)  
           {  
               for (int j = 0; j <= cur; j++)  
                   cout << array[j] << ' ';  
               cout << endl;  
               return 1;  
           }  
           else if (p > 0)  
           {  
               if (dfs(cur + 1, d, a, b))  
                   return 1;  
           }  
       }  
       return 0;  
   }  
     
   int main()  
   {  
       int a, b;  
       cin >> a >> b;  
       for (int i = 1; ; i++)  
       {  
           //cout << i << endl;  
           if (dfs(0, i, a, b))  
               break;  
       }  
   }