HDU-4734-F(x)

\(HDU-4734-F(x)\)

题目传送门

一、题目描述

题目给了个\(F(x)\)的定义：$$\large F(x) = A_n * 2^{n-1} + A_{n-1} * 2^{n-2} + ... + A_2 * 2^1 + A_1 * 2^0$$，\(A_i\)是十进制数位，然后给出\(a、b,\)求区间\([0,b]\)内满足\(f(i)<=f(a)\)的\(i\)的个数。其中 \(0 <= A,B < 10^9\)

二、计算题目中的\(F\)函数

#include <bits/stdc++.h>

using namespace std;
/**
12345-->f(12345)=1*2^4+2*2^3+3*2^2+4*2^1+5*2^0
         f(1234) =1*2^3+2*2^2+3*2^1+4*2^0
       2*f(1234) =1*2^4+2*2^3+3*2^2+4*2^1
所以形成递归表示式
*/
//利用递归计算出F(x)
int f(int x) {
    if (x == 0) return 0;
    return f(x / 10) * 2 + x % 10;
}

//利用循环进行计算
int f2(int x) {
    int res = 0;
    int i = 0;
    while (x) {
        res += x % 10 * (1 << i);
        i++;
        x /= 10;
    }
    return res;
}

int main() {
    cout << f(12345) << endl;
    cout << f2(12345) << endl;
    //极大值是1e9-1=99999999
    cout << f2(1e9 - 1) << endl;
    //输出4599
    return 0;
}

三、暴力怎么做？

用例解析：
以 \(5\) \(100\) 为例：即\(A=5,B=100\)
\(F(A)=5*1=5\)
也就是让我们求一下，在\(F(0)\)~\(F(100)\)之间，有多少个\(F(x)<=5\)

撸起袖子就是干！

#include <bits/stdc++.h>

using namespace std;
int F(int x) {
    if (x == 0) return 0;
    return F(x / 10) * 2 + x % 10;
}
int fa;
int main() {
    int T;
    int num = 1;
    cin >> T;

    while (T--) {
        int x, y;
        cin >> x >> y;
        fa = F(x);
        int cnt = 0;
        for (int i = 0; i <= y; i++)
            if (F(i) <= fa) cnt++;

        printf("Case #%d: %d\n", num++, cnt);
    }
    return 0;
}

毫无疑问，如此暴力，只能是\(TLE\),看了一下时间限制，要求\(500ms\),应该是一个数位\(DP\)问题。

四、正常的数位\(DP\)思路

1、思考暴力\(dfs\)怎么做:

int dfs(int pos,int sum,bool limit)

• \(pos\):我在哪里

• \(sum\):我这个分身，走到现在，按\(F(x)\)的计算办法，已经拼接出的加权前缀和是多少,之所以要携带这个，是因为走完全程时需要判断总的\(sum\)是不是小于\(F(A)\)

• \(limit\):是不是贴上界，之所以需要知道这个，是因为每位都需要上一位告诉自己，自己及以后各位是不是能取满，还是只能取一部分

返回值：\(int\)类型的\(dfs\)，思路就是 向后思考 ：如果我站在\(pos\)位置，并且前面的人告诉了我：以前有多少\(sum\)前缀和，是不是贴上界，
然后，我的任务就是计算，在给定的条件下，后续的枚举所有可能数字中，有多少符合条件的数字。

根据这个返回值定义，所以整体的结果就是：\(dfs(al,0,true)\)

2、记忆化

根据我们的经验，\(500ms\)直接暴力\(dfs\)应该也不可能过的了，必须考虑是不是存在重复计算，能不能记忆化。简单想一想，肯定是可以记忆化的：到达哪种状态后，我不管你前面怎么到达我这里，一旦我的状态确定，那么我的后续所有可能中，符合条件的数字个数是一定的，我计算一次，想办法记下来，下回就可以重复利用。

那么按什么来记忆呢？根据经验，\(limit\)一般不记，只记忆\(!limit\)的状态结果，所以\(dp[pos][sum]\)的状态记忆数组定义就出来了。

代码也就很简单了：

#include <cstdio>
#include <cstring>
#include <iostream>
#include <cmath>

using namespace std;
const int N = 32;
const int M = 1024 * 10 + 10;
int f[N][M];
int a[N];
int fa;
int F(int x) {
    if (x == 0) return 0;
    return F(x / 10) * 2 + x % 10;
}

