[leetcode] 位操作（Ⅱ）

本文是 leetcode 位操作题库的题目解析。点击每个标题可进入题目页面。

重复的DNA序列

题目：所有 DNA 都由一系列缩写为 A，C，G 和 T 的核苷酸组成，例如：“ACGAATTCCG”。在研究 DNA 时，识别 DNA 中的重复序列有时会对研究非常有帮助。编写一个函数来查找 DNA 分子中所有出现超过一次的 10 个字母长的序列（子串）。（是个好题，请耐心看完优化的部分）

示例：

输入：s = "AAAAACCCCCAAAAACCCCCCAAAAAGGGTTT"
输出：["AAAAACCCCC", "CCCCCAAAAA"]

解题思路：显然，这里的序列都是连续的，因此最多只会有 (s.length - 10) 种序列，因此采用数据结构 map<string,int> 进行计数即可。

class Solution
{
public:
    vector<string> findRepeatedDnaSequences(string s)
    {
        unordered_map<string, int> m;
        vector<string> v;
        size_t len = s.length();
        for (int i = 0; (i + 9) < len; i++)
        {
            m[s.substr(i, 10)]++;
        }

        for (auto x : m)
        {
            if (x.second > 1)
                v.push_back(x.first);
        }
        return v;
    }
};

下面考虑如何优化，因为使用字符串作为 (key) 值，效率低得令人发指（特别是使用的空间较大）。

从 leetcode 的海外版找到一个十分 geek 的 优化方案（中文也有人翻译了一下）。建议阅读一下英文原文的三点优化思路，可以看出原作者的计算机基础十分好（特别是 C++ Runtime 这一块）。

简单来说，就是优化 map 的 (key, val) 的存储：

• key ：不使用10个字符的子串作为 key 值，而是将其转化为若干比特位。
• val ：不需要完整计算子串出现的次数，只需要记录 3 种状态：出现零次，出现一次，出现多次（编码表示为00, 01, 11, 实则是出现一个1就代表出现一次，因此只需要 2 bit）。

首先对 ACGT 四种字符编码： 。

unordered_map<char, int> m = {{'A', 0}, {'C', 1}, {'G', 2}, {'T', 3}};

对于 10 个字符的子串，映射之后的值为：

for (int i = 0; i < 10; i++)
    val = (val << 2) | m[s[i]];

一个 10 字符的子串 (substr) ，只有 (4^{10}=2^{20}) 种不同的形式，经过映射为一个 20bit 的数值之后，仍然只有 (2^{20}) 种不同的值，那么在这 ([0,2^{20}-1]) 这些数值当中，我们如何记录某个值 (val) 是否出现呢？答案是使用一个 bitset<(1<<20)> bs 去记录，如果某个 val 出现，那么 bs[val]=1 (bs.set(val))。

到这一步解决了 key 的映射和存储，val 的「出现零次」和「出现一次」的问题也解决了，那么如何记录「出现多次」呢？上面已经提到，需要用到 2 bit 去记录，目前，某个 val 是否出现只用了 bs[val] 一个 bit 去记录，因此我们需要再添加一个 bitset<1<<20> bs2 ：

• 出现 0 次：bs1[val]=0, bs2[val]=0
• 出现 1 次：bs1[val]=1, bs2[val]=0
• 出现 2 次：bs1[val]=1, bs2[val]=1

class Solution
{
public:
    unordered_map<char, int> m = {{'A', 0}, {'C', 1}, {'G', 2}, {'T', 3}};
    vector<string> findRepeatedDnaSequences2(string s)
    {
        int len = s.length();
        vector<string> v;
        if (len < 10)
            return v;
        uint32_t val = 0;              //val只需要低20bit
        uint32_t mask = (1 << 20) - 1; //低20位全1
        bitset<1 << 20> s1, s2;
        for (int i = 0; i < 10; i++)
            val = (val << 2) | m[s[i]];
        s1.set(val);

        for (int i = 10; i < len; i++)
        {
            val = ((val << 2) & mask) | m[s[i]];
            if (s2[val])
                continue;
            if (s1[val])
            {
                v.push_back(s.substr(i - 9, 10));
                s2.set(val);
            }
            else
            {
                s1.set(val);
            }
        }
        return v;
    }
};

时间复杂度 (O(N)) ，对于空间的使用，bitset<1<<20> 看似很大但其实：

int main()
{
    bitset<1 << 20> s;
    cout << 2 * sizeof(s) / 1024 << endl;
}

上面程序的输出是：256 (KB) 。而使用原始字符串作为 key 值，最坏情况下有 (2^{20}) 种不同的字符串，每个字符串 10 个字节：(2^{20} cdot 10 = 10 MB) 的空间开销。

面试题专栏

下一个数

题目：下一个数。给定一个正整数，找出与其二进制表达式中1的个数相同且大小最接近的那两个数（一个略大，一个略小）。

示例：

 输入：num = 2（或者0b10）
 输出：[4, 1] 或者（[0b100, 0b1]）
 输入：num = 1
 输出：[2, -1]

解题思路：细节巨多，还没完成。「正面刚」解法如下所述。

我们先了解一个预备知识：假如某个整数中， bits[i] 为 1 ，把它移动到 bits[i + d] 的位置（bits[i+d] 这个位置为 0 ），那么前后数值的变化为 (Delta = 2^{i+d} - 2^i = 2^{i} cdot (2^d-1)) 。

对于 01000100111011010101000010111110 ，找比它「最近大」的，肯定是把 1 向高位移动，并遵循以下原则： 把位于尽可能低位的 1 提高到尽可能低位的 0 （并要求两个位置尽可能地接近） 。也就是：

   0100010011101101010100001 0  1 11110
