请教一道国内面试算法题，很短，没做出来

国内面试题 没做出来...

给一个DNA序列 只包含ACGT四个字符
返回一个整数，这个整数是最短的没出现过的组合

比如 给一个字

您好！
本帖隐藏的内容需要积分高于 188 才可浏览
您当前积分为 0。
使用VIP即刻解锁阅读权限或查看其他获取积分的方式

游客，您好！
本帖隐藏的内容需要积分高于 188 才可浏览
您当前积分为 0。
VIP即刻解锁阅读权限 或 查看其他获取积分的方式
Unlock interview details and practice with AI
Curated Interview Questions from Top Companies

;不"返回1
但是CA没出现过 这个就是最短的 长度2 所以最终返回2

要求只是返回长度 所以并不需要知道具体是哪个没出现。有了input长度直接可以算出来每个长度应该有多少组合，然后每个长度分别是一个set，遍历时 A就扔1级set，AC扔C进1级set，同时AC扔二级set，以此类推，要保存每一级长度set的前一个状态，最后从1级set往上看set的size，到哪级set比理论组合size少 就返回哪级就好了。理论上是n复杂度？

用suffix tree可以时间O(n)，空间O(n)。具体就是先O(n)建树，然后从树根逐层BFS做一些判断。不过建树算法非常复杂。

其实看到ACGT，第一反应是压缩索引技术，例如FM-index (burrow wheeler transform)，不过对于这一题好像不适用。


估计面试想要的做法是把每个字符压缩为2bit编码，然后用一个32位整数编码子串（可以处理最多4*10^9长度的输入，更长的话要用64位整数）。
在编码后，就不需要用hash set了，因为压缩后的整数分布是稠密的，只需要用一个bitmap。

参考代码如下：

1. #include <cstddef>
   
2. #include <cstdint>
   
3. #include <cstdlib>
   
4. #include <cstring>
   
5. #include <iostream>
   
6. #include <string>
   
7. #include <vector>
   
8. 
   
9. // BitSet的简单实现
   
10. class BitSet {
    
11. public:
    
12.   explicit BitSet(const std::size_t num_bits)
    
13.       : data_array_size_((num_bits >> kHigherOrderShift) +
    
14.                          (num_bits & kLowerOrderMask ? 1 : 0)),
    
15.         data_array_(static_cast<std::size_t*>(std::malloc(data_array_size_ * kDataSize))) {
    
16.     std::memset(data_array_, 0, data_array_size_ * kDataSize);
    
17.   }
    
18. 
    
19.   ~BitSet() {
    
20.     std::free(data_array_);
    
21.   }
    
22. 
    
23.   inline void setBit(const std::size_t bit_num) const {
    
24.     data_array_[bit_num >> kHigherOrderShift] |= kTopBit >> (bit_num & kLowerOrderMask);
    
25.   }
    
26. 
    
27.   inline std::size_t onesCount() const {
    
28.     std::size_t count = 0;
    
29.     for (std::size_t array_idx = 0; array_idx < data_array_size_; ++array_idx) {
    
30.       count += __builtin_popcountl(data_array_[array_idx]);
    
31.     }
    
32.     return count;
    
33.   }
    
34. 
    
35. private:
    
36.   static constexpr std::size_t kDataSize = sizeof(std::size_t);
    
37.   static constexpr std::size_t kLowerOrderMask = (kDataSize << 3) - 1;
    
38.   static constexpr std::size_t kHigherOrderShift = kDataSize == 4 ? 5 : 6;
    
39.   static constexpr std::size_t kOne = 1ull;
    
40.   static constexpr std::size_t kTopBit = kOne << kLowerOrderMask;
    
41. 
    
42.   const std::size_t data_array_size_;
    
43.   std::size_t *data_array_;
    
44. };
    
45. 
    
