数位DP题集

最新推荐文章于 2021-05-12 18:20:58 发布
最新推荐文章于 2021-05-12 18:20:58 发布
阅读量1.4k 收藏
点赞数
分类专栏： 数学基础 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gyarenas/article/details/9080583
版权

强烈推荐记忆化搜索写法，好写，通用。

入门题：

hdoj 2089


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <algorithm>
#include <vector>
#include <cstring>
#include <stack>
#include <cctype>
#include <utility>   
#include <map>
#include <string>  
#include <climits> 
#include <set>
#include <string>    
#include <sstream>
#include <utility>   
#include <ctime>

using std::priority_queue;
using std::vector;
using std::swap;
using std::stack;
using std::sort;
using std::max;
using std::min;
using std::pair;
using std::map;
using std::string;
using std::cin;
using std::cout;
using std::set;
using std::queue;
using std::string;
using std::istringstream;
using std::make_pair;
using std::getline;
using std::greater;
using std::endl;
using std::multimap;
using std::deque;

typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PAIR;
typedef multimap<int, int> MMAP;

const int MAXN(10);
const int SIGMA_SIZE(2);
const int MAXM(110);
const int MAXE(300010);
const int MAXH(18);
const int INFI((INT_MAX-1) >> 1);
const int MOD(1000000007);
const ULL LIM(1000000000000000ull);

int table[10][2];
int digit[10];

int dfs(int len, int flag, bool bound)
{
    if(len == 0)
        return 1;
    if(!bound && table[len][flag] != -1)
        return table[len][flag];
    int up = bound? digit[len]: 9;
    int ret = 0;
    for(int i = 0; i <= up; ++i)
    {
        if(i == 4 || (flag && i == 2))
            continue;
        ret += dfs(len-1, (i == 6? 1: 0), bound && i == up);
    }
    if(!bound)
        table[len][flag] = ret;
    return ret;
}

int fun(int num)
{
    int len = 1;
    while(true)
    {
        digit[len] = num%10;
        num /= 10;
        if(num == 0)
            break;
        ++len;
    }
    return dfs(len, 0, true);
}

int main()
{
    memset(table, -1, sizeof(table));
    int a, b;
    while(scanf("%d%d", &a, &b), a+b)
        printf("%d\n", fun(b)-fun(a-1));
    return 0;
}

HDOJ 3555 


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <algorithm>
#include <vector>
#include <cstring>
#include <stack>
#include <cctype>
#include <utility>   
#include <map>
#include <string>  
#include <climits> 
#include <set>
#include <string>    
#include <sstream>
#include <utility>   
#include <ctime>

using std::priority_queue;
using std::vector;
using std::swap;
using std::stack;
using std::sort;
using std::max;
using std::min;
using std::pair;
using std::map;
using std::string;
using std::cin;
using std::cout;
using std::set;
using std::queue;
using std::string;
using std::istringstream;
using std::make_pair;
using std::getline;
using std::greater;
using std::endl;
using std::multimap;
using std::deque;

typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PAIR;
typedef multimap<int, int> MMAP;

const int MAXN(10);
const int SIGMA_SIZE(2);
const int MAXM(110);
const int MAXE(300010);
const int MAXH(18);
const int INFI((INT_MAX-1) >> 1);
const int MOD(1000000007);
const ULL LIM(1000000000000000ull);

LL table[25][2][2];
int digit[25];

LL dfs(int len, int flag1, int flag2, bool bound)
{
    if(len == 0)
        return flag2? 1: 0;
    if(!bound && table[len][flag1][flag2] != -1)
        return table[len][flag1][flag2];
    int up = bound? digit[len]: 9;
    LL ret = 0;
    for(int i = 0; i <= up; ++i)
        ret += dfs(len-1, (i == 4? 1: 0), flag2|(flag1 && i == 9? 1: 0), bound && i == up);
    if(!bound)
        table[len][flag1][flag2] = ret;
    return ret;
}

LL fun(LL num)
{
    int len = 1;
    while(true)
    {
        digit[len] = num%10;
        num /= 10;
        if(num == 0)
            break;
        ++len;
    }
    return dfs(len, 0, 0, true);
}

int main()
{
    memset(table, -1, sizeof(table));
    int TC;
    scanf("%d", &TC);
    while(TC--)
    {
        LL n;
        scanf("%I64d", &n);
        printf("%I64d\n", fun(n));
    }
    return 0;
}

UESTC 1307 

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <algorithm>
#include <vector>
#include <cstring>
#include <stack>
#include <cctype>
#include <utility>   
#include <map>
#include <string>  
#include <climits> 
#include <set>
#include <string>    
#include <sstream>
#include <utility>   
#include <ctime>

using std::priority_queue;
using std::vector;
using std::swap;
using std::stack;
using std::sort;
using std::max;
using std::min;
using std::pair;
using std::map;
using std::string;
using std::cin;
using std::cout;
using std::set;
using std::queue;
using std::string;
using std::istringstream;
using std::make_pair;
using std::getline;
using std::greater;
using std::endl;
using std::multimap;
using std::deque;

typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PAIR;
typedef multimap<int, int> MMAP;

const int MAXN(10);
const int SIGMA_SIZE(2);
const int MAXM(110);
const int MAXE(300010);
const int MAXH(18);
const int INFI((INT_MAX-1) >> 1);
const int MOD(1000000007);
const ULL LIM(1000000000000000ull);

int table[15][10];
int digit[15];

int dfs(int len, int pre, bool bound, bool zero)
{
	if(len == 0)
		return 1;
	if(!bound && !zero && table[len][pre] != -1)
		return table[len][pre];
	int up = bound? digit[len]: 9;
	int ret = 0;
	for(int i = 0; i <= up; ++i)
	{
		if(!zero && abs(i-pre) < 2)
			continue;
		ret += dfs(len-1, i, bound && i == up, zero && i == 0);
	}
	if(!bound && !zero)
		table[len][pre] = ret;
	return ret;
}

int fun(int num)
{
	int len = 1;
	while(true)
	{
		digit[len] = num%10;
		num /= 10;
		if(num == 0)
			break;
		++len;
	}
	return dfs(len, 0, true, true);
}

int main()
{
	memset(table, -1, sizeof(table));
	int a, b;
	while(~scanf("%d%d", &a, &b))
		printf("%d\n", fun(b)-fun(a-1));
	return 0;
}

常见题型:

hdoj 3652

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <algorithm>
#include <vector>
#include <cstring>
#include <stack>
#include <cctype>
#include <utility>   
#include <map>
#include <string>  
#include <climits> 
#include <set>
#include <string>    
#include <sstream>
#include <utility>   
#include <ctime>

using std::priority_queue;
using std::vector;
using std::swap;
using std::stack;
using std::sort;
using std::max;
using std::min;
using std::pair;
using std::map;
using std::string;
using std::cin;
using std::cout;
using std::set;
using std::queue;
using std::string;
using std::istringstream;
using std::make_pair;
using std::getline;
using std::greater;
using std::endl;
using std::multimap;
using std::deque;

typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PAIR;
typedef multimap<int, int> MMAP;

const int MAXN(10);
const int SIGMA_SIZE(2);
const int MAXM(110);
const int MAXE(300010);
const int MAXH(18);
const int INFI((INT_MAX-1) >> 1);
const int MOD(1000000007);
const ULL LIM(1000000000000000ull);

int table[15][13][2][2];
int digit[15];

