DP：数位DP
数位DP的大致思想：枚举每一位能选取的合法值。
1. LC 2376 统计特殊整数
说是DP，但实际上状态转移方程挺难写的，毕竟是枚举+集合论，这里就不贴状态转移方程了。总体的写法其实是搜索+记忆化。之所以称之为DP，是因为：
- 对于第i位，
- 如果[0,i-1]位全部都选的能选的最大值，那么第i位最多也就只能选到最大值（注意第0位肯定是受限制的）
- 否则，第i位能随便选
- 如果前面[0,i-1]位都是0（前导零），这一位就可以随便选了
有这两大状态转移的规则，所以还是被称之为DP。细节写在代码里了
import java.util.Arrays;
class Solution {
char[] s;
int[][] memo;
public int countSpecialNumbers(int n) {
s = Integer.toString(n).toCharArray();
// 记搜
// memo[i][mask]代表[0,i-1]位选掉了mask中各个索引位置代表的数的情况下后面有多少个特殊整数
memo = new int[s.length][1<<10];
for (int i = 0; i < memo.length; i++) {
Arrays.fill(memo[i],-1); // -1 代表没有计算过
}
// 一开始第一位当然要受限制，不过也可以是前导零，所以 (true,false)
return f(0,0,true,false);
}
/**
* 记搜计算在确定[0,i-1]位后剩下的有种特殊整数的情况
* @param i 第i位
* @param mask 已经选择了mask集合中的数
* @param isLimit 当前位上限是否有限制，有的话是 int(s[i]),没有的话是9
* @param isNum 当前位是否跳过，即前导零
* @return 确定[0,i-1]位后剩下的有种特殊整数的情况
*/
private int f(int i,int mask,boolean isLimit,boolean isNum){
if(i==s.length){
return isNum ?1:0; // 防止从头到尾的前导零，这种情况根本不是个数字，当然不能算
}
/*
这个!isLimit条件非常重要，举个例子，n=420
假设现在前两位选了 4,2，那么mask = {4,2}，第三位就只能选0
但如果前两位选了2，4，mask={4,2}，第三位可以随便选（除了2,4)
在第一种情况下能选1种，第二种情况下能选8种（10-2），差了7种情况
而之后的循环枚举会考虑所有顶着最大上限选的情况，所以如果当前这个数位受到最大上限的限制的话，后面的for循环会统计这个情况的
而不是把非受限制的情况的记忆化搜索结果返回，在这个例子里dp[2][{2,4}] = 8 而不是1
但isNum不是必须判断的，因为如果前面都受限制，后面一位也一定受限制，可前面都是前导零，不代表后面也得是前导零
况且，[0,i-1]位全是前导零的情况，顶多出现一次，后面再怎么递归都不可能有的
*/
if(!isLimit && memo[i][mask]!=-1){
return memo[i][mask];
}
int res = 0;
if(!isNum){
// 含前导零，跳过
res = f(i+1,mask,false,false);
}
// 当前位置是否受限制
int upper = isLimit?s[i]-'0':9;
// 枚举可以填充的数,这里要检查是否之前使用了前导零，使用了的话要去掉（之前if(!isNum)加过了），没有用的话可以从0开始
for (int j = isNum?0:1; j <= upper; j++) {
// 特殊整数要求各数位都不一样，所以检查mask中之前用过没
// mask就是个位图，比如 binary(mask) = 0101010111 从右往左看，用集合论表示就是 {8,6,4,2,1,0} 这些数字已经被用过了
if((mask>>j&1)==0){
// 用掉j就是把mask的第j位设置为0 mask|(1<2. LC 233 数字1的个数
这题是我学了板子后做的第一题，真的汗流浃背。想想做做调调，卡了1h才出来。
首先这个跟上面一题的区别是，对于枚举的数字没有限制。不仅没有重复性的限制，而且还没有前导零的限制（前导零的数不会被判无效，因为这道题只看1的数量）
这样就简便了不少。我们只需要看是否被上限限制即可。这个是否受限还是和以前一样，只有前面的都受限，本次才会受限，否则不会。
令f(i,isLimit)表示第[i,n-1]位在Limit的限制下能产生的1的数量。那么本轮的上限可以由isLimit计算得出：
-
如果upper<1，也就是upper=0的情况，本轮不可能选1
-
如果upper==1，本轮选择1会产生 int(suffix(n,i+1))+1 个1。其中suffix(n,i+1)代表n的[i+1,n-1]位的值，例如 n = 2132 , i=1 那么suffix(2232,2) = 32。
这是比较显然的，拿上面那个例子来说，如果本轮选择1，后续会有2100到2132这些数的第i=1位是1，所以就是32-00+1=33个
-
如果upper>1，本轮选择1会产生 pow(10,n-i-1)个1。例如n=2232,i=1,那么如果本轮选择1，就会有2100到2199的第i=1位是1，也就是pow(4-1-1)=100个
以上考虑的是本轮（第i位）产生的1的数量。后面[i+1,n-1]产生的还没算：
两种情况讨论。上限是upper，说明本轮有upper种选择，其中可能有一种是顶格选的（isLimit情况），有upper种是非顶格选的。依次累加到res即可。这里对于前者，根据当前的isLimit来（如果当前顶格了后面也得顶格，当前不顶格后面也不顶格），根据后者，isLimit = false
最后，记搜的时候要记得排除顶格选的情况。因为这种情况已经被统计过了。
import java.util.Arrays;
class Solution {
char[] s;
int[] memo;
public int countDigitOne(int n) {
s = Integer.toString(n).toCharArray();
memo = new int[s.length];
Arrays.fill(memo,-1);
return f(0,true);
}
/**
* 记搜计算[0,i-1]位选择完毕后，后面的位置总共能出现多少个1
* @param i 第i位
* @param isLimit 受到最大上限限制与否
* @return [0,i-1]位选择完毕后，后面的位置总共能出现多少个1
*/
private int f(int i,boolean isLimit){
if(i==s.length){
return 0;
}
/*
例如：n = 1230 ，现在 i=[0,1,2] = {1,2,3},那么后面一个1都不可能有
但如果i=[0,1,2] = {1,2,2}，后面是可以有一个1的
memo记录的是后者
*/
if(!isLimit && memo[i]!=-1){
return memo[i];
}
int res = 0;
int upper = isLimit?s[i]-'0':9;
// 如果这一轮选1
if(upper==1){
res += suffix(i+1)+1;
}else if(upper>1){
res += (int) Math.pow(10,s.length-i-1);
}
// 本来可以选 upper+1个数（这一轮）
// 如果之前全部都顶格选了，那么将是upper个可以后续不用顶格选的，和一个必须顶格选的
res += upper*f(i+1,false) + f(i+1,isLimit);
if(!isLimit){
memo[i] = res;
}
return res;
}
private int suffix(int start){
StringBuilder sb = new StringBuilder();
for(int i=start;i3. LC 2719 统计整数数目
这道题我思路有的，但就是有点歪，所以虽然A了但是时间上表现不好
首先我的记搜是包含4个状态的：定义 f (i,isLower,isUpper,acc)表示在[0,i-1]位均已枚举，且数位和为acc，且是（否）受下限与上限的制约的情况下，后续能够产生的符合条件的数。
那么上限和下限分别怎么算？我通过补齐较小的num1的前导零，使其与num2在数位长度上等长。这样下限由num1（补齐前导零后）决定，上限由num2决定。
在深搜时记忆化在不受上下限制约的情况下，在枚举到第i位且已有数位累计和acc的情况下，后续能有多少个符合条件的数。
之后根据是否受上下限制约枚举数位即可。这里注意枚举时可以及时地判断是否已经爆掉数位和上界了，而下界可以留到最终递归基的是否判断。
最后，我现在是觉得，模运算这个东西，有很强的性质（加法乘法的性质都特别强），如果担心答案爆了怎么办，就在能取模的地方全部取模就行。
import java.util.Arrays;
class Solution {
static long mod = (long)1e9+7;
char[] s1;
char[] s2;
long[][] memo;
int min;
int max;
public int count(String num1, String num2, int min_sum, int max_sum) {
min = min_sum;
max = max_sum;
s1 = supplyLeadingZero(num1,num2).toCharArray();
s2 = num2.toCharArray();
// memo[i][acc]代表在不受限制的情况下 到了第i位已经有acc的数位和，第[i+1,n-1]位最多能有多少个符合条件的数
memo = new long[s2.length][22*9+1];
for (int i = 0; i < memo.length; i++) {
Arrays.fill(memo[i],-1L);
}
return (int) (f(0,true,true,0) % mod);
}
private String supplyLeadingZero(String num1,String num2){
StringBuilder num1Builder = new StringBuilder(num1);
while(num1Builder.length()=min?1L:0L;
}
if(!isLower && !isUpper && memo[i][acc]!=-1){
return memo[i][acc];
}
int lb = isLower?s1[i]-'0':0;
int ub = isUpper?s2[i]-'0':9;
long res = 0L;
for(int j=lb;j<=ub;j++){
if(max>=acc+j){
res = (res%mod + f(i+1,isLower && j==lb, isUpper && j==ub, acc+j)%mod) % mod;
}
}
if(!isLower && !isUpper){
memo[i][acc] = res;
}
return res;
}
}
还有一种更常见的思路是，先统计一遍≤num1的情况，再统计一遍≤num2的情况，然后后者减前者就是(num1,num2]的情况。又因为题目是闭区间，所以单独判一下num1符合条件与否即可。这种思路跑得比我的代码快，这里摘录一份：
class Solution {
private static final int MOD = 1_000_000_007;
public int count(String num1, String num2, int minSum, int maxSum) {
int ans = calc(num2, minSum, maxSum) - calc(num1, minSum, maxSum) + MOD; // 避免负数
int sum = 0;
for (char c : num1.toCharArray()) {
sum += c - '0';
}
if (minSum <= sum && sum <= maxSum) {
ans++; // num1 是合法的，补回来
}
return ans % MOD;
}
private int calc(String s, int minSum, int maxSum) {
int n = s.length();
int[][] memo = new int[n][Math.min(9 * n, maxSum) + 1];
for (int[] row : memo) {
Arrays.fill(row, -1);
}
return dfs(0, 0, true, s.toCharArray(), minSum, maxSum, memo);
}
private int dfs(int i, int sum, boolean isLimit, char[] s, int minSum, int maxSum, int[][] memo) {
if (sum > maxSum) { // 非法
return 0;
}
if (i == s.length) {
return sum >= minSum ? 1 : 0;
}
if (!isLimit && memo[i][sum] != -1) {
return memo[i][sum];
}
int up = isLimit ? s[i] - '0' : 9;
int res = 0;
for (int d = 0; d <= up; d++) { // 枚举当前数位填 d
res = (res + dfs(i + 1, sum + d, isLimit && (d == up), s, minSum, maxSum, memo)) % MOD;
}
if (!isLimit) {
memo[i][sum] = res;
}
return res;
}
}