力扣刷题日记

给定一个非负整数 n ，请计算 0 到 n 之间的每个数字的二进制表示中 1 的个数，并输出一个数组。

示例 1:
输入: n = 2
输出: [0,1,1]
解释:
0 --> 0
1 --> 1
2 --> 10

示例 2:
输入: n = 5
输出: [0,1,1,2,1,2]
解释:
0 --> 0
1 --> 1
2 --> 10
3 --> 11
4 --> 100
5 --> 101

说明 :
0 <= n <= 10⁵

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

解法1：暴力解法

最简单的思路，将 0 - n 范围内的整数都转换为二进制，纪录二进制表示中1的个数，即暴力解法。

下面给出十进制转二进制的C++代码：

#include<iostream>
#include<vector>
using namespace std;

vector<int> ret;
void DecimalToBinary(int a) {
	while (a) {
		ret.push_back(a % 2);
		a /= 2;
	}
}

int main()
{
	int n;
	cin >> n;
	DecimalToBinary(n);
	reverse(ret.begin(),ret.end());
	for (int x : ret)
		cout << x;
	cout << endl;
	
	return 0;
}

本题的C++代码如下：

class Solution {
public:
    vector<int> countBits(int n) {
		vector<int> ret;
		for(int i = 0; i <= n; ++i){
			ret.push_back(DecimalToBinary(i));
		}
		return ret;
    }

	int DecimalToBinary(int a) {
	int num = 0;
	while (a) {
		if((a % 2) == 1)
			num++;
		a /= 2;
	}
	return num;
    }
};

时间复杂度：O(n*log(n))；空间复杂度：O(1)，除了返回的数组以外，空间复杂度为常数。

解法2：位运算

利用右移和与运算进行解题，C++代码如下：

class Solution {
public:
    vector<int> countBits(int n) {
        vector<int> ret(n + 1);
        for(int i = 0; i <= n; ++i){
        	//0 <= n <= 10^5, 用17位二进制可以表示; 简单起见可以改为32，但是要多循环好多次
        	for(int j = 0; j < 17; ++j)
        		ret[i] += (i >> j) & 1;
        }
        return ret;
    }
};

时间复杂度：O(n*17)；空间复杂度：O(1)。

解法3：动态规划

奇数的二进制表示中 1 的个数比前一个偶数多 1 。
偶数的二进制表示中 1 的个数与除以 2 之后的那个数中 1 的个数相同。

转移方程如下：
dp[i] = dp[i - 1] + 1, 当 i 为奇数
dp[i] = dp[i / 2], 当 i 为偶数，此时可以这样理解： i 相当于 i / 2 左移一位，即表示二者中 1 的个数相同。

C++代码如下：

class Solution {
public:
    vector<int> countBits(int n) {
		vector<int> ret(n + 1, 0);
		for(int i = 1; i <= n; ++i){
			ret[i] = (i % 2) == 1 ? ret[i - 1] + 1 : ret[i / 2];
			// i % 2 == i & 1 ; i / 2 == i >> 1
			//ret[i] = (i & 1) == 1 ? ret[i - 1] + 1 : ret[i >> 1];
		}
		return ret;
    }
};

时间复杂度：O(n)；空间复杂度：O(1)。

参考了力扣大佬的题解，可以对转移方程进行合并：
dp[i] = dp[i / 2] + i % 2;
由 dp[i] = dp[i - 1] + 1, 当 i 为奇数，可得 i - 1 为偶数，那么 dp[i - 1] = dp[(i - 1) / 2] = dp[i / 2]。因此上述两个转移方程可以合并为一。（膜拜大佬）
代码没有多少改动，如下：

class Solution {
public:
    vector<int> countBits(int n) {
		vector<int> ret(n + 1, 0);
		for(int i = 1; i <= n; ++i){
			ret[i] = ret[i >> 1] + (i & 1); //注意要加后边的小括号, & 运算优先级较低
		}
    }
};

运算符及其优先级

算术运算符：+（加）、-（减）、*（乘）、/（除）、%（取余）以及组合使用的++（自增）和–（自减）。
关系运算符：>（大于）、>=（大于等于）、<（小于）、<=（小于等于）、==（等于）、!=（不等于）。
逻辑运算符：逻辑与（&&）、逻辑或（||）和逻辑非（!）。
条件运算符（三目运算符）：符号为（?:），语法为<表达式1> ? <表达式2> : <表达式3>。
位运算符：&（按位与）、|（按位或）、^（按位异或）、~（取反）、>>（二进制右移）、<<（二进制左移）。
赋值运算符：=、+=、-=、*=、/=、%=、<<=、>>=、&=、^=、|=。

运算符优先级见下表（从上往下，优先级依次降低）：

练习：在不使用算术运算符或比较运算符的情况下检查两个数字是否相等

class Solution{
public:
    void isEqual(int a, int b){
        if (a ^ b)
            cout << a << " 和 " << b << " 不相等\n";
        else
            cout << a << " 和 " << b << " 相等\n";
    }
};