int dfs(int len, int divide, int flag1, int flag2, bool bound)
{
    if(len == 0)
        return (divide == 0 && flag2? 1: 0);
    if(!bound && table[len][divide][flag1][flag2] != -1)
        return table[len][divide][flag1][flag2];
    int up = bound? digit[len]: 9;
    int ret = 0;
    for(int i = 0; i <= up; ++i)
        ret += dfs(len-1, (divide*10+i)%13, (i == 1? 1: 0), flag2|(i == 3 && flag1? 1: 0), bound && i == up);
    if(!bound)
        table[len][divide][flag1][flag2] = ret;
    return ret;
}

int fun(int num)
{
    int len = 1;
    while(true)
    {
        digit[len] = num%10;
        num /= 10;
        if(num == 0)
            break;
        ++len;
    }
    return dfs(len, 0, 0, 0, true);
}

int main()
{
    memset(table, -1, sizeof(table));
    int n;
    while(~scanf("%d", &n))
        printf("%d\n", fun(n));
    return 0;
}

hdoj3709 

这个题我是枚举的fix位，因为一个balance number不可能有俩个fix位，所以满足加法原理，不知道有没有更好的办法


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <algorithm>
#include <vector>
#include <cstring>
#include <stack>
#include <cctype>
#include <utility>   
#include <map>
#include <string>  
#include <climits> 
#include <set>
#include <string>    
#include <sstream>
#include <utility>   
#include <ctime>

using std::priority_queue;
using std::vector;
using std::swap;
using std::stack;
using std::sort;
using std::max;
using std::min;
using std::pair;
using std::map;
using std::string;
using std::cin;
using std::cout;
using std::set;
using std::queue;
using std::string;
using std::istringstream;
using std::make_pair;
using std::getline;
using std::greater;
using std::endl;
using std::multimap;
using std::deque;

typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PAIR;
typedef multimap<int, int> MMAP;

const int MAXN(10);
const int SIGMA_SIZE(2);
const int MAXM(110);
const int MAXE(300010);
const int MAXH(18);
const int INFI((INT_MAX-1) >> 1);
const int MOD(1000000007);
const ULL LIM(1000000000000000ull);

LL table[20][20][1800];
int digit[20];

LL dfs(int fix, int len, int presum, bool bound, bool zero)
{
    if(len == 0)
        return presum == 0? 1: 0;
    if(!bound && !zero && table[fix][len][presum] != -1)
        return table[fix][len][presum];
    int up = bound? digit[len]: 9;
    LL ret = 0;
    for(int i = 0; i <= up; ++i)
    {
        LL temp = presum+(len-fix)*i;
        if((zero && i == 0 && fix == len) || temp < 0)
            continue;
        ret += dfs(fix, len-1, temp, bound && i == up, zero && i == 0);
    }
    if(!bound && !zero)
        table[fix][len][presum] = ret;
    return ret;
}

LL fun(LL num)
{
    int len = 1;
    while(true)
    {
        digit[len] = num%10;
        num /= 10;
        if(num == 0)
            break;
        ++len;
    }
    LL ret = 0;
    for(int i = len; i >= 1; --i)
        ret += dfs(i, len, 0, true, true);
    return ret+1;
}

int main()
{
    memset(table, -1, sizeof(table));
    int TC;
    scanf("%d", &TC);
    while(TC--)
    {
        LL a, b;
        scanf("%I64d%I64d", &a, &b);
        printf("%I64d\n", fun(b)-(a? fun(a-1): 0));
    }
    return 0;
}


hdoj 3271

数位DP+构造或者二分都可以

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <algorithm>
#include <vector>
#include <cstring>
#include <stack>
#include <cctype>
#include <utility>   
#include <map>
#include <string>  
#include <climits> 
#include <set>
#include <string>    
#include <sstream>
#include <utility>   
#include <ctime>

using std::priority_queue;
using std::vector;
using std::swap;
using std::stack;
using std::sort;
using std::max;
using std::min;
using std::pair;
using std::map;
using std::string;
using std::cin;
using std::cout;
using std::set;
using std::queue;
using std::string;
using std::istringstream;
using std::make_pair;
using std::getline;
using std::greater;
using std::endl;
using std::multimap;
using std::deque;

typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PAIR;
typedef multimap<int, int> MMAP;

const int MAXN(10);
const int SIGMA_SIZE(2);
const int MAXM(110);
const int MAXE(300010);
const int MAXH(18);
const int INFI((INT_MAX-1) >> 1);
const int MOD(1000000007);
const ULL LIM(1000000000000000ull);

int table[40][500];
int digit[40];
int BASE, M;

int dfs(int len, int sum, bool bound)
{
    if(len == 0)
        return sum == M? 1: 0;
    if(!bound && table[len][sum] != -1)
        return table[len][sum];
    int up = bound? digit[len]: BASE-1;
    int ret = 0;
    for(int i = 0; i <= up; ++i)
    {
        int temp = sum+i;
        if(temp > M)
            continue;
        ret += dfs(len-1, temp, bound && i == up);
    }
    if(!bound)
        table[len][sum] = ret;
    return ret;
}

int fun(int num)
{
    int len = 1;
    while(true)
    {
        digit[len] = num%BASE;
        num /= BASE;
        if(num == 0)
            break;
        ++len;
    }
    return dfs(len, 0, true);
}

int main()
{
    int Q, X, Y, K, n_case(0);
    while(~scanf("%d", &Q))
    {
        printf("Case %d:\n", ++n_case);
        if(Q == 1)
        {
            memset(table, -1, sizeof(table));
            scanf("%d%d%d%d", &X, &Y, &BASE, &M);
            if(X > Y)
                swap(X, Y);
            printf("%d\n", fun(Y)-(X? fun(X-1): 0));
        }
        else
        {
            memset(table, -1, sizeof(table));
            scanf("%d%d%d%d%d", &X, &Y, &BASE, &M, &K);
            if(X > Y)
                swap(X, Y);
            int l = X, r = Y+1;
            int limit = X? fun(X-1): 0;
            while(l < r)
            {
                int m = l+(r-l)/2;
                if(fun(m)-limit < K)
                    l = m+1;
                else
                    r = m;
            }
            if(l == Y+1)
                printf("Could not find the Number!\n");
            else
                printf("%d\n", l);
        }
    }
    return 0;
}

HDOJ 3967

枚举拆分位，由于这题算的是拆分种数，所以直接加和即可


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <algorithm>
#include <vector>
#include <cstring>
#include <stack>
#include <cctype>
#include <utility>   
#include <map>
#include <string>  
#include <climits> 
#include <set>
#include <string>    
#include <sstream>
#include <utility>   
#include <ctime>

using std::priority_queue;
using std::vector;
using std::swap;
using std::stack;
using std::sort;
using std::max;
using std::min;
using std::pair;
using std::map;
using std::string;
using std::cin;
using std::cout;
using std::set;
using std::queue;
using std::string;
using std::istringstream;
using std::make_pair;
using std::getline;
using std::greater;
using std::endl;
using std::multimap;
using std::deque;

typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PAIR;
typedef multimap<int, int> MMAP;

const int MAXN(10);
const int SIGMA_SIZE(2);
const int MAXM(110);
const int MAXE(300010);
const int MAXH(18);
const int INFI((INT_MAX-1) >> 1);
const int MOD(1000000007);
const ULL LIM(1000000000000000ull);

LL table[20][25];
LL pow10[20];
int digit[20];
int K, sep;

