每日刷题-leetcode-338. 比特位计数

算法题目

338. 比特位计数
给定一个非负整数 num。对于 0 ≤ i ≤ num 范围中的每个数字 i ，计算其二进制数中的 1 的数目并将它们作为数组返回。

示例 1:

输入: 2
输出: [0,1,1]
示例 2:

输入: 5
输出: [0,1,1,2,1,2]
进阶:

给出时间复杂度为O(n*sizeof(integer))的解答非常容易。但你可以在线性时间O(n)内用一趟扫描做到吗？
要求算法的空间复杂度为O(n)。
你能进一步完善解法吗？要求在C++或任何其他语言中不使用任何内置函数（如 C++ 中的 __builtin_popcount）来执行此操作。

算法思路

以下通过四部来分析这道题目

• [√ ]模拟：模拟题目的运行
• [√ ] 规律：尝试总结出题目的一般规律和特点
• [√ ] 匹配：找到符合这些特点的数据结构与算法
• [√ ] 边界：考虑特殊情况

1模拟

例1：输入2：
0的二进制是 0000，1的个数是0
1的二进制是0001，1的个数是1，
2的二进制是 0010，1的个数是1，
所以输出是【0,1,1】

例2：输入5：
0的二进制是 0000，1的个数是0
1的二进制是0001，1的个数是1，
2的二进制是 0010，1的个数是1，
3的二进制是 0011，1的个数是2
4的二进制是0100，1的个数是1，
5的二进制是 0101，1的个数是2，
所以输出是【0,1,1,2,1,2】

2规律

但是我们不能通过这种方式来统计每个十进制数中统计二进制个数为1的个数呀
有一个常识，但是可能很多人都不知道的，那就是 n = n&(n-1) ,直到 n = 0 的时候，统计执行了几次，也就是n中有多少个1的个数。
这个可以简单的证明一下

现在已例2为例，计算5的二进制1中的个数：
m = 5&4 = 0101 & 0100 = 0100 = 4 第一次
m = 4 & 3 = 0100 & 0011 = 0000 = 0 第二次

所以 m = 5 中的二进制1的个数就是2

3匹配

我们可以写出简单的伪代码

count = 0;
while(m != 0){
	count++;
	m = m & (m - 1);
}

4边界条件

好像没有特别的

算法实现1

    /**
     * 统计十进制中二进制中有1的个数，使用  m &(m-1),直到结果是0的次数
     *
     * @param num
     * @return
     */
    public static int[] countBits(int num) {
        int[] ans = new int[num+1];
        for (int i = 0; i <= num;i++){
            int count = 0;
            int m = i;
            while (m != 0){
                count++;
                m = m & (m-1);
            }
            ans[i] = count;
        }
        return ans;
    }

优化思路

如果我们再次去看刚才的案例，
计算2的时候
m = 2 & 1 = 0

计算3的时候
m = 3 & 2 = 2
m = 2 & 1 = 0

计算5的时候
m = 5 & 4 = 4
m = 4 & 3 = 0

我们发现没有，会出现重复的计算的，觉不觉得很像递归，而且有很多重复的计算，所以可以一种技巧，也就是备忘录,也就是将中间结果给记录起来，如果下次再次遇到，就不需要重新计算了

  /**
     * 思考，使用动态规划实现操作，可以使用 备忘录，将相同的元素存储起来，就不需要频繁的统计了
     *
     * @param num
     */
    public static int[] countBits1(int num) {
        int[] ans = new int[num+1];
        for (int i = 0; i <= num;i++){
            int count = 0;
            int m = i;
            while (m != 0){
            // 做了一个优化，如果之前已经统计过了，
                if(ans[m] != 0){
                    count = ans[m] + 1;
                    break;
                }
                count++;
                m = m & (m-1);
            }
            ans[i] = count;
        }
        return ans;
    }

哎：刚才的优化，有没有很像动态规划的操作
已知，我们需要统计 i 的1中的个数，但是，如果我们已知了 i-1的1的个数的话，只需要加1就可以了

假设 int[] dp = new int[num + 1], dp[i] 表示 i 中 二进制为1的个数，但是如果我们已知了 dp[i-1] 的值的话，那么 dp[i] = dp[i-1] + 1
所以，可以得到如下解法

    /**
     * 以上的代码可以简化成 如下
     * @param num
     * @return
     */
    public static int[] countBits2(int num) {
        int[] ans = new int[num+1];
        for (int i = 1; i <= num;i++){
           ans[i] = ans[i&(i-1)]+1;
        }
        return ans;
    }