46. int Solve(const std::string &dna) {
    
47.   // 编码索引
    
48.   std::uint32_t dna2code[128];
    
49.   memset(dna2code, 0, sizeof(dna2code));
    
50.   dna2code[(int)'a'] = dna2code[(int)'A'] = 0;
    
51.   dna2code[(int)'c'] = dna2code[(int)'C'] = 1;
    
52.   dna2code[(int)'g'] = dna2code[(int)'G'] = 2;
    
53.   dna2code[(int)'t'] = dna2code[(int)'T'] = 3;
    
54. 
    
55.   // 编码
    
56.   constexpr std::size_t kNumBitsInWord = 32;
    
57.   constexpr std::size_t kNumCodesInWord = kNumBitsInWord / 2;
    
58. 
    
59.   std::vector<std::uint32_t> words;
    
60.   std::size_t shift = 0;
    
61.   std::uint32_t word = 0;
    
62.   for (const unsigned char c : dna) {
    
63.     word |= dna2code[c] << shift;
    
64.     if (shift == kNumBitsInWord - 2) {
    
65.       words.emplace_back(word);
    
66.       shift = 0;
    
67.       word = 0;
    
68.     } else {
    
69.       shift += 2;
    
70.     }
    
71.   }
    
72.   if (shift != 0) {
    
73.     words.emplace_back(word);
    
74.   }
    
75. 
    
76. //  for (const std::uint32_t w : words) {
    
77. //    std::cout << std::bitset<32>(w) << "\n";
    
78. //  }
    
79. 
    
80.   // 枚举长度
    
81.   const std::size_t dnaL = dna.length();
    
82.   std::size_t subL = 1;
    
83.   while (true) {
    
84.     const std::size_t max_combinations = 1ull << (subL * 2);
    
85.     if (max_combinations > dnaL) {
    
86.       break;
    
87.     }
    
88. 
    
89.     // 遍历子串
    
90.     BitSet existence(max_combinations);
    
91.     const std::uint64_t sub_mask = max_combinations - 1;
    
92. 
    
93.     std::uint64_t buffer = words.front();
    
94.     for (std::size_t i = 0; i < words.size() - 2; ++i) {
    
95.       buffer |= static_cast<std::uint64_t>(words[i+1]) << kNumBitsInWord;
    
96.       for (std::size_t k = 0; k < kNumCodesInWord; ++k) {
    
97.         existence.setBit(buffer & sub_mask);
    
98.         buffer >>= 2;
    
99.       }
    
100.     }
     
101.     buffer |= static_cast<std::uint64_t>(words.back()) << kNumBitsInWord;
     
102.     const std::size_t last = dnaL % kNumCodesInWord;
     
103.     const std::size_t num_residual =
     
104.         (kNumCodesInWord + (last == 0 ? kNumCodesInWord : last) - subL + 1);
     
105.     for (std::size_t k = 0; k < num_residual; ++k) {
     
106.       existence.setBit(buffer & sub_mask);
     
107.       buffer >>= 2;
     
108.     }
     
109. 
     
110.     if (existence.onesCount() != max_combinations) {
     
111.       break;
     
112.     }
     
113.     ++subL;
     
114.   }
     
115.   return subL;
     
116. }

复制代码

yanshuo619 发表于 2017-10-29 06:58
每个元素只是跟前一个状态合起来仍set里，为啥会需要遍历呢

1. int leastLen(string str) {
   
2.         int strLen = str.length();
   
3.         int maxLen = log(strLen) / log(4);
   
4.         vector<unordered_set<string>> comb(maxLen);
   
5.         for (int i = 0; i < strLen; i++)
   
6.                 for (int j = 0; j <maxLen && i-j>=0; j++)
   
7.                         comb[j].insert(str.substr(i - j, j+1));
   
8.         int res = maxLen + 1;
   
9.         for (int i = 0; i < maxLen; i++)
   
10.                 if (comb[i].size() < pow(4, i + 1))
    
11.                         res = i + 1;
    
12.         return res;
    
13. }

复制代码

时间复杂度 nlog4(n)

补充内容 (2017-10-29 07:13):
最后那个if应该是
                if (comb[i].size() < pow(4, i + 1)) {
                        res = i + 1;
                        break;
                }

brute force 从长度2开始 生成所有的排列 看看是不是substring 如果都是 长度增加 继续 另外 如果不写code 可以用suffix tree 找一个depth最小 并且child数量小于4的node 就行

wdxh1 发表于 2017-10-28 21:35
brute force 从长度2开始 生成所有的排列 看看是不是substring 如果都是 长度增加 继续 另外 如果不写code  ...

对啊 我也是只会暴力解...

好难？！ Google的题吗

先把所有可能的组合存在hash里 然后用长度从1到length遍历？

我只能想到类似暴力解的，因为只有4个字母，所以每种length的排列组合数量你都可以直接算出来。
从最小length开始，对于某个length都新建一个hash set，用个sliding window把substring扔进set里，如果set的大小不等于你排列组合算出来的数量就直接返回当前length

补充内容 (2017-10-29 06:22):
打错，不是某个，是每个

A for 0, T for 1, C for 2, G for 3,
k tuples----->四进制数字
k=1
while(k){
取k-tuples转化为4进制，得到n-k+1长的数组
for （i=k位四进制的所有数）{数组减去i，搜索是否存在0，不存在返回k}
k++
}



补充内容 (2017-10-29 05:53):
n=length(gene)

yanshuo619 发表于 2017-10-29 06:40
要求只是返回长度 所以并不需要知道具体是哪个没出现。有了input长度直接可以算出来每个长度应该有多少组合 ...

前面有一点会产生误会，理论组合size组合数字是根据有多少元素算出来，不是input string那个长度