CCF系列之有趣的数(201312-4)

Posted 一只猫的旅行

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了CCF系列之有趣的数(201312-4)相关的知识,希望对你有一定的参考价值。

题目链接: http://115.28.138.223:81/view.page?opid=4

试题名称: 有趣的数 

时间限制: 1.0s 

内存限制: 256.0MB 

问题描述: 问题描述

    我们把一个数称为有趣的,当且仅当:
    1. 它的数字只包含0, 1, 2, 3,且这四个数字都出现过至少一次。
    2. 所有的0都出现在所有的1之前,而所有的2都出现在所有的3之前。
    3. 最高位数字不为0。
    因此,符合我们定义的最小的有趣的数是2013。除此以外,4位的有趣的数还有两个:2031和2301。
    请计算恰好有n位的有趣的数的个数。由于答案可能非常大,只需要输出答案除以1000000007的余数。
    输入格式
      输入只有一行,包括恰好一个正整数n (4 ≤ n ≤ 1000)。
    输出格式
      输出只有一行,包括恰好n 位的整数中有趣的数的个数除以1000000007的余数。
    样例输入
      4
    样例输出

      3 

解题思路: 

  1. 在满足题意的情况下,首位只能是2

    最高位不为0,

    如果最高位为1,则不满足0在1之前,

    最高位为3则不满足2在3之前,

    所以最高位只能为2.

  2、在网上找了个动态规划的方法,研究了一晚上大概是这样理解的:

    前n步所有的最优解=前n-1步所有的最优解+第n步的最优解。

    首先考虑0、1、2、3四位的方法,不考虑四位以上。

    那么我可以把哪个数字放在首位呢?0?首位不能是0

                    1?那么0该放哪呢?

                    2。挺合适

                    3?那么2该放哪呢?

                    所以我们获得了第一步骤——放2,一个数字2

 

    现在我们来接着第一步骤继续:

                    我们现在成功放了2了,那么剩下0、1、3。

                    20?可以

                    23?可以

                    21?0该放哪里?

                    所以我们获得了第二步骤——放0,两个数字 2和0

                    以及第三步骤——放3,两个数字 2和3

 

    我们现在先研究第二步骤——放0,两个数字 2和0

                    我们现在放了20了,那么剩下1、3

                    201?可以

                    203?也可以

                    所以我们获得了第四步骤——放1,三个数字 2 0 1

                    以及第五步骤——放3 三个数字 2 0 3

 

    我们现在来接着研究第三步骤:放3,两个数字 2和3

                    230?可以,这是第五步骤

                    231?0该放哪里?

                    所以第三步骤可以和第五步骤建立联系

 

    我们最后研究第四步骤: 放1,三个数字 2 0 1 和 第五步骤:放3 三个数字 2 0 3

                      2031?刚好放完四个数字

                    所以我们获得了第六步骤:四个数字0123放完====================================================================

  总结:

    第一步骤:2               剩余 0 1 3

    第二步骤:2 0     剩余 1 3

    第三步骤:2 3     剩余 0 1

    第四步骤:2 0 1    剩余 3

    第五步骤:2 0 3    剩余 1

    第六步骤:2 0 3 1       剩余 无

  流程图如下:

     技术分享

  根据动态规划的思想:

  前n步所有的最优解=前n-1步所有的最优解+第n步的最优解。

      首先,两个动态增加的量,一个是数字的位数N,另一个是0、1、2、3中出现的个数(虽然要求都至少出现一次,但   是为了维护思想的完整性,所以从出现1个,2个。。。一直递推到4个,额,好像1个、2个完了后,再有个3个就递推到4   个了,算了,不要在意这些细节)。
     数字的位数从1增加到N没有问题。
     关键我们来看看第二个增量。

  状态2和状态3的最优解,依赖于状态1;状态4的最优解依赖于状态2,状态5的最优解依赖于状态2和状态3,状态6的最优解,依赖于状态4和状态5.

3、根据状态之间的转化进行递推:

建立一个二维数组a[N][6],横坐标表示数位N,纵坐标表示刚才的6种状态。

这样的话:

a[ ][ 0 ]就是状态一     // 2      剩余 0 1 3

a[ ][ 1 ]就是状态二  // 2 0    剩余 1 3

a[ ][ 2 ]就是状态三  // 2 3    剩余 0 1

a[ ][ 3 ]就是状态四  // 2 0 1     剩余 3

a[ ][ 4 ]就是状态五  // 2 0 3   剩余 1

a[ ][ 5 ]就是状态六  // 2 0 1 3  剩余 无

 

 

第i位出现第j种状态的情况数表示为 a[i][j]      

