比特位计数（暴力位运算/直接数/动态规划）

该题让我想到了之前做过的一道“将十进制数字转成二进制数字”的一道题，所以我有了法1

法1:暴力位运算

想法很简单，把我们需要的每一个数字的二进制形式（电脑中每一个数字本来就是二进制形式）总共有多少个1，再填入数组即可

class Solution {
public:
vector<int> countBits(int n) {
	int cn = 17;//2^16=65536 差不多达到该题的数据最大范围
	int num_1 = 0;//计算1的个数
	int i,num;
	vector<int> ans;
	for ( i = 0; i <= n; i++)
	{
		num = i;//注意这里要使用num代替i，避免死循环
		cn = 17;
		num_1 = 0;
		while (cn--)
		{
			if (num & 1 )//每次对num二进制形式的最右边的数字判断是不是1
			{
				num_1++;
			}
			num = num >> 1;//右移1位（相当于去除刚刚判断的那一位）
		}
		ans.push_back(num_1);//将对应1的个数填入数组
	}
	return ans;
}
};

 法2:直接数

直接数出每一个数字的二进制形式中1的个数（与上面法1思路一致，只不过我们不用遍历全部比特位），这里利用Brian Kernighan 算法解决，实际上，别看该算法看起来好像很“高大上”，其核心只是利用了一种位运算——x & (x-1)    该种位运算可以将某一个二进制数字最右边出现的1变成0

例如对10（1010）使用该位运算，则相当于10（1010） &    9（1001） 我们得到 1000（二进制），即将1010（最右边的1删除了）

因此我们利用该位运算直接计算每个数字二进制形式中1的个数即可

class Solution {
public:
    int count1(int x)
    {
        int ones=0;
        while(x)//直到这个数字全部1都变成0
        {
            x=x&(x-1);//去掉最右边出现的1
            ones++;//计数
        }
        return ones;
    }
    vector<int> countBits(int n) {
        vector<int> ans(n+1);
        for(int i=0;i<=n;i++)
        {
            ans[i]=count1(i);//填入数组
        }
        return ans;
    }
};

动态规划在该题有三种形式的实现形式（我愣是一种没想出来）

到这里我们就可以利用我们的入门动态规划之三步走

第一步实际上题目已经实现了，即我们返回的一维数组，其中下标代表每个数字，每个元素代表每个数字二进制形式中1的个数

关键就是这第二步，寻找数组元素之间的关系式

法3.动态规划1（利用奇偶性）

        1: 0001     3:  0011      0: 0000
        2: 0010     6:  0110      1: 0001
        4: 0100     12: 1100      2: 0010 
        8: 1000     24: 11000     3: 0011
        16:10000    48: 110000    4: 0100
        32:100000   96: 1100000   5: 0101

我们不妨将一些数字先列出来，找找规律，如图，我们发现

对于偶数的二进制，数字i的二进制1的个数f(i) = f(i/2) ,因为 i/2 本质上是i的二进制左移一位，低位补零，所以1的数量不变

对于奇数的二进制，我们可以将其转换成与偶数的二进制相关联的表示，与偶数的二进制表示同理，因为奇数减1为必为偶数，那么f(i) = f(i - 1) + 1，且因为奇数比它上一个偶数bit上多一个1，所以我们需要加1

因此

class Solution {
public://动态规划
    vector<int> countBits(int n) {
        vector<int>ans(n+1);//这里初始化n+1个元素为0
        for(int i=0;i<=n;i++)
        {
            if(i%2==0)//偶数
            {
                ans[i]=ans[i/2];
            }
            else if(i%2!=0)//奇数
            {
                ans[i]=ans[i-1]+1;
            }
        }
        return ans;
    }
};

这里如果要优化的话，我们可以将奇偶的判断改成用位运算

法4.动态规划2（右移）

这里是利用右移运算符与最后一个数字的关系，ans[i>>1]是之前所判断过的，且再加上被右移除掉的那个数字（用&1判断）

class Solution {
public:
    vector<int> countBits(int n) {
        vector<int>ans(n+1);//初始化n+1个元素为0
        for(int i=0;i<=n;i++)
        {
            ans[i]=ans[i>>1]+(i&1);//注意这里（i&1）的括号不可少
        }
        return ans;
    }
};

法5.动态规划3（利用右边第一个1）

由上面我们提到的Brian Kernighan 算法，即位运算 x&(x-1) 与法4同理，ans[x&(x-1)]同样是我们之前所判断过的，再加上被除去的那个数字（必定是1，因为用这个算法除去的是最右边的1）

class Solution {
public:
    vector<int> countBits(int n) {
        vector<int> ans(n+1);//初始化n+1个元素为0
        for(int i=1;i<=n;i++)
        {
            ans[i]=ans[i&(i-1)]+1;
        }
        return ans;
    }
};