NOIP 2001 数的计算-五种解法

题目链接

---

---

题目描述

我们要求找出具有下列性质数的个数(包含输入的自然数 nn ):

先输入一个自然数 n(n≤1000),然后对此自然数按照如下方法进行处理:

1. 不作任何处理;
2. 在它的左边加上一个自然数,但该自然数不能超过原数的一半;
3. 加上数后,继续按此规则进行处理,直到不能再加自然数为止.

输入输出格式

输入格式：

1 个自然数 n (n≤1000 )

输出格式：

1 个整数，表示具有该性质数的个数。

输入输出样例

输入样例#1：

6

输出样例#1：

6

说明

满足条件的数为

6，16，26，126，36，136

---

来，上车！

这题不难，但值得深究。

是的，我想出了五种方法。

方法一 递归

用递归，f(n)=1+f(1)+f(2)+……+f(n/2),当n较大时会超时，时间为指数级。

代码-超时：

#include<bits/stdc++.h>
using namespace std;
int ans;
void solve(int m)            //统计m所扩展出的数据个数 
{
    int i;
    ans++;                  //每出现一个原数，累加器加1     
    for(i=1;i<=m/2;i++)    //左边添加不超过原数一半的自然数，作为新原数 
        dfs(i);
}
int main()
{
    int n;
    scanf("%d",&n);
    dfs(n);
    printf("%d\n",ans);
    return 0;
}

方法二 记忆化搜索

用记忆化搜索，实际上是对方法一的改进。设h[i]表示自然数i满足题意三个条件的数的个数。若用递归求解，会重复来求一些子问题。例如在求h[4]时，需要再求h[1]和h[2]的值。现在用h数组记录在记忆求解过程中得出的所有子问题的解，当遇到重复子问题时，直接使用前面记忆的结果。

代码：

#include<bits/stdc++.h>
using namespace std;
int h[1001];
void dfs(int m)
{
    int i;
    if(h[m]!=-1) return;
                    //说明前面已经求得h[m]的值，直接引用即可，无需再递归 
    h[m]=1;         //表示m本身是一种情况 
    for(i=1;i<=m/2;i++)
    {
        dfs(i);
        h[m]+=h[i];
    }
}
int main()
{
    int n;
    cin>>n;
    for(int i=1;i<=n;i++)
        h[i]=-1;    //h数组初始化为-1 
    dfs(n);         //由顶到下记忆化递归求解 
    cout<<h[n];
    return 0;
}

方法三 递推

用递推，用h（n）表示自然数n所能扩展的数据个数，则h（1）=1，h（2）=2，h（3）=2，h（4）=4，h（5）=4，h（6）=6，h（7）=6，h（8）=10，h（9）=10。分析以上数据，可得递推公式：h(i)=1+h(1)+h(2)+···+h(i/2)。此算法时间复杂度为O(n*n)。

设h[i]-i按照规则扩展出的自然数个数(1≤i≤n)。下表列出了h[i]值及其方案：

i	h[i]	自然数序列
1	1	1
2	2	2 12
3	2	3 13
4	4	4 14 24 124
5	4	5 15 25 125
……	……	……
i	$1+\sum_{k=1}^{[ \frac{i}{2}]}{h[k]}$	i 1i 2i 12i …

由于1为最小非零自然数，因此1无法扩展出其他自然数。自然数i(2≤i≤n)按照规则扩展出的自然数包括i；i左边加上1；左边加上2按规则扩展出的h[2]个自然数……；由于i左邻的自然数不超过[i/2]，因此直至i左边加上h[[i/2]]个自然数（这些自然数由[i/2]按规则扩展出）为止。由此得出递推的计数公式：

h[1]=1;

h[i]=$1+\sum_{k=1}^{[ \frac{i}{2}]}{h[k]}$ (2≤i≤n)

从1出发，按照上述公式递推至自然数n，便可得出n按规则扩展出的自然数个数h[n]。

代码：

#include<iostream>
using namespace std;
int h[10001];
int main()
{
    int n;
    cin>>n;
    for(int i=1;i<=n;i++)           //按递增顺序计算扩展出的自然数个数
    {
        h[i]=1;                     //扩展出的自然数包括i本身
        for(int j=1;j<=i/2;j++)     //i左边分别加上i···自然数[i/2]按规则扩展出
                                    //的自然数个数
            h[i]+=h[j];
    }
    cout<<h[n];
    return 0;
}

方法四 改进方法三

对方法三的改进，定义数组s，s(x)=h(1)+h(2)+···+h(x)，h(x)=s(x)-s(x-1)，此算法的时间复杂度可降到O(n)。

代码：

#include<iostream>
using namespace std;
int h[10001],s[10001];
int main()
{
    int n;
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        h[i]=1+s[i/2];
        s[i]=s[i-1]+h[i];       //s是h的前缀累加和
    }
    cout<<h[n];
    return 0;
}

方法五 更强的递推

还是用递推，只要作仔细分析，不难发现以下的递推公式：

• 当i为奇数时，h[i]=h[i-1]；
• 当i为偶数时，h[i]=h[i-1]+h[i/2]。

代码：

#include<iostream>
using namespace std;
int h[10001];
int main()
{
    int n;
    cin>>n;
    h[1]=1;
    for(int i=2;i<=n;i++)
    {
        h[i]=h[i-1];
        if(i%2==0)
            h[i]+=h[i/2];
    }
    cout<<h[n];
    return 0;
}