HDU 4352

题意略。

思路：

这一发A得实在是难能可贵。因此我要记录一下。

首先这个题很明显是个数位dp，其难点在于如何知道填到当前这一位时，我的最长上升子序列是多长。

如果是一个简单的求最长上升子序列的题，我们一般会在一个数组中使用二分法，每次查找新来的这个数字在这个数组中应该排什么位置。

但是我们记录状态不可能还带着一个数组。回过头来仔细研究一下这种数组的性质，你会发现它数组内的元素一定是从前到后严格递增的。

那其实我们可以只记录在当前状态时，这个数组中都有哪些元素就可以了，因为反正是两两不同且严格递增的。

又考虑到这个数组中只可能存在0~9这10个数，因此我们可以状态压缩一下。

从这个角度来说，本题同时考察了状压dp和数位dp。

1.要设置前导0，在无前导0的情况下，0可以计入状态集合；在有前导0的情况下，0不可以计入。因为09这种上升序列不合题意。

2.dp[pos][state][k] 表示 考虑到pos位，排序数组中的状况是state，最长上升子序列长度为k。

代码附上：

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxn0 = 20;
const int maxn1 = (1<<10) + 5;
const int maxn2 = 15;

LL dp[maxn0][maxn1][maxn2],l,r;
int a[maxn0],store[maxn0],k,t,tail,T;

int cnt1(int x){
    int ret = 0;
    while(x){
        x = x & (x - 1);
        ret += 1;
    }
    return ret;
}
void process(LL x){
    tail = 0;
    while(x){
        a[tail++] = int(x % 10);
        x /= 10;
    }
}
inline void decode(int x){
    t = 0;
    for(int i = 0;(x>>i) > 0;++i){
        int temp = (x>>i);
        if(temp & 1) store[t++] = i;
    }
    store[t] = maxn0;
}
inline int encode(){
    int ret = 0;
    for(int i = 0;i < t;++i) ret += (1<<store[i]);
    return ret;
}
LL dfs(int pos,int state,bool limit,bool lead,int kk){
    
    if(pos == -1) return cnt1(state) == k ? 1 : 0;
    if(!limit && !lead && dp[pos][state][kk] != -1) return dp[pos][state][kk];
    
    int up = limit ? a[pos] : 9;
    LL ret = 0;
    for(int i = 0;i <= up;++i){
        decode(state);
        int idx = lower_bound(store,store + t,i) - store;
        if(idx + 1 > k) break;
        
        store[idx] = i;
        t = max(idx + 1,t);
        
        int nstate = (i == 0 && lead) ? state : encode();
        ret += dfs(pos - 1,nstate,limit && i == up,lead && i == 0,kk);
    }
    if(!limit && !lead) dp[pos][state][kk] = ret;
    return ret;
}

int main(){
    
    scanf("%d",&T);
    memset(dp,-1,sizeof(dp));
    int cas = 1;
    while(T--){
        scanf("%lld%lld%d",&l,&r,&k);
        
        process(l - 1);
        LL ans0 = dfs(tail - 1,0,true,true,k);
        
        process(r);
        LL ans1 = dfs(tail - 1,0,true,true,k);
        
        printf("Case #%d: %lld
",cas++,ans1 - ans0);
    }
    return 0;
}