HDU 3555 \数位DP

最新推荐文章于 2024-10-01 18:52:56 发布

转载最新推荐文章于 2024-10-01 18:52:56 发布 · 439 阅读

文章标签：

本文探讨了如何通过动态规划解决寻找一个接近10^20的大数中包含特定子串（如49）的方案数问题。详细介绍了状态转移方程及其在高位统计过程中的应用。

题意就是找0到n有多少个数中含有49。数据范围接近10^20

DP的状态是2维的dp[len][3]
dp[len][0] 代表长度为len不含49的方案数
dp[len][1] 代表长度为len不含49但是以9开头的数字的方案数
dp[len][2] 代表长度为len含有49的方案数

状态转移如下
dp[i][0] = dp[i-1][0] * 10 - dp[i-1][1]; // not include 49 如果不含49且，在前面可以填上0-9 但是要减去dp[i-1][1] 因为4会和9构成49
dp[i][1] = dp[i-1][0]; // not include 49 but starts with 9 这个直接在不含49的数上填个9就行了
dp[i][2] = dp[i-1][2] * 10 + dp[i-1][1]; // include 49 已经含有49的数可以填0-9，或者9开头的填4

接着就是从高位开始统计

在统计到某一位的时候，加上 dp[i-1][2] * digit[i] 是显然对的，因为这一位可以填 0 - (digit[i]-1)
若这一位之前挨着49，那么加上 dp[i-1][0] * digit[i] 也是显然对的。
若这一位之前没有挨着49，但是digit[i]比4大，那么当这一位填4的时候，就得加上dp[i-1][1]

代码如下

           #include<iostream>
          
           #include<cstring>
          
           #include<cstdio>
          
           using 
           namespace 
           std;
          
           long 
            long 
           dp[20][3];
          
           int 
            digit[20];
          
           int 
            main()
          
           {
          
           memset
           (dp,0,
           sizeof
           (dp));
          
           dp[0][0] = 1;
          
           for
           (
           int 
           i=1; i<20; i++)
          
           {
          
           dp[i][0] = dp[i-1][0] * 10 - dp[i-1][1];  
           // not include 49
          
           dp[i][1] = dp[i-1][0];  
           // not include 49 but starts with 9
          
           dp[i][2] = dp[i-1][2] * 10 + dp[i-1][1]; 
           // include 49
          
           }
          
           int 
           t;
          
           cin >> t;
          
           while
           (t--)
          
           {
          
           int 
           len = 0,last=0;
          
           long 
           long 
           ans = 0;
          
           unsigned 
           long 
           long 
           n=0;
          
           cin >> n;
          
           n++;
          
           memset
           (digit,0,
           sizeof
           (digit));
          
           while
           (n)
          
           {
          
           digit[++len] = n%10;
          
           n/=10;
          
           }
          
           bool 
           flag = 
           false
           ;
          
           for
           (
           int 
           i =len; i>=1; i--)
          
           {
          
           ans += dp[i-1][2] * digit[i];
          
           if
           (flag)
          
           ans += dp[i-1][0] * digit[i];
          
           if
           (!flag && digit[i] >4)
          
           ans += dp[i-1][1];
          
           if
           (last == 4 && digit[i] == 9)
          
           flag = 
           true
           ;
          
           last = digit[i];
          
           }
          
           cout << ans << endl;
          
           }
          
           return 
           0;
          
           }