《LeetCode之每日一题》：50.汉明距离总和

Posted 2021-06-23 是七喜呀！

汉明距离总和

• 有关题目
• • 题解

题目链接： 汉明距离总和

有关题目

提示：

1 <= nums.length <= 10^5
0 <= nums[i] <= 10^9

两个整数的 汉明距离 指的是这两个数字的二进制数对应位不同的数量。

给你一个整数数组 nums，请你计算并返回 nums 中任意两个数之间汉明距离的总和。

示例 1：

输入：nums = [4,14,2]
输出：6
解释：在二进制表示中，4 表示为 0100 ，14 表示为 1110 ，2表示为 0010 。（这样表示是为了体现后四位之间关系）
所以答案为：
HammingDistance(4, 14) + HammingDistance(4, 2) + 
HammingDistance(14, 2) = 2 + 2 + 2 = 6

示例 2：

输入：nums = [4,14,4]
输出：4

提示：

1 <= nums.length <= 10^5
0 <= nums[i] <= 10^9

题解

法一：通过汉明距离来计算汉明距离总和（未通过）

class Solution {
public:
    int countdifone(int x,int y)
    {
        long long ans = x ^ y;
        int count = 0;
        while(ans)
        {
            ans &= ans - 1;//这个地方不知道为啥跑不过去
            count++;
        }
        return count;
    }
    int totalHammingDistance(vector<int>& nums) {
        int res = 0;
        for (int i = 0 ; i < nums.size(); i++)
        {
            for (int j = i + 1; j < nums.size(); i++)
            {
                res += countdifone(nums[i],nums[j]);
            }
        }
        return res;
    }  
};

法二：逐位统计

思路：
计算汉明距离时，我们考虑的是同一比特位上的值是否不同，而不同比特位之间是互不影响的

汉明距离总和满足：One * Zero 即计算数组中元素同一比特位上的1和0的个数
其中Zero = nums.size() - One;

代码一：

class Solution {
public:
    int totalHammingDistance(vector<int>& nums) {
        vector<int> One(32,0);
        vector<int> Zero(32,0);//当然我们也可以memset(Zero,0,sizeof(Zero));
        int ans = 0;
        for (int i = 0 ; i < 32; i++)
        {
            for (int num : nums)
            {
                if ((num >> i) & 1 == 1)
                    ++One[i];
                else
                    ++Zero[i];
            }
            ans += One[i] * Zero[i];
        }
        return ans;
    }
};

代码二：

由于每一位”0“出现的个数和"1"出现的个数之和为nums.size()，因此，我们可以省掉一个数组

class Solution {
public:
    int totalHammingDistance(vector<int>& nums) {
        vector<int> Zero(32,0);//当然我们也可以memset(Zero,0,sizeof(Zero));
        int ans = 0;
        for (int i = 0 ; i < 32; i++)
        {
            for (int num : nums)
            {
                if (((num >> i) & 1) != 1)
                     ++Zero[i];
            }
            ans += Zero[i] * (nums.size() - Zero[i]);
        }
        return ans;
    }
};

代码三：

数组本身预处理完成之后，是不需要重复使用之前的空间的，因此，我们可以压缩一下空间

class Solution {
public:
    int totalHammingDistance(vector<int>& nums) {
        int sum = 0;
        int n = nums.size();
//        由题干给我们的条件我们知道
//数组中的最大元素为10^9 < 2^30 所以我们只需要将比特位遍历到29就可了
        for (int i = 0; i < 30; i++)
        {
            int One = 0;
            for (auto num : nums)
            {
                One += (num >> i) & 1;
            }
            sum += One * (n - One);
        }
        return sum;
    }
};