数位DP与状态压缩DP专题

数位DP题型较为固定：

特点如下：

数据范围很大；询问区间内符合条件的数的个数；

解题流程：预处理符合条件的数（1-R），根据DFS树，来囊括所有树，大致的步骤如下：

将数存储起来，由大到小进行遍历，状态表示为：选当前的数和不选当前的数；

不选当前的数：代表小于当前数的所有值都囊括；

选当前的数：需要判断是否符合条件，不符合条件直接退出；

状态压缩DP的处理模式也比较固定：

首先根据题目条件预处理出合法状态（横向）；

其次进行dp，dp中需要对合法的纵向状态进行筛选，最后进行状态转移；

数位DP题目清单：

windy 数 - 洛谷 P2657 - Virtual Judge

思路:预处理出：f[i][j]代表i位数，第i位为j的合法数量，初始赋值为f[1][j]=1(0<=j<=9);

直接按照树形结构进行求解，这里需要注意的是0-最高位1的数，比如对于7654321来说，我们需要特别的处理0-999999之间的数。

代码如下：

#include<iostream>
#include<vector>
using namespace std;
const int N=12;
int f[N][N];

void init(){
    for(int i=0; i<=9; i++)f[1][i]=1;
    for(int i=2; i<N; i++){
        for(int j=0; j<=9; j++){
            for(int k=0; k<=9; k++){
                if(abs(j-k)>=2)
                 f[i][j]+=f[i-1][k];
                
            }
        }
    }
}
int dp(int n){
    if(n==0)return 1;
    
    vector<int>num;
    while(n){
        num.push_back(n%10);
        n/=10;
    }
    int res=0;
    int last=-2;
    for(int i=num.size()-1; i>=0; i--){
        int v=num[i];
        for(int j=(i==num.size()-1); j<v; j++){
            if(abs(j-last)>=2)
            res+=f[i+1][j];

        }
        if (abs(num[i] - last) < 2) break;
        last=num[i];
        if(i==0 )res++;
    }
    //cout<<res<<endl;
    for(int i=0; i<=num.size()-2; i++){
        for(int j=1; j<=9; j++){
            res+=f[i+1][j];
        }
    }
    res++;
    return res;
    
}
int main(){
    init();
    int n,m;
    cin>>n>>m;
    //cout<<f[2][0]<<endl;
    cout<<dp(m)-dp(n-1)<<endl;
}

状态压缩DP题目清单

炮兵阵地 - 洛谷 P2704 - Virtual Judge

思路：预处理出横向的合法状态，我这里采用的是处理所有通用的合法状态（即没有考虑地图），最后在dp过程中考虑纵向和地图的影响；你也可以处理出符合地图的所有横向状态，用vector来存储每个横向的合法状态，最后在dp过程中考虑纵向状态即可

代码如下：注意优化空间

#include<iostream>
using namespace std;

const int N = 110, M = 13;
int f[2][1 << M][1 << M];
int g[N];
int st[1 << M];
int num[1 << M];
int cnt = 0;

int main() {
    int n, m;
    cin >> n >> m;
    char c;

    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            cin >> c;
            if (c == 'P') g[i] += 1 << (m - j);
        }
    }


    for (int i = 0; i < (1 << m); i++) {
        if (!(i >> 1 & i) && !(i >> 2 & i)) {  
            st[cnt++] = i;
            for (int j = 0; j < m; j++) {
                num[i] += (i >> j) & 1;
            }
        }
    }

   
    for (int i = 1; i <= n + 2; i++) {
        for (int x = 0; x < cnt; x++) {
            for (int y = 0; y < cnt; y++) {
                for (int z = 0; z < cnt; z++) {
                    if ((g[i] & st[x]) == st[x] && (g[i + 1] & st[y]) == st[y] && (g[i + 2] & st[z]) == st[z]
                        && !(st[x] & st[y]) && !(st[x] & st[z]) && !(st[y] & st[z])) {
                        f[i & 1][y][z] = max(f[i & 1][y][z], f[(i - 1) & 1][x][y] + num[st[x]]);
                    }
                }
            }
        }
    }

    cout << f[(n + 2) & 1][0][0] << endl;

    return 0;
}