LL dfs(int len, LL divide, bool bound, bool zero)
{
    if(len == 0)
        return divide? 0: 1;
    if(!bound && !zero && table[len][divide] != -1)
        return table[len][divide];
    int up = bound? digit[len]: 9;
    LL ret = 0;
    for(int i = 0; i <= up; ++i)
    {
        if(zero && i == 0 && len == sep+1)
            continue;
        ret += dfs(len-1, (divide+(len > sep? i*pow10[len-sep-1]: i*pow10[len-1]))%K, bound && i == up, zero && i == 0);
    }
    if(!bound && !zero)
        table[len][divide] = ret;
    return ret;
}

LL fun(LL num)
{
    int len = 1;
    while(true)
    {
        digit[len] = num%10;
        num /= 10;
        if(num == 0)
            break;
        ++len;
    }
    LL ret = 0;
    for(int i = len-1; i >= 1; --i)
    {
        sep = i;
        memset(table, -1, sizeof(table));
        ret += dfs(len, 0, true, true);
    }
    return ret;
}

int main()
{
    pow10[0] = 1;
    for(int i = 1; i < 20; ++i)
        pow10[i] = pow10[i-1]*10;
    LL A, B;
    while(~scanf("%I64d%I64d%d", &A, &B, &K))
        printf("%I64d\n", fun(B)-(A? fun(A-1): 0));
    return 0;
}

HDOJ 3565

求由两个单峰数组成的数字中数位和最大的最大值，注意单峰数的定义，这题不满足区间减法，所以要同时要卡上界和下界(其实这种写法更加通用)，state是上一位所在的状态，共有7种，0表示前导0,1表示第一个上升坡，2表示第一个顶点，3表示第一个下降坡，4表示第二个上升坡，5表示第二个顶点，6表示第二个下降坡.

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <algorithm>
#include <vector>
#include <cstring>
#include <stack>
#include <cctype>
#include <utility>   
#include <map>
#include <string>  
#include <climits> 
#include <set>
#include <string>    
#include <sstream>
#include <utility>   
#include <ctime>

using std::priority_queue;
using std::vector;
using std::swap;
using std::stack;
using std::sort;
using std::max;
using std::min;
using std::pair;
using std::map;
using std::string;
using std::cin;
using std::cout;
using std::set;
using std::queue;
using std::string;
using std::istringstream;
using std::make_pair;
using std::getline;
using std::greater;
using std::endl;
using std::multimap;
using std::deque;

typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PAIR;
typedef multimap<int, int> MMAP;

const int MAXN(10);
const int SIGMA_SIZE(2);
const int MAXM(110);
const int MAXE(300010);
const int MAXH(18);
const int INFI((INT_MAX-1) >> 1);
const int MOD(1000000007);
const ULL LIM(1000000000000000ull);

bool vis[25][8][10];
int table[25][8][10];
int digitlow[25], digitup[25];

int dfs(int len, int state, int pre, bool lowbound, bool upbound)
{
    if(state == 0 && len < 6)
        return -1;
    if(len == 0)
        return state == 5? 0: -1;
    if(!lowbound && !upbound && vis[len][state][pre])
        return table[len][state][pre];
    int low = lowbound? digitlow[len] : 0, up = upbound? digitup[len]: 9;
    int ret = -1;
    for(int i = low; i <= up; ++i)
    {
        int temp;
        switch(state)
        {
        case 0: temp = dfs(len-1, (i == 0? 0: 1), i, lowbound && i == low, upbound && i == up);
                if(temp != -1)
                    ret = max(ret, temp+i);
                break;
        case 1: if(i > pre)
                {
                    temp = dfs(len-1, 1, i, lowbound && i == low, upbound && i == up);
                    if(temp != -1)
                        ret = max(ret, temp+i);
                    temp = dfs(len-1, 2, i, lowbound && i == low, upbound && i == up);
                    if(temp != -1)
                        ret = max(ret, temp+i);
                }
                break;
        case 2: if(i < pre)
                {
                    temp = dfs(len-1, 3, i, lowbound && i == low, upbound && i == up);
                    if(temp != -1)
                        ret = max(ret, temp+i);
                }
                break;
        case 3: if(i < pre)
                {
                    temp = dfs(len-1, 3, i, lowbound && i == low, upbound && i == up);
                    if(temp != -1)
                        ret = max(ret, temp+i);
                }
                if(i != 0)
                {
                    temp = dfs(len-1, 4, i, lowbound && i == low, upbound && i == up);
                    if(temp != -1)
                        ret = max(ret, temp+i);
                }
                break;
        case 4: if(i > pre)
                {
                    temp = dfs(len-1, 4, i, lowbound && i == low, upbound && i == up);
                    if(temp != -1)
                        ret = max(ret, temp+i);
                    temp = dfs(len-1, 5, i, lowbound && i == low, upbound && i == up);
                    if(temp != -1)
                        ret = max(ret, temp+i);
                }
                break;
        case 5:    if(i < pre)
                {
                    temp = dfs(len-1, 5, i, lowbound && i == low, upbound && i == up);
                    if(temp != -1)
                        ret = max(ret, temp+i);
                }
                break;
        }
    }
    if(!lowbound && !upbound)
    {
        vis[len][state][pre] = true;
        table[len][state][pre] = ret;
    }
    return ret;
}

int fun(ULL numlow, ULL numup)
{
    int len1, len2;
    len1 = 1;
    while(true)
    {
        digitlow[len1] = numlow%10;
        numlow /= 10;
        if(numlow == 0)
            break;
        ++len1;
    }
    len2 = 1;
    while(true)
    {
        digitup[len2] = numup%10;
        numup /= 10;
        if(numup == 0)
            break;
        ++len2;
    }
    for(int i = len1+1; i <= len2; ++i)
        digitlow[i] = 0;
    return dfs(len2, 0, 0, true, true);
}

int main()
{
    int TC, n_case(0);
    scanf("%d", &TC);
    while(TC--)
    {
        ULL n1, n2;
        scanf("%I64u%I64u", &n1, &n2);
        printf("Case %d: ", ++n_case);
        int ans = fun(n1, n2);
        printf("%d\n", ans == -1? 0: ans);
    }
    return 0;
}


hdoj 3943

数位DP+二分或构造

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <algorithm>
#include <vector>
#include <cstring>
#include <stack>
#include <cctype>
#include <utility>   
#include <map>
#include <string>  
#include <climits> 
#include <set>
#include <string>    
#include <sstream>
#include <utility>   
#include <ctime>

using std::priority_queue;
using std::vector;
using std::swap;
using std::stack;
using std::sort;
using std::max;
using std::min;
using std::pair;
using std::map;
using std::string;
using std::cin;
using std::cout;
using std::set;
using std::queue;
using std::string;
using std::istringstream;
using std::make_pair;
using std::getline;
using std::greater;
using std::endl;
using std::multimap;
using std::deque;

typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PAIR;
typedef multimap<int, int> MMAP;

const int MAXN(10);
const int SIGMA_SIZE(2);
const int MAXM(110);
const int MAXE(300010);
const int MAXH(18);
const int INFI((INT_MAX-1) >> 1);
const int MOD(1000000007);
const ULL LIM(1000000000000000ull);

bool vis[25][22][22];
ULL table[25][22][22];
int digit[25];
int X, Y;