int dfs(int pos, int sum, bool limit) {
    if (pos == 0) return sum <= fa;
    if (sum > fa) return 0;
    if (!limit && ~f[pos][sum]) return f[pos][sum];
    int ans = 0;
    int up = limit ? a[pos] : 9;
    for (int i = 0; i <= up; i++)
        ans += dfs(pos - 1, sum + i * (1 << (pos - 1)), limit && i == a[pos]);

    if (!limit) f[pos][sum] = ans;
    return ans;
}

inline int calc(int x) {
    memset(f, -1, sizeof f);
    int al = 0;
    while (x) a[++al] = x % 10, x /= 10;
    return dfs(al, 0, true);
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);

    int T;
    int cnt = 1;
    cin >> T;

    while (T--) {
        int x, y;
        cin >> x >> y;
        fa = F(x);
        printf("Case #%d: %d\n", cnt++, calc(y));
    }
    return 0;
}

但很不幸运，Time Limit Exceeded

五、释放减法的力量

大神原文

某大神写到:刚开始一眼看到这题，算了一下 \(F(999999999) = 4599\)，也不是很大，感觉挺简单的，想着\(dp[pos][sum]\)不就完事了:\(sum\)记录从\(len\)(最高位)到\(pos\)位上累计的符合条件数字个数；

写出来交了一发，\(TLE\)，感觉就有点奇怪，翻了翻网上的题解，说是不能是\(dp[pos][sum]\)，要是\(dp[pos][F(A) - sum]\)才行；

也就是说，新定义\(dp[pos][comp]\)，\(comp\)代表剩下的从第\(pos\)位到第\(1\)位，累加起来的权重，不能超过\(comp\)；

这是为什么呢？原因其实很简单：

我们定义\(dp[pos][sum]\)的话，显然我们这 \(T\)组数据……

每组数据只要\(B\)有变化，由于\(sum\)是从\(B\)最高位\((al)\)往下累加权重，它跟\(B\)有密切关系（\(B\)的长度\(al\)即为最高位），那么\(dp\)数组就必须要重新\(memset(dp,-1,sizeof(dp))\)，这样才不会出错；

那么我们如果是\(dp[pos][comp]\)呢，\(comp\)代表从第\(1\)位到第\(pos\)位最多还能累加起多少权重，那么它就和\(B\)没有关系，我们就不需要在输入每组数据后都重新将\(dp\)数组全部重置为\(-1\)。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <cmath>

using namespace std;
const int N = 32;       //数位的长度上限
const int M = 1024 * 10 + 10; //剩余的数大小(状态集合按这个划分)
int f[N][M];            //结果DP数组
int a[N];               //数位拆分出来的数组
int fa;
//利用递归计算出
int F(int x) {
    if (x == 0) return 0;
    return F(x / 10) * 2 + x % 10;
}

/**
 * @param pos   数位位置
 * @param st    剩余对比值,初始值是F(x)
 * @param limit 是不是贴上界
 * @return
 */
int dfs(int pos, int st, bool limit) {
    if (pos == 0) return st >= 0; //如果到达最后，并且有剩余，表示f(i)<= f(x)，计数++
    if (st < 0) return 0;         //中途或最后一旦发生小于0情况，剪枝
    if (!limit && ~f[pos][st]) return f[pos][st];
    int ans = 0;
    int up = limit ? a[pos] : 9;
    for (int i = 0; i <= up; i++)
        //st = st - i * 2^ ( p-1 )
        ans += dfs(pos - 1, st - i * (1 << (pos - 1)), limit && i == a[pos]);

    if (!limit) f[pos][st] = ans;
    return ans;
}

inline int calc(int x) {
    int al = 0;
    while (x) a[++al] = x % 10, x /= 10;
    return dfs(al, fa, true);
}

int main() {
    //不加78MS，加了31MS，效果还是很明显的
    ios::sync_with_stdio(false);
    cin.tie(0);

    int T;
    int cnt = 1;
    cin >> T; //这个数值太BT了，最大10000次！

    //优化的写法
    memset(f, -1, sizeof f);
    while (T--) {
        int x, y;
        cin >> x >> y;
        fa = F(x); //计算出F(x)值,这是一个固定值
        printf("Case #%d: %d\n", cnt++, calc(y));
    }
    return 0;
}