【dp】-cf1188D-Make Equal

最新推荐文章于 2022-07-15 23:21:12 发布

原创最新推荐文章于 2022-07-15 23:21:12 发布 · 592 阅读

1 ·

CC 4.0 BY-SA版权

Wei个人训练专栏收录该内容

13 篇文章

订阅专栏

该博客主要介绍了一道动态规划题目，题目要求通过给定的数加上2的自然数次幂，使得所有数最终相等。博主分析了问题转化为找到一个自然数t，使得每个数加t后的二进制1的个数最小。利用动态规划方法，通过状态压缩优化了二维空间复杂度，将第二维优化为仅需要表示后面有多少个数进位，降低了复杂度。

题意

给你很多个数，操作是，选择其中一个数，让它加上2的自然数次幂，使得最后每个数相等

如

2 2 8

输出3

题解

我们考虑，最后它们会变成什么，设这个数为p，那么p一定大于等于数的最大值，设这个最大值为mx,即p=mx+t(t>=0)我们可以解决这样的一个问题，我有很多数，我要把它们都进行一些操作使得每个数都变成t

一个数变成t需要的操作数就是t减这个数的化为二进制中1的个数

所以对于这个问题我可以转化为求一个自然数t使得t+mx-a[1],t+mx-a[2],一直到t+mx-a[n]的二进制中的1的个数尽量少。

我们可以用dp来解决，dp(i,j)表示考虑到第i位，j为考虑i-1位的时候，每一个数的进位情况（状态压缩）的最优值。这样的话，复杂度太大了，为64*(2^n)。

我们考虑优化第二维，能不能用很少的东西来表示它

其实是可以的，我们假如只考虑i-1位一直到0位。排一个序，如果只有一个数进位，那么一定是最大的那个数进位，如果有2个数进位，那么一定是最大的2个数进位。那么我们第二维就不需要2^n那么多了，只需要n+1的大小，表示后面有多少个数进位。然后就可以转移了

代码

#include <bits/stdc++.h>

using namespace std;
const int maxn=1e5+100;
int k[70][maxn];
long long dp[70][maxn];
long long a[maxn],mx;
int n,sum0[maxn],sum1[maxn];
long long ans;
int main()
{
    cin>>n;
    memset(dp,0x3f,sizeof(dp));
    for(int i=1;i<=n;i++){
        cin>>a[i];
        mx=max(mx,a[i]);
    }
    for(int i=1;i<=n;i++){
        a[i]=mx-a[i];
    }
    dp[0][0]=0;
    for(int i=0;i<60;i++){
        if(i==0){
            for(int j=1;j<=n;j++)k[i][j]=j;
        }
        else {
            int cnt=0;
            for(int j=1;j<=n;j++){
                if(((a[k[i-1][j]]>>(i-1))&1)==0)k[i][++cnt]=k[i-1][j];
            }
            for(int j=1;j<=n;j++){
                if(((a[k[i-1][j]]>>(i-1))&1)==1)k[i][++cnt]=k[i-1][j];
            }
        }
        for(int j=1;j<=n;j++){
            sum0[j]=sum0[j-1];
            sum1[j]=sum1[j-1];
            if(((a[k[i][j]]>>i)&1)==1)sum1[j]++;
            else sum0[j]++;
        }
        for(int j=0;j<=n;j++){
            for(int bit=0;bit<2;bit++){
                if(bit==0){
                    int v=sum1[n-j]+sum0[n]-sum0[n-j],stage=sum1[n]-sum1[n-j];
                    dp[i+1][stage]=min(dp[i+1][stage],dp[i][j]+v);
                }
                else {
                    int v=sum0[n-j]+sum1[n]-sum1[n-j],stage=n-sum0[n-j];
                    dp[i+1][stage]=min(dp[i+1][stage],dp[i][j]+v);
                }
            }
        }
    }
    cout<<dp[60][0]<<endl;
    return 0;
}
/*
2
0 11
*/