ULL dfs(int len, int qua1, int qua2, bool bound)
{
    if(len == 0)
        return X == qua1 && Y == qua2? 1: 0;
    if(!bound && vis[len][qua1][qua2])
        return table[len][qua1][qua2];
    int up = bound? digit[len]: 9;
    ULL ret = 0;
    for(int i = 0; i <= up; ++i)
    {
        int t1 = qua1+(i == 4? 1: 0), t2 = qua2+(i == 7? 1: 0);
        if(t1 > X || t2 > Y)
            continue;
        ret += dfs(len-1, t1, t2, bound && i == up);
    }
    if(!bound)
    {
        vis[len][qua1][qua2] = true;
        table[len][qua1][qua2] = ret;
    }
    return ret;
}

ULL fun(ULL num)
{
    int len = 1;
    while(true)
    {
        digit[len] = num%10;
        num /= 10;
        if(num == 0)
            break;
        ++len;
    }
    return dfs(len, 0, 0, true);
}

int main()
{
    int TC, n_case(0);
    scanf("%d", &TC);
    while(TC--)
    {
        ULL P, Q;
        scanf("%I64u%I64u%d%d", &P, &Q, &X, &Y);
        memset(vis, 0, sizeof(vis));
        ULL limit = fun(P);
        int n;
        scanf("%d", &n);
        printf("Case #%d:\n", ++n_case);
        for(int i = 0; i < n; ++i)
        {
            ULL l = P+1, r = Q+1, K;
            scanf("%I64u", &K);
            while(l < r)
            {
                ULL m = l+(r-l)/2;
                if(fun(m)-limit < K)
                    l = m+1;
                else
                    r = m;
            }
            if(l == Q+1)
                printf("Nya!\n");
            else
                printf("%I64u\n", l);
        }
    }
    return 0;
}

hdoj 4389

table[len][i][j][k]表示剩余len位，f(x) = i，已经生成的前缀位%f(x)=j,生成的前缀位的数位和为k最后可以生成的合法数字个数.

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <algorithm>
#include <vector>
#include <cstring>
#include <stack>
#include <cctype>
#include <utility>   
#include <map>
#include <string>  
#include <climits> 
#include <set>
#include <string>    
#include <sstream>
#include <utility>   
#include <ctime>

using std::priority_queue;
using std::vector;
using std::swap;
using std::stack;
using std::sort;
using std::max;
using std::min;
using std::pair;
using std::map;
using std::string;
using std::cin;
using std::cout;
using std::set;
using std::queue;
using std::string;
using std::istringstream;
using std::make_pair;
using std::getline;
using std::greater;
using std::endl;
using std::multimap;
using std::deque;

typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PAIR;
typedef multimap<int, int> MMAP;

const int MAXN(10);
const int SIGMA_SIZE(2);
const int MAXM(110);
const int MAXE(300010);
const int MAXH(18);
const int INFI((INT_MAX-1) >> 1);
const int MOD(1000000007);
const ULL LIM(1000000000000000ull);

int table[15][82][82][82];
int reg;
int digit1[15], digit2[15];

int dfs(int len, int divide, int presum, bool lowbound, bool upbound)
{
    if(len == 0)
        return divide == 0 && presum == reg? 1: 0;
    if(!upbound && !lowbound && table[len][reg][divide][presum] != -1)
        return table[len][reg][divide][presum];
    int up = upbound? digit2[len]: 9, low = lowbound? digit1[len]: 0;
    int ret = 0;
    for(int i = low; i <= up; ++i)
        ret += dfs(len-1, (divide*10+i)%reg, presum+i, lowbound && i == low, upbound && i == up);
    if(!upbound && !lowbound)
        table[len][reg][divide][presum] = ret;
    return ret;
}

int fun(int num1, int num2)
{
    int len1 = 1;
    while(true)
    {
        digit1[len1] = num1%10;
        num1 /= 10;
        if(num1 == 0)
            break;
        ++len1;
    }
    int len2 = 1;
    while(true)
    {
        digit2[len2] = num2%10;
        num2 /= 10;
        if(num2 == 0)
            break;
        ++len2;
    }
    for(int i = len1+1; i <= len2; ++i)
        digit1[i] = 0;
    int ret = 0;
    for(int i = 1; i <= 81; ++i)
    {
        reg = i;
        ret += dfs(len2, 0, 0, true, true);
    }
    return ret;
}

int main()
{
    memset(table, -1, sizeof(table));
    int TC, n_case(0);
    scanf("%d", &TC);
    while(TC--)
    {
        int a, b;
        scanf("%d%d", &a, &b);
        printf("Case %d: %d\n", ++n_case, fun(a, b));
    }
    return 0;
}

Codeforces 55D. Beautiful numbers 

很明显的数位DP，但状态不好设计，开始想了一种很暴力的状态

table[len][state][r9][r8][r7][r6][r5][r4][r3][r2],表示剩余len位时，(1,2,...9)访问状态为state，已生成的前缀位%i = ri，最后可以得到的合法数字个数，但这复杂度O(18*256*9*8*7*6*5*4*3*2*9)太可观了。。。

后来发现状态r6,r4,r3,r2不是必要的，最后可以由其他状态推出来，可以省略掉,于是复杂度变成了O(18*256*9*8*7*5*9)，还是略高，写好后交上去试了一下，3秒卡过


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <algorithm>
#include <vector>
#include <cstring>
#include <stack>
#include <cctype>
#include <utility>   
#include <map>
#include <string>  
#include <climits> 
#include <set>
#include <string>    
#include <sstream>
#include <utility>   
#include <ctime>

using std::priority_queue;
using std::vector;
using std::swap;
using std::stack;
using std::sort;
using std::max;
using std::min;
using std::pair;
using std::map;
using std::string;
using std::cin;
using std::cout;
using std::set;
using std::queue;
using std::string;
using std::istringstream;
using std::make_pair;
using std::getline;
using std::greater;
using std::endl;
using std::multimap;
using std::deque;

typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PAIR;
typedef multimap<int, int> MMAP;

const int MAXN(10);
const int SIGMA_SIZE(2);
const int MAXM(110);
const int MAXE(300010);
const int MAXH(18);
const int INFI((INT_MAX-1) >> 1);
const int MOD(1000000007);
const ULL LIM(1000000000000000ull);

LL table[19][1 << 8][9][8][7][5];
int digit1[20], digit2[20];

LL dfs(int len, int state, int rem9, int rem8, int rem7, int rem5, bool lowbound, bool upbound)
{
	if(len == 0)
	{
		if((state&(1 << 7)) && rem9)
			return 0;
		if((state&(1 << 6)) && rem8)
			return 0;
		if((state&(1 << 5)) && rem7)
			return 0;
		if((state&(1 << 4)) && (rem9%3 || rem8%2))
			return 0;
		if((state&(1 << 3)) && rem5)
			return 0;
		if((state&(1 << 2)) && rem8%4)
			return 0;
		if((state&(1 << 1)) && rem9%3)
			return 0;
		if((state&(1 << 0)) && rem8%2)
			return 0;
		return 1;
	}
	if(!lowbound && !upbound && table[len][state][rem9][rem8][rem7][rem5] != -1)
		return table[len][state][rem9][rem8][rem7][rem5];
	int low = lowbound? digit1[len]: 0, up = upbound? digit2[len]: 9;
	LL ret = 0;
	for(int i = low; i <= up; ++i)
		ret += dfs(len-1, (i >= 2? state|(1 << (i-2)): state), (rem9*10+i)%9, (rem8*10+i)%8, (rem7*10+i)%7, (rem5*10+i)%5, lowbound && i == low, upbound && i == up);
	if(!lowbound && !upbound)
		table[len][state][rem9][rem8][rem7][rem5] = ret;
	return ret;
}

