本文是 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]ab的值。

解题思路:异或的性质。

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;
}
};

[leetcode] 位操作题解-2的更多相关文章

  1. [leetcode] 位操作题解

    子集 题目[78]:给定一组不含重复元素的整数数组 nums,返回该数组所有可能的子集(幂集). 示例: 输入: nums = [1,2,3] 输出: [ [3],   [1],   [2],   [ ...

  2. LeetCode OJ 题解

    博客搬至blog.csgrandeur.com,cnblogs不再更新. 新的题解会更新在新博客:http://blog.csgrandeur.com/2014/01/15/LeetCode-OJ-S ...

  3. Leetcode 简略题解 - 共567题

    Leetcode 简略题解 - 共567题     写在开头:我作为一个老实人,一向非常反感骗赞.收智商税两种行为.前几天看到不止两三位用户说自己辛苦写了干货,结果收藏数是点赞数的三倍有余,感觉自己的 ...

  4. LeetCode 算法题解 js 版 (001 Two Sum)

    LeetCode 算法题解 js 版 (001 Two Sum) 两数之和 https://leetcode.com/problems/two-sum/submissions/ https://lee ...

  5. leetcode & lintcode 题解

    刷题备忘录,for bug-free 招行面试题--求无序数组最长连续序列的长度,这里连续指的是值连续--间隔为1,并不是数值的位置连续 问题: 给出一个未排序的整数数组,找出最长的连续元素序列的长度 ...

  6. LeetCode一句话题解

    深度优先搜索 人生经验 1. 需要输出所有解.并由于元素集有重复元素,要求返回的结果需要去重的情况,可考虑使用值对应数量的map,然后分别考虑依次取不同数量该值的可能. LeetCode39 题目:给 ...

  7. LeetCode 中等题解(3)

    34 在排序数组中查找元素的第一个和最后一个位置 Question 给定一个按照升序排列的整数数组 nums,和一个目标值 target.找出给定目标值在数组中的开始位置和结束位置. 你的算法时间复杂 ...

  8. LeetCode 中等题解(1)

    16 最接近的三数之和 Question 给定一个包括 n 个整数的数组 nums 和 一个目标值 target.找出 nums 中的三个整数,使得它们的和与 target 最接近.返回这三个数的和. ...

  9. leetcode个人题解——two sum

    这是leetcode第一题,通过较为简单. 第一题用来测试的,用的c,直接暴力法过, /** * Note: The returned array must be malloced, assume c ...

随机推荐

  1. JavaScript 执行环境以及作用域链

    执行环境(execution context,为简单起见,有时也称为"环境")是 JavaScript 中最为重要的一个概念.执行环境定义了变量或函数有权访问的其他数据,决定了它们 ...

  2. 自动清理IIS log 日志脚本

    系统环境:windows server 2012 r2 IIS 版本:IIS8 操作实现清理IIS log File 脚本如下: @echo off ::自动清理IIS Log file set lo ...

  3. Java入门教程十二(集合与泛型)

    在 Java 中数组的长度是不可修改的.然而在实际应用的很多情况下,无法确定数据数量.这些数据不适合使用数组来保存,这时候就需要使用集合. Java 的集合就像一个容器,用来存储 Java 类的对象. ...

  4. 【读书笔记】https://source.android.google.cn/compatibility/tests?hl=en

    AuthorBlog:秋城https://www.cnblogs.com/houser0323/ Android Platform Testing This content is geared tow ...

  5. 聊一聊MyBatis 和 SQL 注入间的恩恩怨怨

    整理了一些Java方面的架构.面试资料(微服务.集群.分布式.中间件等),有需要的小伙伴可以关注公众号[程序员内点事],无套路自行领取 更多优选 一口气说出 9种 分布式ID生成方式,面试官有点懵了 ...

  6. LeetCode python实现题解(持续更新)

    目录 LeetCode Python实现算法简介 0001 两数之和 0002 两数相加 0003 无重复字符的最长子串 0004 寻找两个有序数组的中位数 0005 最长回文子串 0006 Z字型变 ...

  7. 从头认识js-DOM1

    前面说过一个完整的js实现,包括ECMAScript,BOM,DOM三部分,现在就来讲讲DOM的有关知识. DOM(文档对象模型)是针对HTML和XML文档的一个API(应用程序接口).DOM描绘来一 ...

  8. 前端每日实战:119# 视频演示如何用纯 CSS 创作一个接扎啤的动画(内含2个视频)

    效果预览 按下右侧的"点击预览"按钮可以在当前页面预览,点击链接可以全屏预览. https://codepen.io/comehope/pen/rZeOQp 可交互视频 此视频是可 ...

  9. Flask架构管理及特点(重要)

    正文 程序包结构 ——————————————————————————————————flask文件夹结构 其中:app为程序包,Flask程序保存在这个包中migrations文件夹包含数据库迁移脚 ...

  10. Windows10 JDK1.8安装及环境变量配置

    一.下载JDK1.8: 下载地址:https://www.oracle.com/java/technologies/javase-jdk8-downloads.html  二.安装步骤: 我们通常选择 ...