状压DP的总结

状压dp的标志

①数据小 ②通过题目所给出的条件以后得到的特征集合小

一：CF259div2 D：

题目大意：保证b[i]中每个数互质，给出a[i]，然后求1~n的abs(a[i]-b[i])最小。a[i]<=30

思路：首先得到b[i]必然小于60。这个很重要，因为我们枚举的b的集合就是60.首先当b如果都取1，那么最大的abs就是30，所以b可以取得的极限是60.然后我们可以得到60里面的所有的素数，这些素数的个数是17.因此我们发现是状压DP。

首先预处理出1~60的包含素数的集合，然后枚举a[i]，枚举1~60，再枚举1~1<<17即可得出答案。

关键：寻找子集范围，寻找变量的最大范围

#include<bits/stdc++.h>

using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 100 + 5;
const int u = 1 << 17;
struct point{
    int val, x, pre;
}dp[maxn][u + 5];
int f[maxn];
bool vis[maxn];
vector<int> v;
int n;
int a[maxn];
vector<int> ans;

int main(){
    for (int i = 2; i <= 60; i++){
        if (!vis[i]){
            v.push_back(i);
            for (int j = i + i; j <= 60; j += i){
                vis[j] = true;
            }
        }
    }
    int len = v.size();
    //f[1] = 1;如果单独变成1了，那么dp时就无法有多个1了。
    for (int i = 1; i <= 60; i++){
        int tmp = i;
        for (int j = 0; j < len; j++){
            bool flag = false;
            while (tmp % v[j] == 0){
                tmp /= v[j];
                flag = true;
            }
            if (flag) f[i] |= 1 << (j);
        }
    }
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) scanf("%d", a + i);
    for (int i = 0; i < u; i++) dp[0][i].val = 0;
    for (int i = 1; i <= n; i++){
        for (int j = 0; j < u; j++){
            dp[i][j].val = inf;
        }
    }
    for (int i = 1; i <= n; i++){
        for (int j = 1; j <= 60; j++){
            int x = f[j];
            for (int k = 0; k < u; k++){
                if (k & x) continue;
                if (dp[i][k | x].val > dp[i - 1][k].val + abs(a[i] - j)){
                    dp[i][k | x].val = dp[i - 1][k].val + abs(a[i] - j);
                    dp[i][k | x].pre = k;
                    dp[i][k | x].x = j;
                }
            }
        }
    }

    int pre = 0, mini = dp[n][0].val;
    for (int i = 1; i < u; i++){
        if (mini >= dp[n][i].val){
            mini = dp[n][i].val;
            pre = i;
        }
    }
    //printf("%d
", dp[n][u - 1].val);
    for (int i = n; i > 0; i--){
        ans.push_back(dp[i][pre].x);
        pre = dp[i][pre].pre;
        //printf("dp[i][pre].pre = %d
", dp[i][pre].pre);
        //printf("pre = %d
", pre);
    }
    reverse(ans.begin(), ans.end());
    len = ans.size();
    for (int i = 0; i < len; i++){
        printf("%d%c", ans[i], i == len - 1 ? '
' : ' ');
    }
    return 0;
}

然后上面的这个47-59行可以有优化成

for (int i = 1; i <= n; i++){
        for (int j = 1; j <= 60; j++){
            int y = ((~f[j]) & (u - 1));
            int x = f[j];
            for (int k = y; ; k = (k - 1) & y){
                if (dp[i][k | x].val > dp[i - 1][k].val + abs(a[i] - j)){
                    dp[i][k | x].val = dp[i - 1][k].val + abs(a[i] - j);
                    dp[i][k | x].pre = k;
                    dp[i][k | x].x = j;
                }
                if (k == 0) break;
            }
        }
    }

就是先筛选出其中本来就不包含和原子集取&的元素，然后通过枚举k，再&可以消去很多种情况，大大减少时间复杂度。