剑指offer（专项突破）---整数

总目录：剑指offer（专项突破）---目录-CSDN博客 

1.整数的基础知识

LCR 001. 两数相除 - 力扣（LeetCode）

题解：模拟 + 快速幂

除法本质上就是减法，题目要求我们计算出两个数相除之后的取整结果，其实就是计算被除数是多少个除数加上一个小于除数的数构成的。但是一次循环只能做一次减法，效率太低会导致超时，可借助快速幂的思想进行优化。

需要注意的是，由于题目明确要求最大只能使用 32 位有符号整数，所以需要将除数和被除数同时转换为负数进行计算。因为转换正数可能会导致溢出，如当被除数为 INT32_MIN 时，转换为正数时会大于 INT32_MAX。

假设被除数为 a，除数为 b，则时间复杂度为 O(loga×logb)，空间复杂度 O(1)。

class Solution 
{
public:
    int divide(int a, int b) 
    {
        if (b == 1) 
            return a;
        if (a == INT_MIN && b == -1)
            return INT_MAX;

        bool sign = (a > 0 && b > 0) || (a < 0 && b < 0);
        a = a > 0 ? -a : a;
        b = b > 0 ? -b : b;

        int ans = 0;
        while (a <= b)
        {
            int x = b;
            int cnt = 1;

            while (x >= (INT_MIN >> 1) && a <= (x << 1)) 
            {
                x <<= 1;
                cnt <<= 1;
            }
            
            ans += cnt;
            a -= x;
        }

        return sign ? ans : -ans;
    }
};

2.二进制

LCR 002. 二进制求和 - 力扣（LeetCode）

题解：模拟

用一个变量 carry 记录当前的进位，用两个指针 i 和 j 分别指向 a 和 b 的末尾，从末尾到开头逐位相加即可。

时间复杂度 O(max(m,n))，其中 m 和 n 分别为字符串 a 和 b 的长度。空间复杂度 O(1)。

class Solution 
{
public:
    string addBinary(string a, string b) 
    {
        string ans;
        int i = a.size() - 1, j = b.size() - 1;
        
        for (int carry = 0; i >= 0 || j >= 0 || carry; -- i, -- j) 
        {
            carry += (i >= 0 ? a[i] - '0' : 0) + (j >= 0 ? b[j] - '0' : 0);
            ans.push_back((carry % 2) + '0');
            carry /= 2;
        }
        
        reverse(ans.begin(), ans.end());

        return ans;
    }
};

LCR 003. 比特位计数 - 力扣（LeetCode）

题解：动态规划

我们定义 f[i] 表示整数 i 的二进制表示中 1 的个数。那么对于一个整数 i，它的二进制表示中 1 的个数为 f[i∧(i−1)]+1，其中 i∧(i−1) 是将 i 的二进制表示中的最低位的 1 变成 0 之后的数，显然 i∧(i−1)<i，且 f[i∧(i−1)] 已经被计算出来了，因此我们可以得到状态转移方程：

时间复杂度 O(n)，其中 n 是题目给定的整数。忽略答案数组的空间消耗，空间复杂度 O(1)。

class Solution 
{
public:
    vector<int> countBits(int n) 
    {
        vector<int> f(n + 1);
        
        for (int i = 1; i <= n; ++i)
            f[i] = f[i & (i - 1)] + 1;

        return f;
    }
};

LCR 004. 只出现一次的数字 II - 力扣（LeetCode）

题解：位运算

统计所有数字中每个位上出现的 1 的个数，然后对 3 取模。如果某一位上的出现的 1 的个数无法被 3 整除，说明只出现一次的数字在该位上是 1，否则是 0。

时间复杂度 O(n×log⁡M)，其中 n 是数组 nums 的长度，而 M 是数组中元素的最大值。空间复杂度 O(1)。

class Solution 
{
public:
    int singleNumber(vector<int>& nums) 
    {
        int ans = 0;

        for (int i = 0; i < 32; ++i) 
        {
            int cnt = 0;

            for (int x : nums)
                cnt += (x >> i) & 1;

            cnt %= 3;
            ans |= cnt << i;
        }
        
        return ans;
    }
};

LCR 005. 最大单词长度乘积 - 力扣（LeetCode）

题解：位运算+枚举

由于题目限定了字符串中只包含英语的小写字母，因此每个字符串可以用一个 32 位整数表示，该整数的每个二进制位都是 0 或 1，分别对应字符串的每个字母是否出现。这样一来，我们判断两个字符串是否含有相同字符，只需要将对应的整数进行按位与运算，即可得到一个新的整数，如果新的整数的二进制表示中的每一位都是 0，就说明两个字符串不含有相同的字符。

具体地，我们用一个长度为 n 的整数数组 mask 表示每个字符串对应的整数，其中第 i 个元素 mask[i] 表示字符串 words[i] 对应的整数。对于任意两个下标 i 和 j，如果 mask[i] 和 mask[j] 按位与运算的结果为 0，就说明 words[i] 和 words[j] 不包含相同字符。由于需要找到长度乘积的最大值，因此我们可以枚举所有的 0≤i<j<n，并计算 words[i] 和 words[j] 的长度乘积，最终得到长度乘积的最大值。

时间复杂度 O(n×(n+∣S∣))，空间复杂度 O(n)。其中 n 是数组 words 的长度，而∣S∣是字符串的最大长度。

class Solution 
{
public:
    int maxProduct(vector<string>& words) 
    {
        int n = words.size();
        vector<int> mask(n);

        for (int i = 0; i < n; ++ i)
            for (char c : words[i])
                mask[i] |= 1 << (c - 'a');

        int ans = 0;
        for (int i = 0; i < n; ++ i)
            for (int j = i + 1; j < n; ++ j)
                if ((mask[i] & mask[j]) == 0)
                    ans = max(ans, static_cast<int>(words[i].size() * words[j].size()));

        return ans;
    }
};

小结

整数在计算机中使用二进制形式表示，每位不是0就是1。位运算是对二进制整数的运算，包括与运算、或运算、非运算、异或运算、左移运算和右移运算。只有深刻理解每种位运算的特点才能在需要的时候灵活地应用合适的位运算解决相应的问题。