数位dp训练笔记

依稀还记得去年寒假的时候对数位dp的恐惧达到了顶峰，打死也不想做一题，也是怎么学都学不会，甚至板子也只是真的去网上copy了一份，自己也都不理解。（羞愧）

这个状态持续了一年多（羞愧羞愧），于是上周痛改前非，逼着自己重学数位dp，然后惊喜的发现，里面也没什么东西

刷了一定题目之后会发现还是有一定的套路可循的，在dp系列里应该也不能算很难的那一种（所以我为什么现在才开始学...）

1 前缀和思想处理区间问题，然后差分

2 按位枚举处理

3 合并相同状态做dp

时间复杂度的话一般就是状态数之和，毕竟相同状态会合并

没了

[AHOI2009]同类分布

大意：

给出两个数a,b，求出[a,b]中各位数字之和能整除原数的数的个数。

a,b<=1e18

思路：

考虑dp状态dp[i][j][k]表示枚举到前i位，前i位数字的和是j，前i位组成的数字是k

这是一个比较niave的想法，但是数据范围不支持我们这样处理第三维。

考虑到最后只要求整除，所以可以考虑用k%j来代替k

但是这样还涉及到一个问题，就是如果j是不断变化的，就很难实现状态转移

所以我们可以在外层枚举j，然后dfs的时候就保持j不变

就好了

由于这里是考虑每一位数字的和，所以我们不用考虑前导0的问题

code

#include
using namespace std;
#define ll long long
#define endl '\n'
const ll N=1e5+10;
ll mod;
ll n,m;
ll a[20];
ll cnt=0;
ll dp[20][200][200];
ll dfs(ll x,ll sum,ll rel,ll op)
{
	if(x==0) return sum==0&&rel==0;
	if(!op&&dp[x][rel][sum]!=-1) return dp[x][rel][sum]; 
	ll lim=op?a[x]:9;
	ll tot=0;
	for(int i=0;i<=lim&&i<=sum;++i)
	{	
		tot+=dfs(x-1,sum-i,(rel*10%mod+i)%mod,op&&i==lim);	
	}
	if(!op) dp[x][rel][sum]=tot;
	return tot;
}
ll f(ll x)
{
	cnt=0;
	while(x)
	{
		a[++cnt]=x%10;
		x/=10;
	}
	ll det=0;
	for(int i=1;i<=9*cnt;++i)
	{
		mod=i;
		memset(dp,-1,sizeof dp);
		det+=dfs(cnt,i,0,1);
	}
	return det;
}
void solve()
{
	
	cin>>n>>m;
	cout<>t;while(t--)
	solve();
	return 0;
}

虽然是紫题，但是理解了套路就很水

Classy Numbers

大意：

给出两个数a,b，求出[a,b]中各位数字中非0数不大于3的数字个数。

a,b<=1e18

思路：
板子题

这里显然需要考虑前导0

code

#include
using namespace std;
#define ll long long
#define endl '\n'
const ll N=1e5+10;
ll b,l,r;
int a[20];
ll cnt=0;
ll dp[20][200];
ll dfs(ll x,int sum,ll op)
{
	if(x==0) return sum<=3;
	if(!op&&dp[x][sum]!=-1) return dp[x][sum];
	int lim=op?a[x]:9;
	ll tot=0;
	for(int i=0;i<=lim;++i)
	{
		tot+=dfs(x-1,sum+(i!=0),op&&i==lim);
	}
	if(!op) dp[x][sum]=tot;
	return tot;
}
ll f(ll x)
{
	cnt=0;
	while(x)
	{
		a[++cnt]=x%10;
		x/=10;
	}
	return dfs(cnt,0,1);
}
void solve()
{
	cin>>l>>r;
	cout<>t;while(t--)
	solve();
	return 0;
}

Segment Sum

大意：

给定K,L,R，求L~R之间最多不包含超过K种数码的数的和。

K<=10，L,R<=1e18

思路：
如果只是求满足条件的数字的个数的话就是上面提到的板子题了

这里要求和，我们同样可以考虑对相同状态进行合并求和

f[i][j]表示当前枚举到第i位，出现过的数码种类的状态为j，也就是我们要求的答案数组