LL fun(LL num1, LL num2)
{
	int len1 = 1;
	while(true)
	{
		digit1[len1] = num1%10;
		num1 /= 10;
		if(num1 == 0)
			break;
		++len1;
	}
	int len2 = 1;
	while(true)
	{
		digit2[len2] = num2%10;
		num2 /= 10;
		if(num2 == 0)
			break;
		++len2;
	}
	for(int i = len1+1; i <= len2; ++i)
		digit1[i] = 0;
	return dfs(len2, 0, 0, 0, 0, 0, true, true);
}

int main()
{
	memset(table, -1, sizeof(table));
	int TC;
	scanf("%d", &TC);
	while(TC--)
	{
		LL a, b;
		scanf("%I64d%I64d", &a, &b);
		printf("%I64d\n", fun(a, b));
	}
	return 0;
}

然后就是看题解了，其中应用了俩个性质

1   a = k*b,  则 (n%a)%b = n%b

2   如果 n如果能被 any(a1, a2, ...ak)整除,则有n能被lcm(a1, a2, ...ak)整除

因为lcm(2, 3, 4,...9) = 2520，所以应用这俩个性质就可以设计出一个不错的状态了

table[len][lc][k]表示剩余len位，前缀数位的lcm为lc，生成的前缀%2520为k最后可以得到的合法数字个数

看上去复杂度O(18*2520*2520*9)还是很高，但实际上由于2520的约数个数只有49个，所以lc可以的取值只有49个

这样复杂度就变成了O(18*49*2520*9)，空间也可以用离散化压缩,嗯，这样就可以接受了。

题解上还给了一种更加优化的方法，但还不是很理解(果然数学是硬伤%>_<%)。


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <algorithm>
#include <vector>
#include <cstring>
#include <stack>
#include <cctype>
#include <utility>   
#include <map>
#include <string>  
#include <climits> 
#include <set>
#include <string>    
#include <sstream>
#include <utility>   
#include <ctime>

using std::priority_queue;
using std::vector;
using std::swap;
using std::stack;
using std::sort;
using std::max;
using std::min;
using std::pair;
using std::map;
using std::string;
using std::cin;
using std::cout;
using std::set;
using std::queue;
using std::string;
using std::istringstream;
using std::make_pair;
using std::getline;
using std::greater;
using std::endl;
using std::multimap;
using std::deque;

typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PAIR;
typedef multimap<int, int> MMAP;

const int MAXN(10);
const int SIGMA_SIZE(2);
const int MAXM(110);
const int MAXE(300010);
const int MAXH(18);
const int INFI((INT_MAX-1) >> 1);
const int MOD(2520);
const ULL LIM(1000000000000000ull);

LL table[20][50][2521];
int digit1[20], digit2[20];
int h[2521];

LL gcd(LL a, LL b)
{
	LL temp;
	while(b)
	{
		temp = a%b;
		a = b;
		b = temp;
	}
	return a;
}

LL lcm(LL a, LL b)
{
	return a/gcd(a, b)*b;
}

LL dfs(int len, int lc, int rem, bool lowbound, bool upbound)
{
	if(len == 0)
		return rem%lc? 0: 1;
	if(!lowbound && !upbound && table[len][h[lc]][rem] != -1)
		return table[len][h[lc]][rem];
	int low = lowbound? digit1[len]: 0, up = upbound? digit2[len]: 9;
	LL ret = 0;
	for(int i = low; i <= up; ++i)
		ret += dfs(len-1, i == 0? lc: lcm(lc, i), (rem*10+i)%MOD, lowbound && i == low, upbound && i == up);
	if(!lowbound && !upbound)
		table[len][h[lc]][rem] = ret;
	return ret;
}

LL fun(LL num1, LL num2)
{
	int len1 = 1;
	while(true)
	{
		digit1[len1] = num1%10;
		num1 /= 10;
		if(num1 == 0)
			break;
		++len1;
	}
	int len2 = 1;
	while(true)
	{
		digit2[len2] = num2%10;
		num2 /= 10;
		if(num2 == 0)
			break;
		++len2;
	}
	for(int i = len1+1; i <= len2; ++i)
		digit1[i] = 0;
	return dfs(len2, 1, 0, true, true);
}

int main()
{
	int count = 0;
	for(int i = 1; i <= 2520; ++i)
		if(2520%i == 0)
			h[i] = count++;
	memset(table, -1, sizeof(table));
	int TC;
	scanf("%d", &TC);
	while(TC--)
	{
		LL a, b;
		scanf("%I64d%I64d", &a, &b);
		printf("%I64d\n", fun(a, b));
	}
	return 0;
}

CODECHEF 

Favourite Numbers

AC自动机+数位DP 

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <algorithm>
#include <vector>
#include <cstring>
#include <stack>
#include <cctype>
#include <utility>   
#include <map>
#include <string>  
#include <climits> 
#include <set>
#include <string>    
#include <sstream>
#include <utility>   
#include <ctime>
 
using std::priority_queue;
using std::vector;
using std::swap;
using std::stack;
using std::sort;
using std::max;
using std::min;
using std::pair;
using std::map;
using std::string;
using std::cin;
using std::cout;
using std::set;
using std::queue;
using std::string;
using std::istringstream;
using std::make_pair;
using std::getline;
using std::greater;
using std::endl;
using std::multimap;
using std::deque;
 
typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PAIR;
typedef multimap<int, int> MMAP;
 
const int MAXN(1410);
const int SIGMA_SIZE(10);
const int MAXM(110);
const int MAXE(300010);
const int MAXH(18);
const int INFI((INT_MAX-1) >> 1);
const int MOD(2520);
const ULL LIM(1000000000000000ull);
 
struct AC
{
	int ch[MAXN][SIGMA_SIZE], f[MAXN];
	int val[MAXN];
	int size;
	inline int idx(char temp)
	{
		return temp-'0';
	}
	void init()
	{
		memset(ch[0], 0, sizeof(ch[0]));
		val[0] = 0;
		size = 1;
	}
 
	void insert(char *S)
	{
		int u = 0, id;
		for(; *S; ++S)
		{
			id = idx(*S);
			if(!ch[u][id])
			{
				memset(ch[size], 0, sizeof(ch[size]));
				val[size] = false;
				ch[u][id] = size++;
			}
			u = ch[u][id];
		}
		val[u] = 1;
	}
 
	int que[MAXN];
	int front, back;
	void construct()
	{
		int cur, u;
		front = back = 0;
		for(int i = 0; i < SIGMA_SIZE; ++i)
			if(ch[0][i])
			{
				u = ch[0][i];
				f[u] = 0;
				que[back++] = u;
			}
		while(front < back)
		{
			cur = que[front++];
			for(int i = 0; i < SIGMA_SIZE; ++i)
			{
				u = ch[cur][i];
				if(u)
				{
					f[u] = ch[f[cur]][i];
					val[u] |= val[f[u]];
					que[back++] = u;
				}
				else
					ch[cur][i] = ch[f[cur]][i];
			}
		}
	}
};
 
AC ac;
 
LL table[20][MAXN][2];
int digit1[20], digit2[20];
 
