数学 & 位运算

 直线上最多的点数

给定一个二维平面，平面上有 n 个点，求最多有多少个点在同一条直线上。

示例 1:

输入: [[1,1],[2,2],[3,3]]
输出: 3
解释:
^
|
|        o
|     o
|  o  
+------------->
0  1  2  3  4

示例 2:

输入: [[1,1],[3,2],[5,3],[4,1],[2,3],[1,4]]
输出: 4
解释:
^
|
|  o
|     o        o
|        o
|  o        o
+------------------->
0  1  2  3  4  5  6

这道题的解题思路是利用斜率来判断两点在不在同一条直线上，时间复杂度为O（n2）。因为会有斜率为无穷大的情况（x值相等），所以判断dy和dx是否相等，dy和dx需要化简，求它们的公倍数。同时要考虑重复的点的情况。

class Solution {
public:
    int maxPoints(vector<vector<int>>& points) {
        int n = points.size();
        int count = 0;
        for(int i = 0; i < n; i++)
        {
            int duplicates = 1;
            map<pair<int, int>, int> num;
            for(int j = i + 1; j < n; j++)
            {
                if(points[i][0] == points[j][0] && points[i][1] == points[j][1])
                {
                    duplicates++; //计算重复的点的个数
                    continue;
                }
                int dx = points[i][0] - points[j][0];
                int dy = points[i][1] - points[j][1];
                int d = gcd(dx, dy);//计算公倍数
                num[{dy/d, dx/d}]++;
            }
            count = max(count, duplicates);
            for(auto it = num.begin(); it != num.end(); it++)
            {
                count = max(count, it->second+duplicates);
            }
        }
        return count;
            
    }
    
    int gcd(int a, int b)
    {
        return (b == 0) ? a : gcd(b, a % b);
    }
};

分数到小数

给定两个整数，分别表示分数的分子 numerator 和分母 denominator，以字符串形式返回小数。

如果小数部分为循环小数，则将循环的部分括在括号内。

示例 1:

输入: numerator = 1, denominator = 2
输出: "0.5"

示例 2:

输入: numerator = 2, denominator = 1
输出: "2"

示例 3:

输入: numerator = 2, denominator = 3
输出: "0.(6)"

这道题的问题在于怎么去判断结果是不是无限循环小数，这里采用余数来判断，余数如果出现重复，就可以判断出现了无限循环小数。

class Solution {
public:
    string fractionToDecimal(int numerator, int denominator) {
        if(numerator==INT_MIN && denominator==-1)//边界条件，没法直接除，因为除完结果溢出
            return "2147483648";
        if(numerator==-1 && denominator==INT_MIN)//边界条件，都是int类型，没法除
            return "0.0000000004656612873077392578125";
        int div = numerator / denominator, remainder = numerator % denominator;
        string ret = "";
        if(double(numerator) / double(denominator) < 0)//两个数符号不相同
        {
            if(div == 0)//相除等于0，前面要加一个负号，大于0不用加
                ret = '-' + to_string(div);
            else
                ret = to_string(div);
        }
        else//两个数符号相同
            ret = to_string(div);
        if(remainder == 0)//余数为0直接返回
            return ret;
        ret = ret + '.';
        remainder = abs(remainder);
        denominator = abs(denominator);
        unordered_map<int, int> num;
        num[remainder] = ret.size();//记录余数的位置
        while(remainder != 0)//余数不为0继续除
        {
            remainder = remainder*10;
            div = remainder / denominator;
            remainder = remainder % denominator;
            ret = ret + to_string(div);
            if(num.count(remainder))//出现相同的余数，将小数点后的不循环的小数和
                 //循环的小数连起来
            {
                int start = num[remainder], end = ret.size();
                ret = ret.substr(0, start) + '(' + ret.substr(start, end-start)+')';
                return ret;
            }
            num[remainder] = ret.size();
        }

        return ret;
    }
};

 阶乘后的零

给定一个整数 n，返回 n! 结果尾数中零的数量。

示例 1:

输入: 3
输出: 0
解释: 3! = 6, 尾数中没有零。

示例 2:

输入: 5
输出: 1
解释: 5! = 120, 尾数中有 1 个零.

阶乘结尾的0的个数，要判断里面5的个数，同时要注意25有两个5，125有3个5，，，，一直叠加

class Solution {
public:
    int trailingZeroes(int n) {
        int count = 0;
        for(long i = 5; i <= n; i=i*5)
        {
            count = count + n/i;
        }
        return count;
    }
};

颠倒二进制位

颠倒给定的 32 位无符号整数的二进制位。

 

