leetcode 5619. 最小不兼容性（将大小不超过16的数组分成k组 每组无重复元素 求所有组的最大-最小 的和最小 状压dp）

题目

时间复杂度：(2^n) * (n^2)
空间复杂度：(2^n) * n

class Solution {
#define INF 0x3f3f3f3f
#define low(i) ((i)&(-i))
public:
    //当要选每个组的不是一个时:
    //dp[s|x][x]=min(dp[s][y]+nums[x]-nums[y]);
    //当要选每个组的第一个时：
    //dp[s|x][...]=min(dp[s][...]);
    int get(int x){//返回x二进制的个数
        int res=0;
        while(x) x-=low(x),++res;
        return res;
    }
    int A[20],B[20],tot1,tot2;//分别存放二进制为0,1的数字
    int minimumIncompatibility(vector<int>& nums, int k) {
        int n=nums.size(),t=1<<n,**dp=new int*[t],sz=n/k;
        sort(nums.begin(),nums.end());
        for(int i=0;i<t;++i){
            dp[i]=new int[n];
            for(int j=0;j<n;++j) dp[i][j]=INF;
        }
        for(int i=0;i<n;++i) dp[(1<<i)][i]=0;//第1组的第一个
        for(int s=1;s<t-1;++s){
            tot1=tot2=0;
            for(int j=0;j<n;++j) (s&(1<<j))?B[++tot2]=j:A[++tot1]=j;
            if(get(s)%sz){//分配的不是每组的第一个
                for(int k1=1;k1<=tot1;++k1){//接下来选择第A[k1]个
                    for(int k2=1;nums[B[k2]]<nums[A[k1]]&&k2<=tot2;++k2){//由末尾是B[k2]来更新
                        int x=A[k1],y=B[k2];
                        dp[s|(1<<x)][x]=min(dp[s|(1<<x)][x],dp[s][y]+nums[x]-nums[y]);
                    }
                }
            }else{//分配每组的第一个
                for(int k1=1;k1<=tot1;++k1){//该组的第一个选择第A[k1]个数
                    for(int k2=1;k2<=tot2;++k2){//由前面组且末尾状态是B[k2]来更新
                        int x=A[k1],y=B[k2];
                        dp[s|(1<<x)][x]=min(dp[s|(1<<x)][x],dp[s][y]);
                    }
                }
            }
        }
        int ans=INF;
        for(int i=0;i<n;++i) ans=min(ans,dp[t-1][i]);
        return ans==INF?-1:ans;
    }
};

顺便看一看我这个大白菜写的傻逼爆搜，n!，我还真敢写。。太菜了，好久不写状压dp，忘完了都呜呜。
当然t了，只能过一半测试，，剩下的全tle.

class Solution {
#define INF 0x3f3f3f3f
public:
    int n,k,ans=INF;
    vector<vector<int> >vec;
    unordered_map<int,int>vis;
    vector<int>a;
    void dfs(int pos,int presum){//放置第pos个,前面组的不兼容性和为presum
        if(presum>=ans) return;
        if(pos==n){ans=presum;return;}
        int d=pos/(n/k);//pos在第d组
        for(int o=0;o<a.size();++o){//枚举第pos个数
            int i=a[o];
            if(!vis[i]) continue;//该数不存在或该数已经被使用完
            int flag=0;
            for(int j=0;j<vec[d].size();++j){
                if(vec[d][j]==i) {flag=1;break;}
            }
            if(!flag){//该组中不存在i
                vec[d].push_back(i),--vis[i];
                if(vec[d].size()==n/k){//该组满了,要更新presum
                    int mi=17,mx=0;
                    for(int j=0;j<vec[d].size();++j) mi=min(mi,vec[d][j]),mx=max(mx,vec[d][j]);
                    presum+=mx-mi;
                }
                dfs(pos+1,presum);
                vec[d].pop_back(),++vis[i];
            }
        }
    }
    int minimumIncompatibility(vector<int>& b, int k) {
        this->k=k,this->a=b,n=a.size();
        sort(a.begin(),a.end());
        for(int i=0;i<n;++i) if(++vis[a[i]]>k) return -1;
        vector<int>tmp;
        for(int i=1;i<=k;++i) vec.push_back(tmp);//共k组
        dfs(0,0);
        return ans;
    }
};