HDU - 4352 XHXJ's LIS 数位dp+离散化

题目链接：XHXJ's LIS

初看这道题目首先回忆起LIS的O(nlogn)的做法，于是想到定义状态dp[pos][LIS*][k]，pos代表当前数位，LIS*代表由前缀构造的LIS数组，k代表最长上升子序列的长度。

问题来了，一个数组肯定不能作为下标，所以我们要把这个数组转化成数字。

注意到数组的每个元素取值范围都是0~9，数组的长度最大为10，所以一个最简单的想法就是把数组转化成一个int类型的数字。

但是很明显需要的内存太大，还有什么办法呢？

因为是严格单调递增的子序列，所以LIS数组中的元素肯定是两两不同的，所有可能的情况总共有

这样一来只需要一个离散化就可以解决问题了，复杂度降低为18 * 1023 * 10。

还有一个小问题，如何离散化？

注意到1023 = 2^10 - 1，所以想到用一个10位的二进制数来表示0~9是否出现。

如果当前LIS数组为LIS[0] = 1, LIS[1] = 3, LIS[2] = 4，则对应的二进制数就为0101100000，这样一来就实现了离散化。

代码如下：

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <vector>
#include <cstdio>
#include <map>

using namespace std;

typedef long long int LL;
LL dp[20][1200][20];
int Lis[20];
int bit[20];
int digit[20];

int Hash(int len)
{
    int ret = 0;
    for (int i = 0; i < len; i++)
        ret += bit[Lis[i]];
    return ret;
}

LL dfs(int pos, int len, int k, int lead, int limit)
{
    if (!pos)
        return len == k;
    if (len > k)
        return 0;
    int code = Hash(len);
    if (!limit && dp[pos][code][k] != -1)
        return dp[pos][code][k];
    int up = limit ? digit[pos] : 9;
    LL ans = 0;
    for (int i = 0; i <= up; i++)
    {
        int idx = lower_bound(Lis, Lis + len, i) - Lis;
        int temp = Lis[idx];
        Lis[idx] = i;
        ans += dfs(pos-1, (lead&&!i)?0:len+(idx==len), k, lead&&!i, limit&&i==up);
        Lis[idx] = temp;
    }
    return limit ? ans : dp[pos][code][k] = ans;
}

LL cal(LL n, int k)
{
    int len = 0;
    while (n)
    {
        digit[++len] = n % 10;
        n /= 10;
    }
    return dfs(len, 0, k, 1, 1);
}

int main()
{
    //freopen("test.txt", "r", stdin);
    bit[0] = 1;
    for (int i = 1; i <= 9; i++)
        bit[i] = bit[i - 1] * 2;
    memset(dp, -1, sizeof(dp));
    int T, Case = 1;
    scanf("%d", &T);
    while (T--)
    {
        LL L, R;
        int K;
        scanf("%I64d%I64d%d", &L, &R, &K);
        printf("Case #%d: ", Case++);
        printf("%I64d\n", cal(R, K) - cal(L - 1, K));
    }
    return 0;
}