g[i][j]表示当前枚举到第i位，出出现过的数码种类的状态为j的合法数字个数，也就是板子

考虑如何用g来推f

这里j可以10位二进制状压

我们每往下走一位，如果我们枚举第i位上填的数字是t，用j'表示下一位的数码种类数

稍微意会一下应该就能懂了

f是数字的和，g是合法数字的个数

有了这个之后，我们就直接推就可以了。然后因为需要下一个状态的f和g，所以我们dfs要返回两个值

code

#include
using namespace std;
#define ll long long
#define pii pair
#define mk make_pair
#define endl '\n'
const ll N=1e5+10;
const ll mod=998244353;
ll n,m,k;
ll a[20];
ll cnt=0;
pii dp[40][1030];
ll p[40];
void init()
{
	p[0]=1;
	for(int i=1;i<=20;++i) p[i]=p[i-1]*10ll%mod;
}
bool check(ll x)
{
	ll cn=0;
	while(x)
	{
		cn+=(x%2);
		x/=2;
	}
	return cn<=k;
}
pii dfs(ll x,ll sum,ll head,ll op)
{
	if(x==0) return mk(0,1);
	if(!op&&!head&&dp[x][sum]!=mk(-1ll,-1ll)) return dp[x][sum];
	ll lim=op?a[x]:9;
	ll s1=0,s2=0;
	for(ll i=0;i<=lim;++i)
	{
		//f是数字的和，g是合法数字的个数
		pii gt=mk(0,0);
		if(head&&i==0) gt=dfs(x-1,0,1,op&&i==lim);
		else if(check(sum|(1<>n>>m>>k;
	cout<<((f(m)-f(n-1))%mod+mod)%mod<

 E. Salazar Slytherin's Locket

大意：
求l...r之间转成b进制后，每一位都是偶数的数的个数

思路：
不再是10进制，只要在预处理每一位的时候换个底数就好了

注意一下前导0

code

#include
using namespace std;
#define ll long long
#define endl '\n'
const ll N=1e5+10;
ll b,l,r;
int a[70];
ll cnt=0;
ll dp[70][1026][12];
ll dfs(ll x,int sta,ll op,ll head)
{
	if(x==0) return sta==0;
	if(!op&&!head&&dp[x][sta][b]!=-1) return dp[x][sta][b];
	int lim=op?a[x]:b-1;
	ll tot=0;
	for(int i=0;i<=lim;++i)
	{
		if(head&&i==0) tot+=dfs(x-1,0,op&&i==lim,1);
		else tot+=dfs(x-1,sta^(1<>b>>l>>r;
	cout<>t;while(t--)
	solve();
	return 0;
}

花神的数论题

大意：
设表示i的二进制表示中1的个数，求

思路：
考虑枚举贡献，枚举二进制1的个数为j，假设有k个这样的数字，答案就是

code

#include
using namespace std;
#define ll long long
const ll mod=1e7+7;
const ll N=70;
ll cnt[N];
ll n;
ll p,ans=1;
ll dp[N][N];//dp[i][j],当前枚举到第i位，前面的数中
//有j个1的情况下最终满足sum值等于p的数字的个数 
ll ksm(ll x,ll y)
{
	ll ans=1;
	while(y)
	{
		if(y&1) ans=ans*x%mod;
		x=x*x%mod;
		y>>=1;
	}
	return ans;
}

ll dfs(ll pos,bool limit,ll sum)
{
	if(pos==0) return (sum==p);//边界条件
	if(!limit&&~dp[pos][sum]) return dp[pos][sum];
	ll up=limit?cnt[pos]:1;
	ll cn=0;
	for(int i=0;i<=up;++i)
	{ 
		if(sum+(i==1)>p) continue;
		cn+=dfs(pos-1,limit&&(i==up),sum+(i==1));
	} 
	if(!limit) dp[pos][sum]=cn;
	return cn;
	 
}
void solve()
{
	ll d=0;
	while(n)
	{
		cnt[++d]=n%2;
		n/=2;
	}
	for(int i=1;i<=d;++i)
	{
		memset(dp,-1,sizeof dp);
		p=i;
		ans=ans*ksm(i,dfs(d,1,0))%mod;
	}
	cout<>n;
	solve();
	return 0;
}

未完待续~