=> 0100010011101101010100001 1  0 11110

但是这是不是就是要找的「最近大」的数值呢？显然不是，经过「放大」之后，还能适当缩小：

   0100010011101101010100001 0  1 11110
=> 0100010011101101010100001 1  0 11110
=> 0100010011101101010100001 1  0 01111

把位于被移动的1后面的那些1全部「挤」到最低位，显然这才是答案。

下面来看如何找「最近小」。操作必定是把高位的 1 向低位移动。并且还是遵循：把位于尽可能低位的 1 降低到尽可能低位的 0 （并要求两个位置尽可能地接近）。比如：

   00001010110000
=> 00001010101000

这是比较简单的情况，考虑到 ...00001111 这种形式，如果省略号的位置都没有 1 ，那么显然找不到。如果有 1 ，那就是 ...10...0000111 这种形式，比如 0100 0000 1111，那么：

   0100 0000 1111
=> 0010 0000 1111

同理，这里我们是缩小了，但其实还应该适当「放大」才是我们需要的答案：

   0100 0000 1111
=> 0010 0000 1111
=> 0011 1110 0000

把被移动的1后面的那些1全部排到后面。

完整代码：

class Solution
{
public:
    vector<int> findClosedNumbers(int n)
    {
        vector<int> v({-1, -1});
        if (n == 0 || n == 0x7fffffff)
            return v;
        v[0] = bigger(n), v[1] = smaller(n);
        cout << v[0] << ' ' << v[1] << endl;
        return v;
    }
    int bigger(int n)
    {
        bitset<32> bits(n);
        int i = 0;
        while (bits[i] == 0)
            i++;
        int t = i;
        while (i < 31 && bits[i] == 1)
            i++;
        if (i >= 31)
            return -1;
        int ones = i - t;
        bits[i] = 1, bits[i - 1] = 0;
        uint32_t mask = ~((1 << (i - 1)) - 1);
        bits &= mask;
        i = 0;
        while (--ones)
            bits[i++] = 1;
        return (int)bits.to_ulong();
    }
    int smaller(int n)
    {
        bitset<32> bits(n);
        int i = 0;
        while (bits[i] == 0)
            i++;
        int j = i - 1;
        if (j != -1)
        {
            // ...1000 的形式
            bits[i] = 0, bits[j] = 1;
            return (int)bits.to_ulong();
        }
        else
        {
            // 到这里说明 i=0
            // ..0...1 的形式
            // 计算连续 i 个 1
            //肯定有 0, 不必担心越界
            while (bits[i] == 1)
                i++;
            int ones = i;

            while (i < 31 && bits[i] == 0)
                i++;
            // i=31, 可确定n=1
            if (i == 31)
                return -1;
            bits[i] = 0, bits[i - 1] = 1;
            uint32_t mask = ~((1 << (i - 1)) - 1);
            bits &= mask;
            while (ones--)
                bits[i - 2] = 1, i--;
            return (int)bits.to_ulong();
        }
    }

    void printBits(int num)
    {
        bitset<32> bits(num);
        cout << bits << endl;
    }
};

还有一个「正面刚」的方法，遍历，计算 1 的个数，如果与 n 相等就找到了，到 0 说明没找到，则是默认值 -1 。

class Solution
{
public:
    vector<int> findClosedNumbers(int n)
    {
        vector<int> v({-1, -1});
        if (n == 0 || n == 0x7fffffff)
            return v;
        int t = n;
        int bench = hammingWeight(n);
        while (--t)
        {
            if (hammingWeight(t) == bench)
            {
                v[1] = t;
                break;
            }
        }
        t = n;
        while (++t)
        {
            if (hammingWeight(t) == bench)
            {
                v[0] = t;
                break;
            }
        }
        return v;
    }

    int hammingWeight(uint32_t n)
    {
        int t = 0;
        while (n)
            t++, n &= (n - 1);
        return t;
    }
};

翻转数位

题目：给定一个32位整数 num，你可以将一个数位从0变为1。请编写一个程序，找出你能够获得的最长的一串1的长度。

示例

输入: num = 1775(11011101111)
输出: 8
输入: num = 7(0111)
输出: 4

解题思路：暴力解法，遍历每个0，翻转，计算1的个数，取最大。

#define bit(n, i) (((n) >> (i)) & 0x1)
class Solution
{
public:
    int reverseBits(int num)
    {
        int len = 0;
        bitset<32> bits(num);
        for (int i = 0; i < 32; i++)
        {
            if (bits[i] == 0)
            {
                bits[i] = 1;
                len = max(len, count((uint32_t)bits.to_ulong()));
                bits[i] = 0;
            }
        }
        return len;
    }

    int count(uint32_t n)
    {
        if (((int)n) == -1)
            return 32;
        if (n & (n - 1) == 0)
            return 1;
        int idx = 0;
        int len = 0;
        while (idx < 32 && bit(n, idx) == 0)
            idx++;

        for (int i = idx; i < 32; i++)
        {
            if (bit(n, i) == 0)
            {
                cout << idx << endl;
                len = max(len, i - idx);
                while (i < 32 && bit(n, i) == 0)
                    i++;
                idx = i;
            }
        }
        return len;
    }
};

交换数字

题目：编写一个函数，不用临时变量，直接交换numbers = [a, b]中a与b的值。

解题思路：异或的性质。

class Solution {
public:
    vector<int> swapNumbers(vector<int>& numbers) {
        numbers[0]^=numbers[1]; //n[0]^n[1]
        numbers[1]^=numbers[0]; //n[1]=n[1]^n[0]^n[1]=n[0]
        numbers[0]^=numbers[1]; //n[0]=n[0]^n[1]^[0]=n[1]
        return numbers;
    }
};