LeetCode 初级 其他问题

位1的个数

• 编写一个函数，输入是一个无符号整数，返回其二进制表达式中数字位数为 ‘1’ 的个数（也被称为汉明重量）。
• 示例 1：

  输入：00000000000000000000000000001011
  输出：3
  解释：输入的二进制串 00000000000000000000000000001011 中，共有三位为 '1'。
  

• 示例 2：

  输入：00000000000000000000000010000000
  输出：1
  解释：输入的二进制串 00000000000000000000000010000000 中，共有一位为 '1'。
  

• 示例 3：

  输入：11111111111111111111111111111101
  输出：31
  解释：输入的二进制串 11111111111111111111111111111101 中，共有 31 位为 '1'。
  

• 提示：
  • 请注意，在某些语言（如 Java）中，没有无符号整数类型。在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。
  • 在 Java 中，编译器使用二进制补码记法来表示有符号整数。因此，在上面的 示例 3 中，输入表示有符号整数 -3。
• 进阶:
  • 如果多次调用这个函数，你将如何优化你的算法？

解答

• 方法一: bitset法

  int bybitset(uint32_t n){
          bitset<32> b(n);
          return b.count();
      }
  

• 方法二: 位移法

int byand(uint32_t n){
        int bits=0;
        for(int i=0;i<32;++i){
            bits += n&1;
            n >>= 1;
        }
        return bits;
    }

• 方法三: 尾数法
  • 思路:
    • 考虑二进制数1100和1011以及相应关系1011=1100-1和1100&1011=1000
    • 具体的关系: 二进制减法只跟最后一个1相关,减法的结果为将最后一个1置0以及将后面的0置1
  • CODE

  int byleftone(uint32_t n){
          int bits=0;
          while(n){
              ++bits;
              n&=n-1;
          }
          return bits;
      }
  

汉明距离

• 两个整数之间的汉明距离指的是这两个数字对应二进制位不同的位置的数目。
• 给出两个整数 x 和 y，计算它们之间的汉明距离。
• 注意：
  • 0 ≤ x, y < 231.
• 示例:

  输入: x = 1, y = 4
  输出: 2
  解释:
  	1   (0 0 0 1)
  	4   (0 1 0 0)
  	       ↑   ↑
  上面的箭头指出了对应二进制位不同的位置。
  

解

• 方法一: bitset

  class Solution {
  public:
      int hammingDistance(int x, int y) {
          bitset<32>a(x^y);
          return a.count();
      }
  };
  

帕斯卡三角形(杨辉三角)

• 给定一个非负整数 numRows，生成杨辉三角的前 numRows 行。
  
• 在杨辉三角中，每个数是它左上方和右上方的数的和。
• 示例:

  输入: 5
  输出:
  [     [1],
      [1,1],
     [1,2,1],
    [1,3,3,1],
   [1,4,6,4,1]]
  

解

class Solution {
public:
    vector<vector<int>> generate(int numRows) {
        /* // 迭代法
        if(numRows==0){return {};}
        if(numRows==1){return {{1}};}
        vector<vector<int>> next = generate(numRows-1);
        vector<int> t;
        auto m=(*(next.end()-1)).begin();
        t.push_back(1);
        for(int i=0;i<next.back().size()-1;++i){
            t.push_back((*m)[i]+(*m)[i+1]);
        }
        t.push_back(1);
        next.push_back(t);
        return next;
        */
        return dynamic_plan(numRows);
    }
    vector<vector<int>> dynamic_plan(int numRows) {
        vector<vector<int>> result;
        if(numRows==0){return result;}
        result.push_back({{1}}); // 1
        for(int idx=1;idx<numRows; ++idx){
            result.push_back(vector<int>());
            result.back().push_back(1);
            
            for(int i=0;i<result[idx-1].size()-1;++i){
                result.back().push_back(result[idx-1][i]+result[idx-1][i+1]);
            }
            
            result.back().push_back(1);
        }
        return result;
    }
};