zoukankan      html  css  js  c++  java
  • [leetcode-338-Counting Bits]

    Given a non negative integer number num. For every numbers i in the range 0 ≤ i ≤ num
    calculate the number of 1's in their binary representation
    and return them as an array.
    Example:
    For num = 5 you should return [0,1,1,2,1,2].
    Follow up:
    It is very easy to come up with a solution with run time O(n*sizeof(integer)).
    But can you do it in linear time O(n) /possibly in a single pass?
    Space complexity should be O(n).
    Can you do it like a boss? Do it without using any builtin function like
    __builtin_popcount in c++ or in any other language.

    思路:

    Question:
    Given a non negative integer number num. For every numbers i in the range 0 ≤ i ≤ num calculate the number of 1's in their binary representation and return them as an array.

    Thinking:

    1. We do not need check the input parameter, because the question has already mentioned that the number is non negative.

    2. How we do this? The first idea come up with is find the pattern or rules for the result. Therefore, we can get following pattern

    Index : 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

    num : 0 1 1 2 1 2 2 3 1 2 2 3 2 3 3 4

    Do you find the pattern?

    Obviously, this is overlap sub problem, and we can come up the DP solution. For now, we need find the function to implement DP.

    dp[0] = 0;

    dp[1] = dp[0] + 1;

    dp[2] = dp[0] + 1;

    dp[3] = dp[1] +1;

    dp[4] = dp[0] + 1;

    dp[5] = dp[1] + 1;

    dp[6] = dp[2] + 1;

    dp[7] = dp[3] + 1;

    dp[8] = dp[0] + 1;
    ...

    This is the function we get, now we need find the other pattern for the function to get the general function. After we analyze the above function, we can get
    dp[0] = 0;

    dp[1] = dp[1-1] + 1;

    dp[2] = dp[2-2] + 1;

    dp[3] = dp[3-2] +1;

    dp[4] = dp[4-4] + 1;

    dp[5] = dp[5-4] + 1;

    dp[6] = dp[6-4] + 1;

    dp[7] = dp[7-4] + 1;

    dp[8] = dp[8-8] + 1;
    ..

    Obviously, we can find the pattern for above example, so now we get the general function

    dp[index] = dp[index - offset] + 1;

    Coding:

    vector<int> countBits(int num)
         {
             vector<int> ret(num + 1, 0);
             ret[0] = 0;
             int offset = 1;
             for (int i = 1; i <= num;i++)
             {
                 if (i == offset*2)
                 {
                     offset *= 2;
                 }
                 ret[i] = ret[i - offset] + 1;
             }
             return ret;
         }

    另外:

    倒过来想,一个数 * 2 就是把它的二进制全部左移一位,也就是说 1的个数是相等的。

    那么我们可以利用这个结论来做。

    res[i /2] 然后看看最低位是否为1即可(上面*2一定是偶数,这边比如15和14除以2都是7,但是15时通过7左移一位并且+1得到,14则是直接左移)

    所以res[i] = res[i >>1] + (i&1)

    class Solution {
    public:
        vector<int> countBits(int num) {
            vector<int> res = vector<int>(num+1,0);
            for(int i=1;i<=num;i++){
                res[i] = res[i >> 1] + (i & 1);
            }
            return res;
        }
    };

    参考:
    https://discuss.leetcode.com/topic/40195/how-we-handle-this-question-on-interview-thinking-process-dp-solution

    https://www.hrwhisper.me/leetcode-counting-bits/

     
  • 相关阅读:
    GDB+QEMU调试内核模块(实践篇)
    排序算法的python实现
    Linux命令行相关
    操作系统与网络
    计算机组成原理
    有了自己的技术博客
    if 和 if else
    十效率换算成十六进制
    <<左移 >>右移 >>>无符号右移 &与运算 |或运算 ^异或运算 ~反码
    // &与 // |或 // ^异或 // !非 // &&短路 // ||短路
  • 原文地址:https://www.cnblogs.com/hellowooorld/p/6877175.html
Copyright © 2011-2022 走看看