状压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 =  + ;
 const int u =  << ;
 struct point{
     int val, x, pre;
 }dp[maxn][u + ];
 int f[maxn];
 bool vis[maxn];
 vector<int> v;
 int n;
 int a[maxn];
 vector<int> ans;

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

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

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

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

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