i位数的来源在于(i-1)位数(已经按顺序排列)+最后一位数字
例如:

  a[i][0] = a[i-1][0] ;

      使用过2 的情况可以由:   前i-1位使用2(状态1),第i位使用2

 

  a[i][1] = (a[i-1][0] + a[i-1][1] *2);
      使用过 2 0 的情况可以由:前i-1位使用2(状态1),第i位使用0
                  前i-1位使用2 0(状态2),第i位使用0或2  (顺序正确)

     a[i][2] = (a[i-1][0] + a[i-1][2] );
          使用过 2 3 的情况可以由:前i-1位使用2(状态1),第i位使用3
                     前i-1位使用2 3(状态3),第i位使用3  (因为已经有了3了不能用2了,只能用3) 

     a[i][3] = (a[i-1][1] + a[i-1][3] *2);
         使用过 2 0 1 的情况可以由:前i-1位使用2 0(状态2),第i位使用1
                       前i-1位使用2 0 1(状态4),第i位使用1或2 (因为已经有了1了不能用0了,只能用1)

     a[i][4] = (a[i-1][1] + a[i-1][2] + a[i-1][4] *2);
         使用过 2 0 3 的情况可以由: 前i-1位使用2 0(状态2),第i位使用3
                      前i-1位使用2 3(状态3),第i位使用0
                      前i-1位使用2 0 3(状态5),第i位使用0或3 (因为已经有了3了不能用2了,只能用3)
      

     a[i][5] = (a[i-1][3] + a[i-1][4] + a[i-1][5] *2);
        使用过2 3 0 1的情况可以由: 前i-1位使用2 0 1(状态4),第i位使用3
                      前i-1位使用2 0 3(状态5),第i位使用1
                      前i-1位使用2 3 0 1(状态6),第i位使用1或3

                     (因为已经有了1了不能用0了,只能用1)

                     (因为已经有了3了不能用2了,只能用3)


    题目要求的答案为a[n][5],即0 1 2 3都使用过。

4.注意答案可能非常大,会爆int,应用long long。

  由于答案可能非常大,只需要输出答案除以1000000007的余数。

  mod = 1000000007;

 1         a[0][0] = 1;
 2         for (int i = 1; i < N; i++) {
 3             j = i - 1;
 4             a[i][0] = (a[j][0] * 1) % mod;
 5             a[i][1] = (a[j][0] * 1 + a[j][1] * 2) % mod;
 6             a[i][2] = (a[j][0] * 1 + a[j][2] * 1) % mod;
 7             a[i][3] = (a[j][1] * 1 + a[j][3] * 2) % mod;
 8             a[i][4] = (a[j][1] * 1 + a[j][2] * 1 + a[j][4] * 2) % mod;
 9             a[i][5] = (a[j][3] * 1 + a[j][4] * 1 + a[j][5] * 2) % mod;
10         }
11         System.out.println(a[N - 1][5]);    

5.代码如下(java):

版本1(完全符合以上分析,好理解):

 1 package ccf_text;
 2 
 3 import java.util.Scanner;
 4 
 5 public class MainD2 {
 6     public static void main(String[] args) {
 7         Scanner in = new Scanner(System.in);
 8         int N = in.nextInt();
 9         long a[][] = new long[N][6];
10         int j = 0;
11         long mod = 1000000007;
12         // 2
13         // 2 0
14         // 2 3
15         // 2 0 1
16         // 2 0 3
17         // 2 0 1 3
18         a[0][0] = 1;
19         for (int i = 1; i < N; i++) {
20             j = i - 1;
21             a[i][0] = (a[j][0] * 1) % mod;
22             a[i][1] = (a[j][0] * 1 + a[j][1] * 2) % mod;
23             a[i][2] = (a[j][0] * 1 + a[j][2] * 1) % mod;
24             a[i][3] = (a[j][1] * 1 + a[j][3] * 2) % mod;
25             a[i][4] = (a[j][1] * 1 + a[j][2] * 1 + a[j][4] * 2) % mod;
26             a[i][5] = (a[j][3] * 1 + a[j][4] * 1 + a[j][5] * 2) % mod;
27         }
28         System.out.println(a[N - 1][5]);
29     }
30 }

版本2(标准答案):

 1 package ccf_text2013_12;
 2 
 3 import java.util.*;
 4 /**
 5  * 我们把一个数称为有趣的,当且仅当:
 6   1. 它的数字只包含0, 1, 2, 3,且这四个数字都出现过至少一次。
 7   2. 所有的0都出现在所有的1之前,而所有的2都出现在所有的3之前。
 8   3. 最高位数字不为0。
 9   因此,符合我们定义的最小的有趣的数是2013。除此以外,4位的有趣的数还有两个:2031和2301。
10   请计算恰好有n位的有趣的数的个数。由于答案可能非常大,只需要输出答案除以1000000007的余数。
11  * @author Hello stranger
12  *
13  */
14 public class InterstingData {
15     public static void main(String[] args) {
16         new InterstingData().run();
17     }
18 
19     public void run() {
20         Scanner fin = new Scanner(System.in);
21 
22         int N = fin.nextInt();
23         long[] count = new long[8];
24         count[6] = 0;
25         count[7] = 1;
26         long mod = 1000000007;
27         for (int i = 2; i <= N; ++i) {
28             long[] newCount = new long[8];
29             newCount[0] = (count[0] * 2 + count[1] + count[3]) % mod;
30             newCount[1] = (count[1] * 2 + count[2] + count[5]) % mod;
31             newCount[2] = (count[2] + count[6]) % mod;
32             newCount[3] = (count[3] * 2 + count[4] + count[5]) % mod;
33             newCount[4] = (count[4] + count[7]) % mod;
34             newCount[5] = (count[5] * 2 + count[6] + count[7]) % mod;
35             newCount[6] = 0;
36             newCount[7] = 1;
37 
38             count = newCount;
39         }
40 
41         System.out.println(count[0]);
42     }
43 }

 

6.运行结果示例:

  技术分享

 

以上是关于CCF系列之有趣的数(201312-4)的主要内容,如果未能解决你的问题,请参考以下文章

CCF 201312-4 有趣的数

CCF 201312-4 有趣的数[dp][难]

CCF 201312-4 有趣的数 100分(数位dp)

CCF 201312-4 有趣的数 100分(数位dp)

CCF 201312-4 有趣的数 100分(数位dp)

CCF 201312-4有趣的数 (数位DP, 状压DP, 组合数学+暴力枚举, 推公式, 矩阵快速幂)