gyarenas

数位DP题集

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

入门题：

hdoj 2089

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include    
#include 
#include   
#include  
#include 
#include     
#include 
#include    
#include 

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 PAIR;
typedef multimap 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 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include    
#include 
#include   
#include  
#include 
#include     
#include 
#include    
#include 

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 PAIR;
typedef multimap 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 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include    
#include 
#include   
#include  
#include 
#include     
#include 
#include    
#include 

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 PAIR;
typedef multimap 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 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include    
#include 
#include   
#include  
#include 
#include     
#include 
#include    
#include 

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 PAIR;
typedef multimap 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 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include    
#include 
#include   
#include  
#include 
#include     
#include 
#include    
#include 

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 PAIR;
typedef multimap 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 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include    
#include 
#include   
#include  
#include 
#include     
#include 
#include    
#include 

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 PAIR;
typedef multimap 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 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include    
#include 
#include   
#include  
#include 
#include     
#include 
#include    
#include 

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 PAIR;
typedef multimap 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 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include    
#include 
#include   
#include  
#include 
#include     
#include 
#include    
#include 

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 PAIR;
typedef multimap 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 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include    
#include 
#include   
#include  
#include 
#include     
#include 
#include    
#include 

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 PAIR;
typedef multimap 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 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include    
#include 
#include   
#include  
#include 
#include     
#include 
#include    
#include 

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 PAIR;
typedef multimap 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 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include    
#include 
#include   
#include  
#include 
#include     
#include 
#include    
#include 

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 PAIR;
typedef multimap 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 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include    
#include 
#include   
#include  
#include 
#include     
#include 
#include    
#include 

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 PAIR;
typedef multimap 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

http://www.codechef.com/problems/FAVNUM

AC自动机+数位DP

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include    
#include 
#include   
#include  
#include 
#include     
#include 
#include    
#include 
 
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 PAIR;
typedef multimap 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 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include    
#include 
#include   
#include  
#include 
#include     
#include 
#include    
#include 

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 PAIR;
typedef multimap 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 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include    
#include 
#include   
#include  
#include 
#include     
#include 
#include    
#include 

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 PAIR;
typedef multimap 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 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include    
#include 
#include   
#include  
#include 
#include     
#include 
#include    
#include 
#include 
#include 
//#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 PAIR;
typedef multimap 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 inline bool checkmax(T &a, T b){if(b > a) { a = b; return true;} return false;}
template inline bool checkmin(T &a, T b){if(b < a) { a = b; return true;} return false;}
template inline T ABS(T a){return a < 0? -a: a;}
template 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 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include    
#include 
#include   
#include  
#include 
#include     
#include 
#include    
#include 
#include 
#include 
//#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 PAIR;
typedef multimap 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 inline bool checkmax(T &a, T b){if(b > a) { a = b; return true;} return false;}
template inline bool checkmin(T &a, T b){if(b < a) { a = b; return true;} return false;}
template inline T ABS(T a){return a < 0? -a: a;}
template 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;
}

你可能感兴趣的:(数学基础,动态规划)