示例 1：

输入: 00000010100101000001111010011100
输出: 00111001011110000010100101000000
解释: 输入的二进制串 00000010100101000001111010011100 表示无符号整数 43261596，
      因此返回 964176192，其二进制表示形式为 00111001011110000010100101000000。

示例 2：

输入：11111111111111111111111111111101
输出：10111111111111111111111111111111
解释：输入的二进制串 11111111111111111111111111111101 表示无符号整数 4294967293，
      因此返回 3221225471 其二进制表示形式为 10101111110010110010011101101001。

使用位移，将数往右移i位（0<= i <= 31）和1相与，同时将结果左移 32-i 位 与结果相或。

class Solution {
public:
    uint32_t reverseBits(uint32_t n) {
        uint32_t result = 0;
        for(int i = 0; i < 32;i++)
        {
            int temp = (n>>i) & 1;
            if(temp)
                result = result | (1 << (31-i));
        }
        return result;
    }
};

位1的个数

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

示例 1：

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

示例 2：

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

示例 3：

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

class Solution {
public:
    int hammingWeight(uint32_t n) {
        int count = 0;
        for(int i = 0; i < 32; i++)
        {
            count += (n>>i) & 1;
        }
        return count;
    }
};

 计数质数

统计所有小于非负整数 n 的质数的数量。

示例:

输入: 10
输出: 4
解释: 小于 10 的质数一共有 4 个, 它们是 2, 3, 5, 7 。

遍历，使用函数判断n是不是质数，同时将n的倍数设为非质数，超时了

class Solution {
public:
     int countPrimes(int n) {
    bool pArray[n + 1] = {0};
    int cnt = 0;
    for (int i = 2; i < n; ++i) {
      if (!pArray[i] && isPrime(i)) {
        ++cnt;
        for (int j = i; j < n; j += i) pArray[j] = true;
      }
    }
    return cnt;
  }
  bool isPrime(int m) {
    for (int i = 2; i <= sqrt(m); ++i) {
      if (m % i == 0) return false;
    }
    return true;
  }
};

第二种方法，使用埃拉托斯特尼筛法，我们从2开始遍历到根号n，先找到第一个质数2，然后将其所有的倍数全部标记出来，然后到下一个质数3，标记其所有倍数，一次类推，直到根号n，此时数组中未被标记的数字就是质数。我们需要一个n长度的bool型数组来记录每个数字是否被标记，长度为n的原因是题目说是小于n的质数个数，并不包括n。

class Solution {
public:
    int countPrimes(int n) 
    {
        int count = 0;
        vector<bool> prime(n, true);
        for(int i = 2; i < n; i++)
        {
            if(prime[i])
            {
                count++;
            }
            for(int j = 2; i*j < n ; j ++)
                prime[i*j] = false;       
        }
        return count;
    }
};

缺失数字

给定一个包含 0, 1, 2, ..., n 中 n 个数的序列，找出 0 .. n 中没有出现在序列中的那个数。

示例 1:

输入: [3,0,1]
输出: 2

示例 2:

输入: [9,6,4,2,3,5,7,0,1]
输出: 8

class Solution {
public:
    int missingNumber(vector<int>& nums) {
        int n = nums.size();
        int sum = 0;
        for(int i = 0; i <= n; i++)
            sum += i;
        for(int i = 0; i < n; i++)
            sum -= nums[i];
        return sum;
    }
};

3的幂

给定一个整数，写一个函数来判断它是否是 3 的幂次方。

示例 1:

输入: 27
输出: true

示例 2:

输入: 0
输出: false

示例 3:

输入: 9
输出: true

示例 4:

输入: 45
输出: false

使用循环或者递归

class Solution {
public:
    bool isPowerOfThree(int n) {
        if(n == 3 || n == 1)
            return true;
        else if(n > 3)
        {
            if(n % 3 == 0)
                return isPowerOfThree(n/3);
            else
                return false;
        }
        return false;
    }
};


class Solution {
public:
    bool isPowerOfThree(int n) {
        if(n < 1)
            return false;
        while(n > 1)
        {
            int remain = n % 3;
            if(remain != 0)
                return false;
            n = n / 3;
        }
        return true;
    }
};

第二种方法：使用对数，一个数是3的次方，那么以3为底n的对数一定是个整数。实现上可利用换底公示

class Solution {
public:
    bool isPowerOfThree(int n) {
        if(n < 1)
            return false;
        double temp = log10(n) / log10(3.0);
        if(int(temp) - temp == 0)
            return true;
        return false;
    }
};