LL dfs(int len, int u, int flag, bool lowbound, bool upbound, bool zero)
{
	if(len == 0)
		return flag? 1: 0;
	if(!lowbound && !upbound && !zero && table[len][u][flag] != -1)
		return table[len][u][flag];
	int low = lowbound? digit1[len]: 0, up = upbound? digit2[len]: 9;
	LL ret = 0;
	for(int i = low; i <= up; ++i)
		if(zero && i == 0 && len > 1)
			ret += dfs(len-1, 0, flag, lowbound && i == low, upbound && i == up, true);
		else
			ret += dfs(len-1, ac.ch[u][i], flag|(ac.val[ac.ch[u][i]]), lowbound && i == low, upbound && i == up, zero && i == 0);
	if(!lowbound && !upbound && !zero)
		table[len][u][flag] = ret;
	return ret;
}
 
LL fun(LL num1, LL num2)
{
	int len1 = 1;
	while(true)
	{
		digit1[len1] = num1%10;
		num1 /= 10;
		if(num1 == 0)
			break;
		++len1;
	}
	int len2 = 1;
	while(true)
	{
		digit2[len2] = num2%10;
		num2 /= 10;
		if(num2 == 0)
			break;
		++len2;
	}
	for(int i = len1+1; i <= len2; ++i)
		digit1[i] = 0;
	return dfs(len2, 0, 0, true, true, true);
}
 
char str[20];
 
int main()
{
	LL a, b, K;
	int n;
	while(cin >> a >> b >> K >> n)
	{
		ac.init();
		for(int i = 0; i < n; ++i)
		{
			cin >> str;
			ac.insert(str);
		}
		ac.construct();
		memset(table, -1, sizeof(table));
		LL l = a, r = b+1;
		while(l < r)
		{
			LL m = l+(r-l)/2;
			if(fun(a, m) < K)
				l = m+1;
			else
				r = m;
		}
		if(l == b+1)
			cout << "no such number\n";
		else
			cout << l << "\n";
	}	
	return 0;
}

Fast Bit Calculations lightoj 1032 

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <algorithm>
#include <vector>
#include <cstring>
#include <stack>
#include <cctype>
#include <utility>   
#include <map>
#include <string>  
#include <climits> 
#include <set>
#include <string>    
#include <sstream>
#include <utility>   
#include <ctime>

using std::priority_queue;
using std::vector;
using std::swap;
using std::stack;
using std::sort;
using std::max;
using std::min;
using std::pair;
using std::map;
using std::string;
using std::cin;
using std::cout;
using std::set;
using std::queue;
using std::string;
using std::istringstream;
using std::make_pair;
using std::getline;
using std::greater;
using std::endl;
using std::multimap;
using std::deque;

typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PAIR;
typedef multimap<int, int> MMAP;

const int MAXN(200010);
const int MAXM(10010);
const int MAXE(10010);
const int MAXH(19);
const int INFI(2000000000);
const int MOD(1000000007);
const ULL BASE(31);
const LL LIM(10000000);
const int INV(-10000);

LL table[33][33][2];
int digit1[33], digit2[33];

LL dfs(int len, int presum, int flag, bool lowbound, bool upbound)
{
	if(len == 0)
		return presum;
	if(!lowbound && !upbound && table[len][presum][flag] != -1)
		return table[len][presum][flag];
	int low = lowbound? digit1[len]: 0, up = upbound? digit2[len]: 1;
	LL ret = 0;
	for(int i = low; i <= up; ++i)
		ret += dfs(len-1, presum+(i&flag), i, lowbound && i == low, upbound && i == up);
	if(!lowbound && !upbound)
		table[len][presum][flag] = ret;
	return ret;
}

LL fun(int num1, int num2)
{
	int len1 = 1;
	while(true)
	{
		digit1[len1] = num1&1;
		num1 >>= 1;
		if(num1 == 0)
			break;
		++len1;
	}
	int len2 = 1;
	while(true)
	{
		digit2[len2] = num2&1;
		num2 >>= 1;
		if(num2 == 0)
			break;
		++len2;
	}
	for(int i = len1+1; i <= len2; ++i)
		digit1[i] = 0;
	return dfs(len2, 0, 0, true, true);
}

int main()
{
	memset(table, -1, sizeof(table));
	int TC, n_case(0);
	scanf("%d", &TC);
	while(TC--)
	{
		int n;
		scanf("%d", &n);
		printf("Case %d: %lld\n", ++n_case, fun(0, n));
	}
	return 0;
}



BALNUM spoj10606


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <algorithm>
#include <vector>
#include <cstring>
#include <stack>
#include <cctype>
#include <utility>   
#include <map>
#include <string>  
#include <climits> 
#include <set>
#include <string>    
#include <sstream>
#include <utility>   
#include <ctime>

using std::priority_queue;
using std::vector;
using std::swap;
using std::stack;
using std::sort;
using std::max;
using std::min;
using std::pair;
using std::map;
using std::string;
using std::cin;
using std::cout;
using std::set;
using std::queue;
using std::string;
using std::stringstream;
using std::make_pair;
using std::getline;
using std::greater;
using std::endl;
using std::multimap;
using std::deque;

typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PAIR;
typedef multimap<int, int> MMAP;

const int MAXN(1510);
const int MAXM(5010);
const int MAXE(10010);
const int HSIZE(13131);
const int SIGMA_SIZE(26);
const int MAXH(19);
const int INFI((INT_MAX-1) >> 1);
const ULL BASE(31);
const LL LIM(10000000);
const int INV(-10000);

int hash[1024][1024];
LL table[21][60010];
int lowdig[21], updig[21];

LL dfs(int len, int state1, int state2, bool zero, bool lowbound, bool upbound)
{
	if(len == 0)
	{
		for(int i = 0; i <= 9; ++i)
			if((state1&(1 << i)) && ((state2&(1 << i))^((i&1) << i)) == 0)
				return 0;
		return 1;
	}
	if(!zero && !lowbound && !upbound && table[len][hash[state1][state2]] != -1)
		return table[len][hash[state1][state2]];
	int low = lowbound? lowdig[len]: 0;
	int up = upbound? updig[len]: 9;
	LL temp = 0;
	for(int i = low; i <= up; ++i)
		if(zero && i == 0)
			temp += dfs(len-1, state1, state2, true, lowbound && i == low, upbound && i == up);
		else
			temp += dfs(len-1, state1|(1 << i),  state2^(1 << i), false, lowbound && i == low, upbound && i == up);
	if(!zero && !lowbound && !upbound)
		table[len][hash[state1][state2]] = temp;
	return temp;
}

LL fun(ULL l, ULL u)
{
	int len1 = 1;
	while(true)
	{
		lowdig[len1] = l%10;
		l /= 10;
		if(!l)
			break;
		++len1;
	}
	int len2 = 1;
	while(true)
	{
		updig[len2] = u%10;
		u /= 10;
		if(!u)
			break;
		++len2;
	}
	for(int i = len1+1; i <= len2; ++i)
		lowdig[i] = 0;
	return dfs(len2, 0, 0, true, true, true);
}

int main()
{
	int cnt = 0;
	for(int i = 0; i < 1024; ++i)
		for(int j = 0; j < 1024; ++j)
		{
			bool flag(true);
			for(int k = 0; k <= 9; ++k)
				if(!(i&(1 << k)) && (j&(1 << k)))
				{
					flag = false;
					break;
				}
			if(flag) hash[i][j] = cnt++;
		}
	memset(table, -1, sizeof(table));
	int TC;
	scanf("%d", &TC);
	ULL a, b;
	while(TC--)
	{
		scanf("%llu%llu", &a, &b);
		printf("%lld\n", fun(a, b));
	}
	return 0;
}

