蓝桥杯 ALGO-532 数的计数 java题解

题目

试题来源

　　NOIP2001 普及组

问题描述
　　我们要求找出具有下列性质数的个数(包含输入的自然数n):
　　先输入一个自然数n(n<=1000),然后对此自然数按照如下方法进行处理:
　　1. 不作任何处理;
　　2. 在它的左边加上一个自然数,但该自然数不能超过原数的一半;
　　3. 加上数后,继续按此规则进行处理,直到不能再加自然数为止.

输入格式

　　一个数n

输出格式

　　一个数表示答案

样例输入

        6

样例输出

        6

样例说明

满足条件的数为6,16,26,126,36,136

---

分析

蓝桥杯给本题的关键字是：记忆化递归 递推

所以本题有两种方向：

1.递归：

        方法一：普通递归。dg(n)=1+dg(1)+dg(2)+......+dg(n/2)，当n较大时会超时(但在蓝桥杯的在线测评系统上可以通过，应该是蓝桥杯的在线测评系统测试点不完整)。

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

2.递推：

        方法三：根据三条规则可以得到前十个数扩展后每个数对应的个数。

n	0	1	2	3	4	5	6	7	8	9	10
h[n]	1	1	2	2	4	4	6	6	10	10	14

                       1.分析数据可以得到递推公式：

                                h[i]=1+h[1]+h[2]+......+h[i\2]

                        2.分析数据可以得到递推公式：

                                当i为奇数时，h[i]=h[i-1]; 当i为偶数时,h[i]=h[i-1]+h[i\2](i>0)

                        3.分析数据可以得到递推公式：

                                h[i]=h[i-2]+h[i\2](i>1)

---

AC

        方法一：

import java.util.Scanner;

public class Main {
    public static int sum;
    
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        dg(n);
        System.out.println(sum);
    }

    public static void dg(int n) {
        // 每出现一个原数，sum+1
        sum++;
        // 左边添加不超过原数一半的自然数，作为新原数
        for (int i = 1; i <= n / 2; i++) {
            dg(i);
        }
    }
}

        方法二：

import java.util.Scanner;

public class Main {

    public static Scanner scanner = new Scanner(System.in);
    public static int n = scanner.nextInt();
    public static int[] h = new int[n + 1];

    public static void main(String[] args) {
        dg(n);
        System.out.println(h[n]);
    }

    public static void dg(int m) {
        // 说明前面已经求得h[m]的值，直接引用即可，不需要再递归
        if (h[m] != 0) {
            return;
        }
        // 将h[m]置为1，表示m本身为一种情况
        h[m] = 1;
        for (int i = 1; i <= m / 2; i++) {
            dg(i);
            h[m] += h[i];
        }
    }
}

        方法三：

1.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[] h = new int[n + 1];
        // 按照递增顺序计算扩展出的自然数的个数
        h[1] = 1;
        for (int i = 2; i <= n; i++) {
            // 扩展出的自然数包括i本身
            h[i] = 1;
            for (int j = 1; j <= i / 2; j++) {
                h[i] += h[j];
            }
        }
        System.out.println(h[n]);
    }
}

2.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[] h = new int[n+1];
        h[1] = 1;
        for (int i = 2; i <= n; i++) {
            if (i % 2 == 0) {
                h[i] = h[i - 1] + h[i / 2];
            }else{
                h[i] = h[i - 1];
            }
        }
        System.out.println(h[n]);
    }
}

3.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[] h = new int[n + 1];
        h[0] = h[1] =1;
        for (int i = 2; i <= n; i++) {
            h[i] = h[i - 2] + h[i / 2];
        }
        System.out.println(h[n]);
    }
}

---

参考

https://blog.csdn.net/sinat_34943123/article/details/51435658

https://blog.csdn.net/u011434547/article/details/38018051