HDU 4734 F(x) 数位DP

最新推荐文章于 2018-08-21 15:46:11 发布

Feynman1999

最新推荐文章于 2018-08-21 15:46:11 发布

阅读量246

点赞数 1

CC 4.0 BY-SA版权

分类专栏： Digital DP

本文链接：https://blog.csdn.net/Feynman1999/article/details/79048439

Digital DP 专栏收录该内容

4 篇文章

订阅专栏

本文针对一个特定的数值计算问题，提出了一种优化方案来减少内存使用并提高算法效率。通过对不同输入数据的分析，发现每次计算时需要重置内存的状态会导致时间复杂度增加。通过调整算法逻辑，将内存初始化操作移出循环，显著减少了重复计算，从而提高了整体性能。

problem

For a decimal number x with n digits (A nA n-1A n-2 … A 2A 1), we define its weight as F(x) = A n * 2 n-1 + A n-1 * 2 n-2 + … + A 2 * 2 + A 1 * 1. Now you are given two numbers A and B, please calculate how many numbers are there between 0 and B, inclusive, whose weight is no more than F(A).

Input

The first line has a number T (T <= 10000) , indicating the number of test cases.
For each test case, there are two numbers A and B (0 <= A,B < 10 9)

Output

The first line has a number T (T <= 10000) , indicating the number of test cases.
For each test case, there are two numbers A and B (0 <= A,B < 10 9)

Sample Input

3
0 100
1 10
5 100

Sample Output

Case #1: 1
Case #2: 2
Case #3: 13

超时的例子（memset内置）

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

const int maxn=5000;

ll a[11];

ll dp[11][maxn];

ll SUM;

ll fun(ll n)
{
    int pos=0;
    while(n)
    {
        a[pos++]=n%10;
        n/=10;
    }
    ll sum=0;
    pos--;
    for(int i=pos;i>=0;--i){
        //cout<<a[i]<<' ';
        sum+=a[i]*(1<<i);
    }
    //cout<<endl;
    return sum;
}


ll dfs(int pos,int sum,bool limit)
{
    if(pos==-1){
        return (sum<=SUM);
    }
    if(sum>SUM) return 0;//提前return0
    if(!limit && dp[pos][sum]!=-1) return dp[pos][sum];
    int up=limit? a[pos] : 9;
    ll tmp=0;
    for(int i=0;i<=up;i++){
        tmp+=dfs(pos-1,sum+i*(1<<pos),limit && i==a[pos]);
    }
    if(!limit) dp[pos][sum]=tmp;
    return tmp;
}


ll solve(ll n)
{
    int pos=0;
    while(n)
    {
        a[pos++]=n%10;
        n/=10;
    }
    dfs(pos-1,0,true);
    //cout<<fun(pos-1)<<endl;
}

int main()
{
    ios::sync_with_stdio(false);
    int t,num;
    num=0;
    ll a,b;
    cin>>t;
    memset(dp,-1,sizeof(dp));
    while(t--)
    {
        memset(dp,-1,sizeof(dp));//由于每次SUM不同，dfs时记忆的dp[pos][sum]值也就不同，所以每次都要memset，导致超时
        num++;
        cin>>a>>b;
        SUM=fun(a);
        //solve(b)-solve(0);
        //cout<<SUM<<endl;
        cout<<"Case #"<<num<<": "<<solve(b)<<endl;
    }
    return 0;
}

思路

由于每次SUM不同，dfs时记忆的dp[pos][sum]值也就不同，所以每次都要memset，导致超时。（在某个SUM下，可能当前的sum是小于它的，但换个SUM，就大于了，显然状态要重新记。）

考虑，在没有限制（！limit）的情况下，SUM-sum这个标准对所有样例是一样的。由于没有限制指的就是后面位（低位）任意取，而对不同的SUM和sum，这个差值对应的dp值是一模一样的。因为大家都没有限制嘛，而后面的位数又是一致的。
因此可以将memset外置，降低了时间复杂度。

代码示例

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

const int maxn=1e4+5;

ll a[20];

ll dp[20][maxn];

ll SUM;

ll fun(ll n)
{
    int pos=0;
    while(n)
    {
        a[pos++]=n%10;
        n/=10;
    }
    ll sum=0;
    pos--;
    for(int i=pos;i>=0;--i){
        //cout<<a[i]<<' ';
        sum+=a[i]*(1<<i);
    }
    //cout<<endl;
    return sum;
}


ll dfs(int pos,int sum,bool limit)
{
    if(pos==-1){
        return (sum<=SUM);
    }
    if(sum>SUM) return 0;//提前return0
    if(!limit && dp[pos][SUM-sum]!=-1) return dp[pos][SUM-sum];//用与SUM的差做状态标准
    int up=limit? a[pos] : 9;
    ll tmp=0;
    for(int i=0;i<=up;i++){
        tmp+=dfs(pos-1,sum+i*(1<<pos),limit && i==a[pos]);
    }
    if(!limit) dp[pos][SUM-sum]=tmp;
    return tmp;
}


ll solve(ll n)
{
    int pos=0;
    while(n)
    {
        a[pos++]=n%10;
        n/=10;
    }
    dfs(pos-1,0,true);
    //cout<<fun(pos-1)<<endl;
}

int main()
{
    ios::sync_with_stdio(false);
    int t,num;
    num=0;
    ll a,b;
    cin>>t;
    memset(dp,-1,sizeof(dp));//可以外置
    while(t--)
    {
        num++;
        cin>>a>>b;
        SUM=fun(a);
        //solve(b)-solve(0);
        //cout<<SUM<<endl;
        cout<<"Case #"<<num<<": "<<solve(b)<<endl;
    }
    return 0;
}

dfs部分也可以这样写(本质一样)

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