俩个回文数字题:

需要注意的是回文定义的状态还有无后效性(只对数字的前一半进行DP)

poj2402

http://poj.org/problem?id=2402

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <algorithm>
#include <vector>
#include <cstring>
#include <stack>
#include <cctype>
#include <utility>   
#include <map>
#include <string>  
#include <climits> 
#include <set>
#include <string>    
#include <sstream>
#include <utility>   
#include <ctime>
#include <bitset>
#include <iomanip>
//#pragma comment(linker, "/STACK:102400000,102400000")

using std::priority_queue;
using std::vector;
using std::swap;
using std::stack;
using std::sort;
using std::max;
using std::min;
using std::pair;
using std::map;
using std::string;
using std::cin;
using std::cout;
using std::set;
using std::queue;
using std::string;
using std::stringstream;
using std::make_pair;
using std::getline;
using std::greater;
using std::endl;
using std::multimap;
using std::deque;
using std::unique;
using std::lower_bound;
using std::random_shuffle;
using std::bitset;
using std::upper_bound;
using std::multiset;
using std::ios;
using std::make_heap;
using std::push_heap;
using std::pop_heap;

typedef long long LL;
typedef unsigned long long ULL;
typedef unsigned UN;
typedef pair<ULL, ULL> PAIR;
typedef multimap<int, int> MMAP;
typedef long double LF;

const int MAXN(1510);
const int MAXM(40010);
const int MAXE(10010);
const int MAXK(6);
const int HSIZE(13131);
const int SIGMA_SIZE(26+11);
const int MAXH(18);
const int INFI((INT_MAX-1) >> 1);
const ULL BASE(31);
const LL LIM(1e13);
const int INV(-10000);
const int MOD(1000000007);
const double EPS(1e-7);
const LF PI(acos(-1.0));

template<typename T> inline bool checkmax(T &a, T b){if(b > a) { a = b; return true;} return false;}
template<typename T> inline bool checkmin(T &a, T b){if(b < a) { a = b; return true;} return false;}
template<typename T> inline T ABS(T a){return a < 0? -a: a;}
template<typename T> inline bool EZ(T a){return ABS(a) < EPS;}

LL dp[20][20];
int dig[20], tdig[20];
LL dfs(int len, int tl, bool bound, bool zero)
{
	if(len+1 == tl/2)   //通过前一半可以得出结果
	{
		if(!zero && !bound) return 1;
		int add = (tl&1)? 2: 1;
		for(int i = 0; i <= len; ++i) tdig[len-i] = tdig[len+i+add];
		for(int i = len; i >= 0; --i)
		{
			if(tdig[i] < dig[i]) return 1;
			if(tdig[i] > dig[i]) return 0;
		}
		return 1;
	}
	if(!zero && !bound && dp[len][tl] != -1) return dp[len][tl];
	int up = bound? dig[len]: 9;
	LL ret = 0;
	for(int i = 0; i <= up; ++i)
	{
		tdig[len] = i;
		ret += dfs(len-1, tl? tl: (zero && i == 0? 0: len+1), bound && i == up, zero && i == 0);
	}
	if(!zero && !bound && len+1 > tl/2) dp[len][tl] = ret; //只对前一半dp
	return ret;
}

LL fun(LL n)
{
	int len = 0;
	while(true)
	{
		dig[len] = n%10;
		n /= 10;
		if(n == 0) break;
		++len;
	}
	return dfs(len, 0, true, true)-1;
}

int main()
{
	int n;
	memset(dp, -1, sizeof(dp));
	while(scanf("%d", &n), n)
	{
		LL lo = 1, hi = 1LL << 62;
		while(lo < hi)
		{
			LL mi = lo+(hi-lo)/2;
			if(fun(mi) < n) lo = mi+1;
			else hi = mi;
		}
		printf("%I64d\n", lo);
	}
	return 0;
}

uestc1191

http://acm.uestc.edu.cn/problem.php?pid=1191

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <algorithm>
#include <vector>
#include <cstring>
#include <stack>
#include <cctype>
#include <utility>   
#include <map>
#include <string>  
#include <climits> 
#include <set>
#include <string>    
#include <sstream>
#include <utility>   
#include <ctime>
#include <bitset>
#include <iomanip>
//#pragma comment(linker, "/STACK:102400000,102400000")

using std::priority_queue;
using std::vector;
using std::swap;
using std::stack;
using std::sort;
using std::max;
using std::min;
using std::pair;
using std::map;
using std::string;
using std::cin;
using std::cout;
using std::set;
using std::queue;
using std::string;
using std::stringstream;
using std::make_pair;
using std::getline;
using std::greater;
using std::endl;
using std::multimap;
using std::deque;
using std::unique;
using std::lower_bound;
using std::random_shuffle;
using std::bitset;
using std::upper_bound;
using std::multiset;
using std::ios;
using std::make_heap;
using std::push_heap;
using std::pop_heap;

typedef long long LL;
typedef unsigned long long ULL;
typedef unsigned UN;
typedef pair<ULL, ULL> PAIR;
typedef multimap<int, int> MMAP;
typedef long double LF;

const int MAXN(1510);
const int MAXM(40010);
const int MAXE(10010);
const int MAXK(6);
const int HSIZE(13131);
const int SIGMA_SIZE(26+11);
const int MAXH(18);
const int INFI((INT_MAX-1) >> 1);
const ULL BASE(31);
const LL LIM(1e13);
const int INV(-10000);
const int MOD(1000000007);
const double EPS(1e-7);
const LF PI(acos(-1.0));

template<typename T> inline bool checkmax(T &a, T b){if(b > a) { a = b; return true;} return false;}
template<typename T> inline bool checkmin(T &a, T b){if(b < a) { a = b; return true;} return false;}
template<typename T> inline T ABS(T a){return a < 0? -a: a;}
template<typename T> inline bool EZ(T a){return ABS(a) < EPS;}

LL dp[22][22];
int dig[22], tdig[22];
LL dfs(int len, int tl, bool bound, bool zero)
{
	if(len+1 == tl/2)
	{
		if(!zero && !bound) return 1;
		int add = (tl&1)? 2: 1;
		for(int i = 0; i <= len; ++i) tdig[len-i] = tdig[len+i+add];
		for(int i = len; i >= 0; --i)
		{
			if(tdig[i] < dig[i]) return 1;
			if(tdig[i] > dig[i]) return 0;
		}
		return 1;
	}
	if(!zero && !bound && dp[len][tl] != -1) return dp[len][tl];
	int up = bound? dig[len]: 9;
	LL ret = 0;
	for(int i = 0; i <= up; ++i)
	{
		tdig[len] = i;
		if(zero)
		{
			if(i != 0 && ((len+1)&1) == 0) continue;
			ret += dfs(len-1, i == 0? 0: len+1, bound && i == up, i == 0);
		}
		else
		{
			if(i == tdig[len+1]) continue;
			ret += dfs(len-1, tl, bound && i == up, false);
		}
	}
	if(!zero && !bound && len+1 > tl/2) dp[len][tl] = ret;
	return ret;
}

LL fun(ULL n)
{
	int len = 0;
	while(true)
	{
		dig[len] = n%10;
		n /= 10;
		if(n == 0) break;
		++len;
	}
	return dfs(len, 0, true, true);
}

