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

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

set长度最高为log4(n)，所以遍历每个元素时遍历log4(n)次，总的时间复杂度为nlog4(n)。

empy 发表于 2017-10-29 06:49
set长度最高为log4(n)，所以遍历每个元素时遍历log4(n)次，总的时间复杂度为nlog4(n)。

每个元素只是跟前一个状态合起来仍set里，为啥会需要遍历呢

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

k1938slll 发表于 2017-10-29 05:03
好难？！ Google的题吗

百度的 字数字数

fangdanzai 发表于 2017-10-29 05:10
先把所有可能的组合存在hash里 然后用长度从1到length遍历？

不能暴力解啊 那还有啥意思了..

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

面试完了以后我又想了一下 应该这样做是可行的

empy 发表于 2017-10-29 07:10
时间复杂度 nlog4(n)

补充内容 (2017-10-29 07:13):

substr也是需要时间的

twitter OA questions. i have seen this question last year

无量塔 发表于 2017-10-29 07:40
substr也是需要时间的

即使substr的时间复杂度是O(n),总的复杂度也不过是多乘一个log4(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. }

复制代码