Leetcode状压DP
状压DP，是状态压缩和DP相结合，通常是将某个局面，或某种选择方案视为一个状态，状态与状态进行转移。
涉及一些位运算知识：
for(int i = 0;i < (1<<n);i++) // 枚举所有的状态
i&(1<<j) // 判断i的第j位
(i>>j)&1 // 判断i的第j位，且可以取值
for(int cur=s; cur>0; cur=(cur-1)&s) // 枚举s的子集
解释一下s的子集枚举，假设s=13，即1101，s的所有子集如下：
1 1 0 1
1 1 0 0
1 0 0 1
1 0 0 0
0 1 0 1
0 1 0 0
0 0 0 1
共\(2^3-1\)个
通常，状态转移的时候是选择其中一个‘1’，但也有可能是选择其中一个子集，例如下面的情况：
for(int i = 0;i < (1<<n);i++) {
for(int s = i;s;s=(s-1)&i) {
....
}
}
它的时间复杂度是多少呢？\(O(3^n)\)
由于长度为\(n\)且包含\(k\)个1的二进制表示有\(C_{n}^{k}\)个，其有\(2^k\)个子集，动态规划的时间复杂度就是每个二进制表示的子集个数之和：\(\sum_{i=0}^{n} C_{n}^{i} {2^i} = 3^n\)，因为它就是\(3^n\)的二进制展开。
Leetcode 1879. 两个数组最小的异或值之和
题解：问题模型就是两个数组的带权匹配，可以用状压DP、匈牙利算法KM、随机算法模拟退火。这里只介绍状压DP的做法。
dp[i]表示左边状态为i，右边选择到了第__bulitin_popcount(i)个，递推的时候相当于先算出1的个数为k的状态，在算出1的个数为k+1的状态
class Solution {
public:
int minimumXORSum(vector<int>& nums1, vector<int>& nums2) {
int n = nums1.size(), ans = 0x3f3f3f3f;
int dp[1<<n];
memset(dp, 0x3f, sizeof(dp));
dp[0] = 0;
for(int i = 0;i < (1<<n); i++) {
int cnt = __builtin_popcount(i);
if(cnt > n) continue;
for(int j = 0;j < n;j++) {
if(i & (1<<j)) {
dp[i] = min(dp[i], dp[i^(1<<j)] + (nums1[j] ^ nums2[cnt-1]));
}
}
if(cnt == n) ans = min(ans, dp[i]);
}
return ans;
}
};
Leetcode 2172. 数组的最大与和
题解：把两组数组都扩展到2*m长度，就和上一题一样了
class Solution {
public:
int maximumANDSum(vector<int>& nums, int m) {
int n = nums.size(), ans = 0;
int dp[1<<2*m];
memset(dp, 0, sizeof(dp));
for(int i = 0;i < (1<<2*m);i++) {
int cnt = __builtin_popcount(i); // 1的个数
if(cnt > n) continue;
for(int j = 0;j < 2*m;j++) {
if((i>>j)&1) {
dp[i] = max(dp[i], dp[i^(1<<j)] + ((j/2+1) & nums[cnt-1]));
}
}
if(cnt == n) ans = max(ans, dp[i]);
}
return ans;
}
};
Leetcode 1947. 最大兼容性评分和
题解：同1879
class Solution {
public:
int cal(vector<int>& nums1, vector<int>& nums2) {
int res = 0, n = nums1.size();
for(int i = 0;i < n;i++) res += (1-(nums1[i]^nums2[i]));
return res;
}
int maxCompatibilitySum(vector<vector<int>>& students, vector<vector<int>>& mentors) {
int n = students.size(), ans = 0;
vector<int>dp(1<<n, 0);
for(int i = 0;i < (1<<n);i++) {
int cnt = __builtin_popcount(i);
for(int j = 0;j < n;j++) {
if(i & (1<<j)) {
dp[i] = max(dp[i], dp[i^(1<<j)] + cal(students[j], mentors[cnt-1]));
}
}
}
return dp.back();
}
};
Leetcode 1595. 连通两组点的最小成本
题解：dp[i][[s]表示左边选择前i个，右边选择s，不过和前面相比，是从dp[i][s]往后推，而不是从前推出dp[i][s]。
class Solution {
public:
int connectTwoGroups(vector<vector<int>>& cost) {
int n = cost.size(), m = cost[0].size();
int dp[n+1][(1<<m)];
memset(dp, 0x3f, sizeof(dp));
dp[0][0] = 0;
for(int i = 1;i <= n;i++) {
// cout << "i: " << i << endl;
for(int s = 0;s < (1<<m);s++) {
for(int j = 0;j < m;j++) {
dp[i][s|(1<<j)] = min(dp[i][s|(1<<j)], min(dp[i-1][s] + cost[i-1][j], dp[i][s]+cost[i-1][j]));
}
}
}
return dp[n][(1<<m)-1];
}
};
Leetcode 1494. 并行课程 II
题解：把已经上完的课当做一个状态learned，当前状态下可选择的课为wait，枚举wait的子集作为一个选择，所有选择里取最小值。
参考链接：钰娘娘】1494. 并行课程 II 拓扑反例+状态压缩动态规划
class Solution {
public:
int minNumberOfSemesters(int n, vector<vector<int>>& relations, int k) {
int pre[n], dp[1<<n];
memset(pre, 0, sizeof(pre));
memset(dp, 0x3f, sizeof(dp));
dp[0] = 0;
for(auto x : relations) {
pre[x[1]-1] |= (1<<(x[0]-1));
}
for(int learned = 0;learned < (1<<n);learned++) {
int wait = 0;
for(int i = 0;i < n;i++) {
if((pre[i] & learned) == pre[i]) wait |= (1<<i);
}
wait = wait & (~learned); // 只有在未学习的情况下才能学习
for(int cur = wait;cur > 0;cur=(cur-1)&wait) { // 枚举wait的一个子集学习
if(__builtin_popcount(cur) > k) continue; // 子集1的个数不能超过k，这个nb!!
dp[learned|cur] = min(dp[learned|cur], dp[learned] + 1);
}
}
return dp[(1<<n)-1];
}
};
Leetcode 1655. 分配重复整数
题解：dp[i][j] 表示cnts的前i个能否满足quantity的子集j。dp[i][j] = dp[i-1][j'] && sum[j&(~j)] <= cnts[i-1]
参考链接：【子集枚举】经典套路状压 DP](https://leetcode-cn.com/problems/distribute-repeating-integers/solution/zi-ji-mei-ju-jing-dian-tao-lu-zhuang-ya-dp-by-arse/)
class Solution {
public:
bool canDistribute(vector<int>& nums, vector<int>& quantity) {
unordered_map<int, int>freq;
for(int i = 0;i < nums.size();i++) {
freq[nums[i]]++;
}
vector<int>cnts;
for(auto& x : freq) cnts.push_back(x.second);
int n = cnts.size(), m = quantity.size();
vector<int>sum(1<<m, 0);
for(int i = 0;i < (1<<m);i++) {
for(int j = 0;j < m;j++) {
if(i & (1<<j)) {
sum[i] = sum[i^(1<<j)] + quantity[j];
break;
}
}
}
bool dp[n+1][1<<m];
memset(dp, 0, sizeof(dp));
for(int i = 0;i <= n;i++) dp[i][0] = true;
// dp[0][0] = true;
for(int i = 1;i <= n;i++) {
for(int j = 0;j < (1<<m);j++) {
if(dp[i-1][j]) {dp[i][j] = true; continue;} // 其实对应s=0的情况
for(int s = j;s;s = (s-1)&j) { // 当前选的
int pre = j & (~s); // 之前选的
dp[i][j] = dp[i-1][pre] && (sum[s] <= cnts[i-1]);
if(dp[i][j]) break;
}
}
}
return dp[n][(1<<m)-1];
}
};
LC 1986. 完成任务的最少工作时间段
题解：dp[i]枚举所有i的子集转移即可
class Solution {
public:
int minSessions(vector<int>& tasks, int sessionTime) {
int n = tasks.size();
int sum[1<<n];
memset(sum, 0, sizeof(sum));
for(int i = 0;i < (1<<n);i++) {
for(int j = 0;j < n;j++) {
if(i & (1<<j)) {
sum[i] = sum[i^(1<<j)] + tasks[j];
break;
}
}
// cout << i << " " << sum[i] << endl;
}
int dp[1<<n];
memset(dp, 0x3f, sizeof(dp));
dp[0] = 0;
for(int i = 0;i < (1<<n);i++) {
for(int s = i;s;s=(s-1)&i) {
int pre = i & (~s);
if(sum[s] <= sessionTime) {
dp[i] = min(dp[i], dp[pre]+1);
}
}
}
return dp[(1<<n)-1];
}
};
LC 1434. 每个人戴不同帽子的方案数
题解：状压DP，dp[i][j]表示前i个帽子能满足子集j的方案数
const int mod = 1e9+7;
class Solution {
public:
int numberWays(vector<vector<int>>& hats) {
int n = hats.size();
int dp[41][1<<n];
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
for(int i = 1;i <= 40;i++) {
for(int j = 0;j < (1<<n);j++) {
dp[i][j] = dp[i-1][j];
for(int k = 0;k < n;k++) {
if(j & (1<<k)) {
if(find(hats[k].begin(), hats[k].end(),i) != hats[k].end()) {
dp[i][j] = (dp[i][j] + dp[i-1][j^(1<<k)]) % mod;
}
}
}
}
}
return dp[40][(1<<n)-1];
}
};
LC 1799. N 次操作后的最大分数和
题解：dp[i]表示状态i的最大分数，可以由子集j转移而来，i减去两个1形成j
class Solution {
public:
int gcd(int a, int b) {
return b ? gcd(b, a%b) : a;
}
int maxScore(vector<int>& nums) {
int n = nums.size();
int dp[1<<n];
memset(dp, 0, sizeof(dp));
for(int i = 0;i < (1<<n);i++) {
int cnt = __builtin_popcount(i);
if(cnt%2) continue;
for(int k = 0;k < n;k++) {
for(int t = k+1;t < n;t++) {
if((i&(1<<k)) && (i&(1<<t))) {
int j = i ^ (1<<k) ^ (1<<t);
// cout << "j: " << j << " " << k << " " << t << " " << cnt << endl;
dp[i] = max(dp[i], dp[j] + ((n-cnt)/2+1)*gcd(nums[k], nums[t]));
// cout << "dp: " << dp[i] << endl;
}
}
}
}
return dp[(1<<n)-1];
}
};
LC 1349. 参加考试的最大学生数
题解：头插DP，也算是状压DP的一种吧，dp[i][j]表示前i行且最后一行的状态为j的最大学生数目，然后逐行转移，计算行与行之间的互斥性。
class Solution {
public:
int maxStudents(vector<vector<char>>& seats) {
int n = seats.size(), m = seats[0].size();
int dp[n+1][1<<m];
memset(dp, 0, sizeof(dp));
for(int i = 1;i <= n;i++) {
for(int j = 0;j < (1<<m);j++) {
for(int k = 0;k < (1<<m);k++) {
int cnt = 0;
for(int t = 0;t < m;t++) {
if(seats[i-1][t] == '#') continue;
if(t>0 && (j & (1<<(t-1)))) continue;
if(t>0 && (k & (1<<(t-1)))) continue;
if(t < m-1 && (j & (1<<(t+1)))) continue;
if(t < m-1 && (k & (1<<(t+1)))) continue;
if(k & (1<<t)) cnt++;
}
dp[i][j] = max(dp[i][j], dp[i-1][k] + cnt);
}
}
}
return *max_element(dp[n], dp[n]+(1<<m));
}
};
LC 1681. 最小不兼容性
题解：子集枚举，要求子集的大小为kk，将其作为新的一组
class Solution {
public:
bool check(int s, int n, vector<int>& nums) {
unordered_map<int,int>mp;
for(int i = 0;i < n;i++) {
if(s & (1<<i)) mp[nums[i]]++;
}
for(auto x : mp) {
if(x.second > 1) return false;
}
return true;
}
int cal(int s, int n, vector<int>& nums) {
int mymax = 0, mymin = 0x3f3f3f3f;
for(int i = 0;i < n;i++) {
if(s & (1<<i)) {
mymax = max(mymax, nums[i]);
mymin = min(mymin, nums[i]);
}
}
return mymax-mymin;
}
int minimumIncompatibility(vector<int>& nums, int k) {
int n = nums.size();
int kk = n/k;
int valid[1<<n], cha[1<<n],oneCnt[1<<n];
for(int i = 0;i < (1<<n);i++) {
valid[i] = check(i, n, nums);
cha[i] = cal(i, n, nums);
oneCnt[i] = __builtin_popcount(i);
}
int dp[1<<n];
memset(dp, 0x3f, sizeof(dp));
dp[0] = 0;
for(int i = 0;i < (1<<n);i++) {
if(oneCnt[i] % kk) continue;
for(int s = i;s;s=(s-1)&i) {
int pre = i & (~s);
if(oneCnt[s] != kk) continue;
if(!valid[s]) continue;
dp[i] = min(dp[i], dp[pre]+cha[s]);
}
}
int ans = dp[(1<<n)-1];
return ans==0x3f3f3f3f? -1 : ans;
}
};
LC 691. 贴纸拼词
题解：由于可以重复，通过采用刷表法。dp[i]表示target的状态为i时需要的最少贴纸数目
class Solution {
public:
int minStickers(vector<string>& stickers, string target) {
int n = stickers.size(), m = target.size();
int dp[1<<m];
memset(dp, 0x3f, sizeof(dp));
dp[0] = 0;
vector<vector<int>>cnt(n, vector<int>(26, 0));
for(int i = 0;i < n;i++) {
for(char ch : stickers[i]) {
cnt[i][ch-'a']++;
}
}
for(int i = 0;i < (1<<m);i++) { // 逐层染色的感觉
if(dp[i] == 0x3f3f3f3f) continue;
for(int j = 0;j < n;j++) { // 每次都有n中选择（因为可以重复）
int nxt = i;
vector<int>left = cnt[j];
for(int k = 0;k < m;k++) {
if(i & (1<<k)) continue;
if(left[target[k]-'a']) {
nxt |= (1<<k);
left[target[k]-'a']--;
}
}
// cout << i << " " << j << " " << nxt << endl;
dp[nxt] = min(dp[nxt], dp[i]+1);
}
}
int ans = dp[(1<<m)-1];
return ans==0x3f3f3f3f ? -1 : ans;
}
};
值得注意的是，由于只考虑最少数目，不要求顺序，因此i 和 j 两个循环交换也是可以的；否则，如果是求方案数，应该将枚举物品放外面。
个性签名：时间会解决一切