每日算法&面试题，大厂特训二十八天——第二十天（树）肥学 ⚡算法题⚡面试题每日精进 java 算法数据结构
目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
代码随想录Day 41|动态规划之买卖股票问题，leetcode题目121. 买卖股票的最佳时机、122. 买卖股票的最佳时机Ⅱ、123. 买卖股票的最佳时机Ⅲ LluckyYH 动态规划 leetcode 算法数据结构
提示：DDU，供自己复习使用。欢迎大家前来讨论~文章目录买卖股票的最佳时机相关题目题目一：121.买卖股票的最佳时机解题思路：题目二：122.买卖股票的最佳时机II解题思路：题目三：123.买卖股票的最佳时机III解题思路总结买卖股票的最佳时机相关题目题目一：121.买卖股票的最佳时机[[121.买卖股票的最佳时机](https://leetcode.cn/problems/combination
后端开发刷题 | 把数字翻译成字符串（动态规划） jingling555 笔试题目动态规划 java 算法数据结构后端
描述有一种将字母编码成数字的方式：'a'->1,'b->2',...,'z->26'。现在给一串数字，返回有多少种可能的译码结果数据范围：字符串长度满足0=10&&num<=26){if(i==1){dp[i]+=1;}else{dp[i]+=dp[i-2];}}}returndp[nums.length()-1];}}
滑动窗口+动态规划 wniuniu_ 算法动态规划算法
前言：分析这个题目的时候，就知道要这两个线段要分开，但是要保证得到最优解，那么我们在选取第二根线段的时候，要保证我们第一根线段是左边最优解并且我们选的两根线段的右端点一定是我们的数组的点（贪心思想）classSolution{public:intmaximizeWin(vector&prizePositions,intk){intn=prizePositions.size();vectormx(n
【NO.72】LeetCode HOT 100—279. 完全平方数悬浮海 #LeetCode HOT 100 leetcode 算法 279.完全平方数
文章目录279.完全平方数解题方法：动态规划279.完全平方数给你一个整数n，返回和为n的完全平方数的最少数量。完全平方数是一个整数，其值等于另一个整数的平方；换句话说，其值等于一个整数自乘的积。例如，1、4、9和16都是完全平方数，而3和11不是。示例1：输入：n=12输出：3解释：12=4+4+4示例2：输入：n=13输出：2解释：13=4+9提示：1<=n<=104解题方法：动态规划动态规划
洛谷P2066 机器分配 summ1ts 算法动态规划
此题可用动态规划解决，首先进行阶段划分，可将解决问题的过程看作逐一为每家公司分配机器，因此按照已分配公司数量划分阶段，设变量i代表前i家公司。设计状态，设f[i][j]代表前i家公司分配j台设备能产生的最大盈利。确定决策为第i家公司分配多少设备，决策变量k范围0usingnamespacestd;inta[20][20],f[20][20],g[20][20];intn,m;voidprint(i
代码随想录算法训练营第46天 | LeetCode647.回文子串、 LeetCode516.最长回文子序列霸L 算法数据结构动态规划
目录LeetCode647.回文子串1.动态规划2.双指针法LeetCode516.最长回文子序列LeetCode647.回文子串给你一个字符串s，请你统计并返回这个字符串中回文子串的数目。回文字符串是正着读和倒过来读一样的字符串。子字符串是字符串中的由连续字符组成的一个序列。思路：在回溯系列也做过求给定字符串的所有回文子串，那里求的是所有的划分结果，这里统计的是回文子串的数目，但是因为回溯本质上
12312312 二进制掌控者 c++
c语言中的小小白-CSDN博客c语言中的小小白关注算法,c++,c语言,贪心算法,链表,mysql,动态规划,后端,线性回归,数据结构,排序算法领域.https://blog.csdn.net/bhbcdxb123?spm=1001.2014.3001.5343给大家分享一句我很喜欢我话：知不足而奋进，望远山而前行！！！铁铁们，成功的路上必然是孤独且艰难的，但是我们不可以放弃，远山就在前方，但我们
你知道什么是回调函数吗？二进制掌控者 #C语言专栏 c语言开发语言
c语言中的小小白-CSDN博客c语言中的小小白关注算法,c++,c语言,贪心算法,链表,mysql,动态规划,后端,线性回归,数据结构,排序算法领域.https://blog.csdn.net/bhbcdxb123?spm=1001.2014.3001.5343给大家分享一句我很喜欢我话：知不足而奋进，望远山而前行！！！铁铁们，成功的路上必然是孤独且艰难的，但是我们不可以放弃，远山就在前方，但我们
Leetcode面试经典150题-221.最大正方形鱼跃鹰飞数据结构与算法字节跳动高频面试题 leetcode 面试算法
解法都在代码里，不懂就留言或者私信classSolution{/**本题一看就是典型的动态规划，要找以每个点为右下角的正方形的面积，然后取最大的这个题要注意找规律，我找到的规律如下：1.以第一行为右下角的，因为正方形是边长相同的，所以第一行为右下角最大正方形只能是自己，自己是1就是1，不是1就是02.以第一列为右下角的也是一样。3.以普通位置为右下角的最大正方形，首先看自己是不是1，如果自己不是1
如何有效的学习AI大模型？ Python程序员罗宾学习人工智能语言模型自然语言处理架构
学习AI大模型是一个系统性的过程，涉及到多个学科的知识。以下是一些建议，帮助你更有效地学习AI大模型：基础知识储备：数学基础：学习线性代数、概率论、统计学和微积分等，这些是理解机器学习算法的数学基础。编程技能：掌握至少一种编程语言，如Python，因为大多数AI模型都是用Python实现的。理论学习：机器学习基础：了解监督学习、非监督学习、强化学习等基本概念。深度学习：学习神经网络的基本结构，如卷
【NO.5】LeetCode HOT 100—5. 最长回文子串悬浮海 #LeetCode HOT 100 leetcode 算法 5.最长回文子串
文章目录5.最长回文子串解题方法一：动态规划方法二：中心扩展5.最长回文子串5.最长回文子串给你一个字符串s，找到s中最长的回文子串。如果字符串的反序与原始字符串相同，则该字符串称为回文字符串。示例1：输入：s=“babad”输出：“bab”解释：“aba”同样是符合题意的答案。示例2：输入：s=“cbbd”输出：“bb”提示：1maxLength){maxLength=j-i+1;index=i
大二上学期详细学习计划学会沉淀。学习
本学习完成目标：项目：书籍：《mysql必知必会》《java核心技术卷》（暂时）加强JavaSE的学习，掌握Java核心Mysql+sql（把牛客上的那50道sql语句题写完）git+maven完成springboot项目（跟着黑马敲）对于每天的Java学习进行记录算法：刷题（多去刷cf上的题，每周15道）针对最近比赛薄弱的地方加强练习（图论，字符串，动态规划，搜索）cf先上1400，牛客和atc
群体遗传分析（一）#学习笔记 kangroomoon
哈温的遗传平衡定律是基础，费、莱、霍的群体遗传学是数学基础和理论框架，木村资生的中性进化论深化了自然选择的概念。中性学说认为：分子水平上的遗传变异在很大程度上是中性的，变异程度主要由突变速率和有效群体大小决定。（通过观察值和理论值之间的差异性测验中性进化假说）群体遗传多态性与结构分析Locus：遗传座位，在群体中通常包含多个allele：等位基因，即遗传多态性。大多数的新突变是由于geneticd
代码随想录算法训练营第三十九天| 62. 不同路径，63. 不同路径 II 零offer在手算法动态规划图论
62.不同路径搞清楚dp[i][j]的定义推导出公式遍历顺序，从左到右，从上到下dp的初始化动态规划中如何初始化很重要！|LeetCode：62.不同路径_哔哩哔哩_bilibili《代码随想录》算法公开课开讲啦！快来打卡！本期视频的文字讲解版在「代码随想录」刷题网站：programmercarl.comGithub：https://github.com/youngyangyang04/leetc
数学建模笔记——动态规划 liangbm3 数学建模笔记数学建模笔记动态规划 python 背包问题算法优化问题
数学建模笔记——动态规划动态规划1.模型原理2.典型例题2.1例1凑硬币2.2例2背包问题3.python代码实现3.1例13.2例2动态规划1.模型原理动态规划是运筹学的一个分支，通常用来解决多阶段决策过程最优化问题。动态规划的基本想法就是将原问题转换为一系列相互联系的子问题，然后通过逐层地推来求得最后的解。目前，动态规划常常出现在各类计算机算法竞赛或者程序员笔试面试中，在数学建模中出现的相对较
代码随想录训练营 Day38打卡动态规划 part06 322. 零钱兑换 279. 完全平方数 139. 单词拆分那一抹阳光多灿烂力扣动态规划动态规划算法 python 力扣
代码随想录训练营Day38打卡动态规划part06一、力扣322.零钱兑换给你一个整数数组coins，表示不同面额的硬币；以及一个整数amount，表示总金额。计算并返回可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回-1。你可以认为每种硬币的数量是无限的。示例：输入：coins=[1,2,5],amount=11输出：3解释：11=5+5+1题目中说每种硬币的数量是
代码随想录训练营 Day45打卡动态规划 part12 115. 不同的子序列 583. 两个字符串的删除操作 72. 编辑距离那一抹阳光多灿烂力扣动态规划动态规划算法 leetcode python
代码随想录训练营Day45打卡动态规划part12一、力扣115.不同的子序列给你两个字符串s和t，统计并返回在s的子序列中t出现的个数，结果需要对109+7取模。示例：输入：s=“rabbbit”,t=“rabbit”输出：3解释：如下所示,有3种可以从s中得到“rabbit”的方案。rabbbitrabbbitrabbbit确定dp数组的定义dp[i][j]表示s的前i个字符中子序列等于t的前
算法设计与分析期末复习题汇总 wisdom_zhe Java题库算法
文章目录1、选择题1.1选择题11.2选择题22、判断题2.1判断题12.2判断题23、填空题3.1算法填空3.2填空题24、简答题1、选择题1.1选择题11、下列不是动态规划算法基本步骤的是（A）。A、找出最优解的解空间B、构造最优解C、算出最优解D、定义最优解2、最大效益优先是（A）的一搜索方式。A、分支界限法B、动态规划法C、贪心法D、回溯法3、最长公共子序列算法利用的算法是（B）。A、分支
五一的成果王跃坤txdy
emm。。五一过了有意义的四天。原来简单的图论我也是可以搞出来的原来DFS放进图论真的会使难度变大原来BFS在没有出口的时候会以超指数的爆炸增长原来二叉树并不是很难原来哈希的速度远超数组原来动态规划滚动起来速度真的快原来栈是那么的有用，可惜来不及学了（遇到一个求化学方程式的算法题，我自己写了133行的字符串处理，原来用栈可以缩减3倍的代码）原来很多复杂的问题都可以拆解成很简单的问题比如我好像发现数
[01] 动态规划解题套路框架 _魔佃_
本文解决几个问题：动态规划是什么？解决动态规划问题有什么技巧？如何学习动态规划？刷题刷多了就会发现，算法技巧就那几个套路。所以本文放在第一章，来扒一扒动态规划的裤子，形成一套解决这类问题的思维框架，希望能够成为解决动态规划问题的一部指导方针。本文就来讲解该算法的基本套路框架，下面上干货。labuladong的算法小抄首先，动态规划问题的一般形式就是求最值。动态规划其实是运筹学的一种最优化方法，只不
【动态规划【hard】力扣1449. 数位成本和为目标值的最大数字 sjsjs11 动态规划动态规划 leetcode 算法
给你一个整数数组cost和一个整数target。请你返回满足如下规则可以得到的最大整数：给当前结果添加一个数位（i+1）的成本为cost[i]（cost数组下标从0开始）。总成本必须恰好等于target。添加的数位中没有数字0。由于答案可能会很大，请你以字符串形式返回。如果按照上述要求无法得到任何整数，请你返回“0”。示例1：输入：cost=[4,3,2,5,6,7,2,5,5],target=9
【每日一题】LeetCode 2708.一个小组的最大实力值（一次遍历、分类讨论、动态规划） Chase-Hart 算法 leetcode 动态规划算法数据结构 java
【每日一题】LeetCode2708.最大实力值小组（一次遍历、分类讨论、动态规划）题目描述给定一个整数数组nums，表示一个班级中所有学生在一次考试中的成绩。老师想从这个班级中选出一部分同学组成一个非空小组，使得这个小组的实力值最大。小组的实力值定义为小组中所有学生成绩的乘积。请返回老师创建的小组能得到的最大实力值。思路分析这个问题可以通过动态规划的思想来解决。我们需要维护两个变量，mn和mx，
几何分布的期望和方差公式推导_算法数学基础-统计学最基础之均值、方差、协方差、矩... weixin_39848097 几何分布的期望和方差公式推导均值定理六个公式概率论方差公式
我们天天都可以接触很多随机现象，比如每天的天气不一样气温是我们最直接的感受，我们很难预测明天的精确问题，但是这些随机现象又体现出了一定的规律性。比如上海7月份平均35度左右，冬天的平均温度在5度左右。所以35、5这些数字体现了某种稳定性。所以除了前面几章中讲到的分布律和概率密度函数可以表征随机变量外，还可以用一组数字来表达随机变量的一般特性。这就是我们今天要讲到的随机变量的数字特征。通过对数字特征
CTF 竞赛密码学方向学习路径规划 David Max CTF 学习笔记密码学 ctf 信息安全
目录计算机科学基础计算机科学概念的引入、兴趣的引导开发环境的配置与常用工具的安装WattToolkit（Steam++）、机场代理Scoop（Windows用户可选）常用Python库SageMathLinux小工具yafuOpenSSLMarkdown编程基础Python其他编程语言、算法与数据结构（可选）数学基础离散数学与抽象代数复杂性分析密码学的正式学习兴趣的培养做题小技巧系统学习需要了解并
深度学习算法，该如何深入，举例说明 liyy614 深度学习
深度学习算法的深入学习可以从理论和实践两个方面进行。理论上，深入理解深度学习需要掌握数学基础（如线性代数、概率论、微积分）、机器学习基础和深度学习框架原理。实践上，可以通过实现和优化深度学习模型来提升技能。理论深入数学基础线性代数：理解向量、矩阵、特征值和特征向量等，对于理解神经网络的权重和偏置矩阵至关重要。概率论：用于理解模型的不确定性，如Dropout等正则化技术。微积分：理解梯度下降等优化算
Java数据结构与算法：动态规划之斐波那契数列省赚客APP开发者@聚娃科技 java 动态规划代理模式
Java数据结构与算法：动态规划之斐波那契数列大家好，我是免费搭建查券返利机器人赚佣金就用微赚淘客系统3.0的小编。在这寒冷的季节里，让我们一同探讨Java中的动态规划，重点关注解决问题的经典代表之一——斐波那契数列。动态规划简介动态规划是一种解决问题的数学方法，通常用于优化递归算法。它通过将问题分解为子问题并保存它们的解，避免重复计算，从而提高算法效率。在动态规划的应用中，最常见的问题之一就是求
动态规划算法之最长公子序列详细解读（附带Java代码解读）南城花随雪。算法分析算法动态规划 java
最长公共子序列（LongestCommonSubsequence,LCS）问题是动态规划中另一个经典问题，广泛用于比较两个序列的相似度。它的目标是找到两个序列之间最长的公共子序列（不是连续的），使得这个子序列同时出现在两个序列中。1.问题定义给定两个序列X和Y，要找到它们的最长公共子序列，即一个序列Z，它同时是X和Y的子序列，且Z的长度最大。例如：对于序列X="ABCBDAB"和Y="BDCAB"
Leetcode：139. 单词拆分（C++） Cosmoshhhyyy LeetCode leetcode c++算法动态规划
目录问题描述：实现代码与解析：动态规划（完全背包）:原理思路：问题描述：给你一个字符串s和一个字符串列表wordDict作为字典。请你判断是否可以利用字典中出现的单词拼接出s。注意：不要求字典中出现的单词全部都使用，并且字典中的单词可以重复使用。示例1：输入:s="leetcode",wordDict=["leet","code"]输出:true解释:返回true因为"leetcode"可以由"l
力扣第213题“打家劫舍 II” 数据分析螺丝钉 LeetCode刷题与模拟面试面试算法 leetcode 经验分享 python
在本篇文章中，我们将详细解读力扣第213题“打家劫舍II”。通过学习本篇文章，读者将掌握如何使用动态规划来解决这一问题，并了解相关的复杂度分析和模拟面试问答。每种方法都将配以详细的解释，以便于理解。问题描述力扣第213题“打家劫舍II”描述如下：你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这一整条街的所有房屋都围成一圈，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的
ztree异步加载 3213213333332132 JavaScript Ajax json Web ztree
相信新手用ztree的时候,对异步加载会有些困惑，我开始的时候也是看了API花了些时间才搞定了异步加载，在这里分享给大家。我后台代码生成的是json格式的数据，数据大家按各自的需求生成，这里只给出前端的代码。设置setting，这里只关注async属性的配置 var setting = { //异步加载配置
thirft rpc 具体调用流程 BlueSkator 中间件 rpc thrift
Thrift调用过程中，Thrift客户端和服务器之间主要用到传输层类、协议层类和处理类三个主要的核心类，这三个类的相互协作共同完成rpc的整个调用过程。在调用过程中将按照以下顺序进行协同工作：（1）将客户端程序调用的函数名和参数传递给协议层（TProtocol），协议
异或运算推导, 交换数据 dcj3sjt126com PHP 异或 ^
/* * 5 0101 * 9 1010 * * 5 ^ 5 * 0101 * 0101 * ----- * 0000 * 得出第一个规律: 相同的数进行异或, 结果是0 * * 9 ^ 5 ^ 6 * 1010 * 0101 * ---- * 1111 * * 1111 * 0110 * ---- * 1001
事件源对象周华华 JavaScript
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml&q
MySql配置及相关命令 g21121 mysql
MySQL安装完毕后我们需要对它进行一些设置及性能优化，主要包括字符集设置，启动设置，连接优化，表优化，分区优化等等。一修改MySQL密码及用户
[简单]poi删除excel 2007超链接 53873039oycg Excel
采用解析sheet.xml方式删除超链接，缺点是要打开文件2次,代码如下: public void removeExcel2007AllHyperLink(String filePath) throws Exception { OPCPackage ocPkg = OPCPac
Struts2添加 open flash chart 云端月影
准备以下开源项目： 1. Struts 2.1.6 2. Open Flash Chart 2 Version 2 Lug Wyrm Charmer (28th, July 2009) 3. jofc2，这东西不知道是没做好还是什么意思，好像和ofc2不怎么匹配，最好下源码，有什么问题直接改。 4. log4j 用eclipse新建动态网站，取名OFC2Demo，将Struts2 l
spring包详解 aijuans spring
下载的spring包中文件及各种包众多，在项目中往往只有部分是我们必须的，如果不清楚什么时候需要什么包的话，看看下面就知道了。 aspectj目录下是在Spring框架下使用aspectj的源代码和测试程序文件。Aspectj是java最早的提供AOP的应用框架。 dist 目录下是Spring 的发布包，关于发布包下面会详细进行说明。 docs&nb
网站推广之seo概念 antonyup_2006 算法 Web 应用服务器搜索引擎 Google
持续开发一年多的b2c网站终于在08年10月23日上线了。作为开发人员的我在修改bug的同时，准备了解下网站的推广分析策略。所谓网站推广，目的在于让尽可能多的潜在用户了解并访问网站，通过网站获得有关产品和服务等信息，为最终形成购买决策提供支持。网站推广策略有很多，seo，email，adv
单例模式,sql注入,序列百合不是茶单例模式序列 sql注入预编译
序列在前面写过有关的博客,也有过总结,但是今天在做一个JDBC操作数据库的相关内容时需要使用序列创建一个自增长的字段居然不会了,所以将序列写在本篇的前面 1,序列是一个保存数据连续的增长的一种方式; 序列的创建; CREATE SEQUENCE seq_pro 2 INCREMENT BY 1 -- 每次加几个 3
Mockito单元测试实例 bijian1013 单元测试 mockito
Mockito单元测试实例： public class SettingServiceTest { private List<PersonDTO> personList = new ArrayList<PersonDTO>(); @InjectMocks private SettingPojoService settin
精通Oracle10编程SQL(9)使用游标 bijian1013 oracle 数据库 plsql
/* *使用游标 */ --显示游标 --在显式游标中使用FETCH...INTO语句 DECLARE CURSOR emp_cursor is select ename,sal from emp where deptno=1; v_ename emp.ename%TYPE; v_sal emp.sal%TYPE; begin ope
【Java语言】动态代理 bit1129 java语言
JDK接口动态代理 JDK自带的动态代理通过动态的根据接口生成字节码(实现接口的一个具体类)的方式，为接口的实现类提供代理。被代理的对象和代理对象通过InvocationHandler建立关联 package com.tom; import com.tom.model.User; import com.tom.service.IUserService;
Java通信之URL通信基础白糖_ java jdk webservice 网络协议 ITeye
java对网络通信以及提供了比较全面的jdk支持，java.net包能让程序员直接在程序中实现网络通信。在技术日新月异的现在，我们能通过很多方式实现数据通信，比如webservice、url通信、socket通信等等，今天简单介绍下URL通信。学习准备：建议首先学习java的IO基础知识 URL是统一资源定位器的简写，URL可以访问Internet和www，可以通过url
博弈Java讲义 - Java线程同步 (1) boyitech java 多线程同步锁
在并发编程中经常会碰到多个执行线程共享资源的问题。例如多个线程同时读写文件，共用数据库连接，全局的计数器等。如果不处理好多线程之间的同步问题很容易引起状态不一致或者其他的错误。同步不仅可以阻止一个线程看到对象处于不一致的状态，它还可以保证进入同步方法或者块的每个线程，都看到由同一锁保护的之前所有的修改结果。处理同步的关键就是要正确的识别临界条件（cri
java-给定字符串，删除开始和结尾处的空格，并将中间的多个连续的空格合并成一个。 bylijinnan java
public class DeleteExtraSpace { /** * 题目：给定字符串，删除开始和结尾处的空格，并将中间的多个连续的空格合并成一个。 * 方法1.用已有的String类的trim和replaceAll方法 * 方法2.全部用正则表达式，这个我不熟 * 方法3.“重新发明轮子”，从头遍历一次 */ public static v
An error has occurred.See the log file错误解决！ Kai_Ge MyEclipse
今天早上打开MyEclipse时，自动关闭！弹出An error has occurred.See the log file错误提示！很郁闷昨天启动和关闭还好着！！！打开几次依然报此错误，确定不是眼花了！打开日志文件！找到当日错误文件内容： --------------------------------------------------------------------------
[矿业与工业]修建一个空间矿床开采站要多少钱? comsci
地球上的钛金属矿藏已经接近枯竭........... 我们在冥王星的一颗卫星上面发现一些具有开采价值的矿床..... 那么,现在要编制一个预算,提交给财政部门..
解析Google Map Routes dai_lm google api
为了获得从A点到B点的路劲，经常会使用Google提供的API，例如 [url] http://maps.googleapis.com/maps/api/directions/json?origin=40.7144,-74.0060&destination=47.6063,-122.3204&sensor=false [/url] 从返回的结果上，大致可以了解应该怎么走，但
SQL还有多少“理所应当”？ datamachine sql
转贴存档，原帖地址：http://blog.chinaunix.net/uid-29242841-id-3968998.html、http://blog.chinaunix.net/uid-29242841-id-3971046.html！ ------------------------------------华丽的分割线--------------------------------
Yii使用Ajax验证时，如何设置某些字段不需要验证 dcj3sjt126com Ajax yii
经常像你注册页面,你可能非常希望只需要Ajax去验证用户名和Email,而不需要使用Ajax再去验证密码,默认如果你使用Yii 内置的ajax验证Form,例如: $form=$this->beginWidget('CActiveForm', array( 'id'=>'usuario-form',&
使用git同步网站代码 dcj3sjt126com crontab git
转自:http://ued.ctrip.com/blog/?p=3646?tn=gongxinjun.com 管理一网站，最开始使用的虚拟空间，采用提供商支持的ftp上传网站文件，后换用vps，vps可以自己搭建ftp的，但是懒得搞，直接使用scp传输文件到服务器，现在需要更新文件到服务器，使用scp真的很烦。发现本人就职的公司，采用的git+rsync的方式来管理、同步代码，遂
sql基本操作蕃薯耀 sql sql基本操作 sql常用操作
sql基本操作 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2015年6月1日 17:30:33 星期一 &
Spring4+Hibernate4+Atomikos3.3多数据源事务管理 hanqunfeng Hibernate4
Spring3+后不再对JTOM提供支持，所以可以改用Atomikos管理多数据源事务。Spring2.5+Hibernate3+JTOM参考：http://hanqunfeng.iteye.com/blog/1554251Atomikos官网网站：http://www.atomikos.com/ 一.pom.xml <dependency> <
jquery中两个值得注意的方法one()和trigger()方法 jackyrong trigger
在jquery中，有两个值得注意但容易忽视的方法，分别是one()方法和trigger()方法,这是从国内作者<<jquery权威指南》一书中看到不错的介绍 1） one方法 one方法的功能是让所选定的元素绑定一个仅触发一次的处理函数，格式为 one(type,${data},fn) &nb
拿工资不仅仅是让你写代码的 lampcy 工作面试咨询
这是我对团队每个新进员工说的第一件事情。这句话的意思是，我并不关心你是如何快速完成任务的，哪怕代码很差，只要它像救生艇通气门一样管用就行。这句话也是我最喜欢的座右铭之一。这个说法其实很合理：我们的工作是思考客户提出的问题，然后制定解决方案。思考第一，代码第二，公司请我们的最终目的不是写代码，而是想出解决方案。话粗理不粗。付你薪水不是让你来思考的，也不是让你来写代码的，你的目的是交付产品
架构师之对象操作----------对象的效率复制和判断是否全为空 nannan408 架构师
1.前言。如题。 2.代码。 (1)对象的复制，比spring的beanCopier在大并发下效率要高，利用net.sf.cglib.beans.BeanCopier Src src=new Src(); BeanCopier beanCopier = BeanCopier.create(Src.class, Des.class, false);
ajax 被缓存的解决方案 Rainbow702 JavaScript jquery Ajax cache 缓存
使用jquery的ajax来发送请求进行局部刷新画面，各位可能都做过。今天碰到一个奇怪的现象，就是，同一个ajax请求，在chrome中，不论发送多少次，都可以发送至服务器端，而不会被缓存。但是，换成在IE下的时候，发现，同一个ajax请求，会发生被缓存的情况，只有第一次才会被发送至服务器端，之后的不会再被发送。郁闷。解决方法如下： ① 直接使用 JQuery提供的 “cache”参数，
修改date.toLocaleString()的警告 tntxia String
我们在写程序的时候，经常要查看时间，所以我们经常会用到date.toLocaleString()，但是date.toLocaleString()是一个过时的API，代替的方法如下： package com.tntxia.htmlmaker.util; import java.text.SimpleDateFormat; import java.util.
项目完成后的小总结 xiaomiya js 总结项目
项目完成了，突然想做个总结但是有点无从下手了。做之前对于客户端给的接口很模式。然而定义好了格式要求就如此的愉快了。先说说项目主要实现的功能吧 1，按键精灵 2，获取行情数据 3，各种input输入条件判断 4，发送数据（有json格式和string格式） 5，获取预警条件列表和预警结果列表， 6，排序， 7，预警结果分页获取 8，导出文件（excel，text等） 9，修