数位dp

bzoj 1026  windy数

刚开始学这个数位dp，感觉都这个题不错，再很多地方都提供了思路：

题意：windy数就是这个数相邻两个数位的数相差不能小于2的数，给出一个区间，计算出这个区间的windy数有多少个？ 数据范围 2000000000

思路： 刚开始尝试用递归，tle,果断放弃；学到了数位dp,dp[ i ][ j ], i 表示的是数有i位，j 表示的是最高位即第i位的数是j，dp[ i ][ j ]表示的是符合这个条件的数的个数，如dp[ 2 ][ 1 ] = 7 ，是这几个数 ： 13，14，15，16，17，18，19；进行更新的时候就是i表示的是有多少位，j代表有i个数位的数的最高位上的数字,k表示的有i - 1个数位的数的最高位的数字，如果 j , k相差大于2,就进行 dp[ i ][ j ] += dp[ i - 1][k]的操作；

进行统计的时候，先统计【1，x】的windy数的个数，详细参照代码：

#include<bits/stdc++.h>

using namespace std;
const int maxn = 10 + 10;
typedef long long ll;
ll number[maxn];
int bits[maxn];
//bool vis[maxn];
ll n,m;
ll dp[maxn][maxn];//i 代表的是位数，j 代表的是最高位的数
void Init()
{
    memset(dp,0,sizeof(dp));
    for(int j = 0; j <= 9; j ++)
        dp[1][j] = 1;
    for(int i = 2; i <= 11; i ++)
    {
        for(int j = 0; j <= 9; j ++)
        {
            for(int k = 0; k <= 9 ; k ++)
            {
                if(abs(j - k) >= 2)
                {
                    dp[i][j] += dp[i - 1][k];
                }
            }
        }
    }
}
int getbits(ll x)
{
    int len = 1;
    while(x)
    {
        bits[len ++] = (x % 10);
        x = x / 10;
    }
    return len - 1;
}
ll solve(ll x)
{
    int len = getbits(x);//len表示的是这个数有多少位
    ll ans = 0;
    for(int i = 1; i < len ; i ++)//小于x的并且小于len位数的个数
    {
        for(int j = 1; j <= 9; j ++)
        {
            ans += dp[i][j];
        }
    }
    //len位数小于x 的分为两种情况进行统计
    for(int j = 1; j < bits[len]; j ++)
    {
        ans += dp[len][j];
    }
    //当首位为与x相同的数的时候
    for(int i = len - 1; i >= 1; i --)//
    {
        for(int j = 0; j < bits[i]; j ++)//后面的要实行的话就得前面得符合这种情况
        {
            if(abs(j - bits[i + 1]) >= 2)
            ans += dp[i][j];
        }
        if(abs(bits[i] - bits[i + 1]) < 2)//前面得不符合，后面得无需再进行下去了
            break;
    }
    return ans ;
}
int main()
{
    Init();
    while( ~ scanf("%lld%lld",&n,&m) )
    {
        cout << solve(m + 1) - solve(n) << endl;//因为上面在个位上并未进行判断，所以直接加一，后面也无需减一
    }
    return 0;
}

数位dp的记忆化搜索实现：

hdu4734

数位DP，用来学习数位DP了。

　　<数位DP>

　　　　所谓数位DP就是基于考虑数字的每一位来转移的DP。

　　　　例如求比456小的数，可以这么考虑，

　　　　　　　　4          5               6

　　　　　　　   4　       5             (0~6)

　　　　　　　　4       (0~4)         (0~9)

　　　　　　　　(0~3)(0~9)         (0~9)

　　　　然后我们就可以考虑用dp[len][pre]表示长度为len，以pre开头的符合条件的数的个数。

　　　　这样就可以得到转移方程了。

 

　　而对于这道题，我们可以用dp[len][pre]表示长度为len且权值不大于pre的数。

　　这道题用记忆化搜索，除边界条件外记录dp[len][pre]的值，下一次发现以前已经计算过了就可以直接return；

 

　　初值：dp[len][pre] = 0; 

　　　　　dfs(len, pre, flag)表示求长度为len，不超过pre的所有符合条件的值。其中flag是用来控制边界的。

　　　　　dfs过程中当深搜的边界，发现len < 0，pre >=0 的时候就返回1.

　　　　   

Tips：

　　下面记忆的时候要记得判断是不是边界，如果是边界算出来的答案是不完整的。

注意一点：dp数组初始化在外面进行；

#include<bits/stdc++.h>
using namespace std;
const int maxn = (1 << 10) * 200;
int dp[10][maxn];


int f(int x)
{
	int ans = 0;
	int t = 1;
	while(x)
	{
		ans += t * (x % 10);
		x /= 10;
		t <<= 1;
	}
	return ans;
}
int n,m;
int bits[10];

int dfs(int len,int x,int flag)
{
	if(len < 0)
	return x >= 0;
	if(x < 0)
	return 0;
	if(!flag && dp[len][x] != -1)
	return dp[len][x];
	int ans = 0;
	int ends = flag?bits[len]:9;
	for(int i = 0; i <= ends; i ++)
	{
		ans += dfs(len - 1,x - i * (1 << len),flag && i == ends);
	}
	if(!flag)
	dp[len][x] = ans;
//	cout <<len << " " << x << " " << dp[len][x] << endl;
	return ans;
}
int solve()
{
	int len = 0;
	int t = m;
	while(t)
	{
		bits[len ++] = t% 10;
		t /= 10;
	}
	return dfs(len - 1,f(n),1);
}
int main()
{
	int Tcase;
	scanf("%d",&Tcase);
	memset(dp,-1,sizeof(dp));
	for(int ii = 1; ii <= Tcase; ii ++)
	{
		
		scanf("%d%d",&n,&m);
		cout << "Case #"<< ii << ": " << solve() << endl;
	}
	return 0;
}