題目大意

任何正整數都能分解成2的冪，給定整數N，求N的此類劃分方法的數量！

比如N = 7時，共有6種劃分方法。

7=1+1+1+1+1+1+1
=1+1+1+1+1+2
=1+1+1+2+2
=1+2+2+2
=1+1+1+4
=1+2+4

最簡單的方法

首先很容易想到用DP做。
設f[i][j]表示組成的數是i，方案中最大的數是2j的方案數。
為了避免重複，f[i][j]轉移時列舉下一個數必須大於等於2j
那麼可以得出：f[i][j]=∑jk=0f[i−2j][k]
注意到第一維是和k無關的，配合字首和優化即可做到O(nlogn)

相對巧妙的做法

狀態太大了，可不可以減去一維？
設f[i]表示組成i的方案數。如果還是列舉下一個數來轉移，那麼時間複雜度沒變。
那麼考慮換一種轉移方式。先給出方程：
f[i]=f[i−1]+f[i/2]∗[i是偶數]
f[i-1]轉移到f[i]表示加入了一個1，f[i/2]則表示f[i/2]的分解方案中，全部數乘2。這樣轉移也保證了加進來數的順序是從大到小的，故不會重複。

時間複雜度O(n)

跑得很快的做法

如果n很大怎麼辦？
那樣就要挖掘一下分解方案的性質了。

1. 對於一個數n，假設它二進位制下有m個1，分別是第a1,a2…am位。對於n的任意一種分解方案，把所有2的冪升序排序，然後可以劃分成m段，其中第i段的和是2
   ai
2. 對於一個數2i的一種劃分方案，如果不是隻有它本身一個數，一定可以把這些2的冪升序排序，然後分成兩段，每一段的和都是2i−1

證明並不難。有了這些性質，就可以設新的狀態了。

首先設g[i][j]表示做完了前i段（即n二進位制下的前i個1位），最大的數是2j，方案數是多少。
再設一個輔助陣列f[i][j]，表示組成2i，最大的數是2j的方案數。
接下來列舉第i-1段的最大數是多少，假設是2k，那麼g[i][j]=∑jk=0g[i−1][k]∗f[i−k][j−k]
其中i-k,j-k的意義在於：要控制後面的數都大於等於2k，每個數都要除掉2k，那麼就不會算重了。
f[i][j]的轉移類似

時間複雜度O(log3n∗高精度)

#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int N=99,M=170,mo=1e9;

typedef long long LL;

char c[N];

int tot;

struct num
{
    int w,a[M];
}f[N+5][N+5],ans,n,p,t,s[N+5],g[N+5][N+5];

num operator + (const num &a,const num &b)
{
    t.w=max(a.w,b.w);
    //t.a[1]=0;
    memset(t.a,0,sizeof(t.a));
    for (int i=1;i<=t.w;i++)
    {
        t.a[i]+=a.a[i]+b.a[i];
        if (t.a[i]>=mo)
        {
            t.a[i+1]=1;
            t.a[i]-=mo;
        }//else t.a[i+1]=0;
    }
    if (t.a[t.w+1]>0) t.w++;
    //memset(t.a+t.w+1,0,sizeof(t.a+t.w+1));
    return t;
}

num operator * (const num &a,const num &b)
{
    memset(t.a,0,sizeof(t.a));
    for (int i=1;i<=a.w;i++)
    {
        for (int j=1;j<=b.w;j++)
        {
            t.a[i+j]+=(t.a[i+j-1]+(LL)a.a[i]*b.a[j])/mo;
            t.a[i+j-1]=(t.a[i+j-1]+(LL)a.a[i]*b.a[j])%mo;
        }
    }
    for (t.w=a.w+b.w;t.w>1 && t.a[t.w]==0;t.w--);
    return t;
}

int main()
{
    freopen("data.out","w",stdout);
    scanf("%s",c+1);
    int l=strlen(c+1);
    n.w=l/9+1;
    for (int i=1;i<=l;i++)
    {
        int j=(l-i)/9;
        n.a[j+1]=n.a[j+1]*10+c[i]-48;
    }
    f[0][0].w=f[0][0].a[1]=1;
    for (int i=1;i<=N;i++)
    {
        for (int j=0;j<i;j++)
        {
            for (int k=0;k<=j;k++)
            {
                f[i][j]=f[i][j]+f[i-1][k]*f[i-1-k][j-k];
            }
        }
        f[i][i].w=f[i][i].a[1]=1;
    }
    tot=0;
    for (int i=0;i<=N;i++)
    {
        if (n.a[1]&1)
        {
            tot++;
            if (tot==1)
            {
                for (int j=0;j<=i;j++) g[1][j]=f[i][j];
            }else
            {
                for (int j=0;j<=i;j++)
                {
                    for (int k=0;k<=j;k++)
                    {
                        g[tot][j]=g[tot][j]+g[tot-1][k]*f[i-k][j-k];
                    }
                }
            }
        }
        int r=0;
        for (int j=n.w;j;j--)
        {
            int t=n.a[j];
            n.a[j]=((LL)r*mo+t)/2;
            r=((LL)r*mo+t)%2;
        }
    }
    for (int i=0;i<=N;i++) ans=ans+g[tot][i];
    printf("%d",ans.a[ans.w]);
    for (int i=ans.w-1;i;i--)
    {
        for (int j=1e8;j;j/=10)
        {
            printf("%d",ans.a[i]/j);
            ans.a[i]%=j;
        }
    }
    printf("\n");
    return 0;
}