int main()
{
	memset(dp, -1, sizeof(dp));
	int TC;
	scanf("%d", &TC);
	while(TC--)
	{
		ULL a, b;
		scanf("%llu%llu", &a, &b);
		LL re = fun(b)-(a? fun(a-1): 0);
		printf("%lld\n", re);
	}
	return 0;
}


gyarenas
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数位DP(包含例题和模板)
m0_51678367的博客
11-23 575
如上题所示意: f®-f(l-1)就是答案. 那么f(n)要怎么求呢? 先把n分解为m进制的l位.那么对于第i位来说,就只有0或者1,因为题目里面没有系数.如181818=242^424+212^121.而没有282828=242^424+3∗223*2^23∗22. 从最高位到最低位,那么对于第i位来说如果第i位>1那么第i位可以是0(组合数学,第i位下面的i-1位可以填k-last(已经填了的1的个数)个1,即C[i-1][k-last] (下标从1开始,若是从零开始就是C[i][k-last..
数位dp题集
GAUSS_CLB
07-18 459
ural1057  论文题，b进制转二进制，按二进制数位dp,符合题意的应当满足每位为0或1，例如3*****，就相当于111111，因为2和3开头的数必然不满足条件，因此相当于区间[000000,111111]. #include #include #include using namespace std; int dp[40][30]; int tot,bit[40]; void chan
【数位DP——题集及提示】
..
04-28 1212
4207 -- 【模拟试题】不要62    最简单数位DP 不解释 4600 -- 【模拟试题】迷信的黄学长   挺坑！注意有正反向两种连续，传递序列里是否有2,4这两个参数，另外还要传有没有连续，所以DFS到下一层时要写作  Is_four||i==4;   Is_two||i==8;    Is_continuous||((i==pre+2&&i==last+1)||(pre
动态规划之数位DP专题（附题目清单）
剑锋OI SharpSwordOI
12-14 765
动态规划之数位DP专题
数位dp算法详细图文解答
02-13
数位动态规划（Digital Dynamic Programming, 简称数位DP）是一种用于解决与数字的组成有关的问题的算法。它通常涉及到对数字的每一位进行操作，通过递推和记忆化搜索来优化计算效率。数位DP的核心思想是将问题分解...
数位DP.pdf
07-12
数位DP整理的模板和一些题目的题解。QAQ没钱下载资源了只好上传点东西。
数位DP入门
08-22
数位DP入门思想，包括详细的思考过程以及一些习题的讲解
数位dp——某次队内分享任务
07-21
数位动态规划(Digit Dynamic Programming, 简称数位DP)是一种在处理与数字相关的动态规划问题时，通过分析每个数字位上的状态来优化算法的技术。它通常用于解决涉及数字序列特性的数学问题，例如计数特定类型的数...
初探数位dp.pdf
09-16
lazycal的集训队报告：初探数位DP 以HDU 2089，HDU 3652, URAL 1057等题目为例，介绍了数位DP的算法
数位DP经典例题
king9666的博客
05-03 331
不要62 Time Limit: 1000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 66538 Accepted Submission(s): 26439 Problem Description 杭州人称那些傻乎乎粘嗒嗒的人为62（音：laoer）。 杭州交...
数位dp 例题
ZCY的博客
08-03 258
                                      不要62 Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 56059    Accepted Submission(s): 21685 Problem De...
数位dp例题
hutwuguangrong的博客
05-14 309
在了解数位dp之前，先来看一个问题： 求a~b中不包含49的数的个数. 0 < a、b < 2*10^9； 注意到n的数据范围非常大，暴力求解是不可能的，考虑dp,如果直接记录下数字，数组会开不起，该怎么办呢？要用到数位dp. 数位dp一般应用于：求出在给定区间[A,B]内，符合条件P(i)的数i的个数.条件P(i)一般与数的大小无关，而与数的组成有关. 这样，我们就要考...
数位dp例题——找数
LELElele01的博客
07-23 346
找数 题面 给你两个数L,R，请求出在区间[L,R]中，有多少个数符合十进制下任意相邻K位数字的值两两互不相同，数不足K位则取全部数位。 一看这道题我们就知道是数位dp，但有k位，果断跳过， 赛后：原来k这么小，2<=k<=5,… 警示：一定要看数据范围 显然我们对于k的情况暴力枚举即可 if(K==2){ if(i==d) continue; re...
数位dp练习题
UniverseofHK的博客
06-08 582
随便记录几个题， 防止连数位dp的思路都忘了，2333 数位dp 先将上限各位保存到num数组 从高位到低位dfs（暴力） 记忆化，优雅的暴力，否则就是O(n)的算法了，对单个数据也有很大的加速 pos为-1时以及记忆存在时可直接返回 关键：时刻记住判断条件，做到不重不漏 HDU 3652 B-number B-number Time Limit: 2000/1000 MS (Java/Oth...
数位DP训练 例题
qq_43710979的博客
05-11 218
前几天被数位DP搞崩了，开始重新学(......) ① HDU 3555 Bomb [http://acm.hdu.edu.cn/showproblem.php?pid=3555] Description：计算1~n之间的数中含有‘49’的数的个数 一种解法：记录之前‘49’是否出现和前一位数的状态，板子题 #include<cstdio> #include<cstring&gt...
数位DP总结（含有例题）
微风的博客
10-13 297
数位DP 说实话数位DP我曾经刷过，但也只是复制粘贴地刷过，没有真正理解，今年暑假的牛客多校中，我们队就碰见了这样一道题，我看见题就脱口而出“数位DP”算法的名字，可惜，然后就没后续，知道它能够解决什么样的问题做什么用其实并没有多大用，只有真正理解算法的核心才能够用在解决问题上 初见 SCOI2009 windy 数 这道可以说是数位DP的模板题 区间内相邻两个数位之差至少为 2 的正整数的个数 既没有繁杂的限制条件，要求也很简单就是个数，可以说这就是数位DP的本来模样 核心代码段 ll dfs(int
数位DP学习整理（数位DP看完这篇你就会了）
pursuit的博客
05-12 3万+
文章目录数位DP数位DP介绍数位DP解法数位DP经典例题例题1：度的数量例题2：计数问题例题3：数字游戏例题4：windy数数位DP总结 数位DP 数位DP介绍 数位DP往往都是这样的题型，给定一个闭区间[l,r][l,r][l,r]，让你求这个区间中满足某种条件的数的总数。而这个区间可能很大，简单的暴力代码如下： int ans=0; for(int i=l;i<=r;i++){ if(check(i))ans++; } 我们发现，若区间长度超过1e81e81e8，我们暴力枚举就会超时了，
数位dp总结 之 从入门到模板
热门推荐
努力
08-03 7万+
for(int i=le;i<=ri;i++) if(right(i)) ans++; 基础篇 数位dp是一种计数用的dp，一般就是要统计一个区间[le,ri]内满足一些条件数的个数。所谓数位dp，字面意思就是在数位上进行dp咯。数位还算是比较好听的名字，数位的含义：一个数有个位、十位、百位、千位......数的每一位就是数位啦！ 之所以要引入数位的概念完全就是为了dp。
数位DP详解：区间统计与C语言基础
"这篇资料主要介绍了C语言中的数位动态规划(DP)技术，用于解决区间统计类问题，特别是与数位相关的计算。文中通过不同的例题解释了数位DP的基本思想、方法，并提供了几个具体实例，如HDU2089等，帮助读者理解和应用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值