Question

有一个从0-n索引的数组（即size = n）包含来自0-m的元素，其中m < n（假设m比n小100或1000倍，即m更小比n），必须重复许多元素或子数组，我们必须找到大小为1或大于1的重复子数组的数量。例如，考虑一个数组
1 2 4 1 2 4 1 5 6 3 5，这里是 1重复2次 {1}重复一次2 {1}重复一次4 {1}重复一次5 {1}重复一次1 2 {1}重复一次2 4 {1}重复一次4 1 {1}重复一次1 2 4 {1}重复一次2 4 1 {1}重复一次1 2 4 1 所以最后的答案是这些的总和，即11
任何人都可以建议一些数据结构或一个有效的算法来解决这个问题。我正在考虑散列m并注意它出现的索引值，但没有形式化它假设n,m < 10^5

Answer 1

创建一个以整数作为键的散列，以及整数作为值的可扩展列表（例如链接列表）。
通读输入列表。将每个被扫描的输入元素视为一个键;将以下元素的索引附加到关联的值列表。
现在，您重复的1个元素计数是n - | keys |
接下来，查看您的密钥。对于每个键，将原始列表的索引元素视为新的输入列表。创建一个新的哈希并继续执行步骤1.请注意，当我们存储索引时，我们将继续使用原始列表的那些。

示例：1 2 4 1 2 4 1 5 6 3 5（假设我们是零索引）。这里，n = 11。

1 - ＆gt; [1,4,7]
2 - ＆gt; [2,5]
3 - ＆gt; [10]
4 - ＆gt; [3,6]
5 - ＆gt; [8，无]
6 - ＆gt; [9]

重复的1-elts的数量是11-6 = 5。

现在，我们通过密钥。我们从1开始。索引列表是[1,4,7]，它对应于元素[2,2,5]。

2 - ＆gt; [2,5]
5 - ＆gt; [8]

这会获得3 - 2 = 1个重复的2元素列表。

等...

运行时间：输入+输出中的线性

Answer 2

我使用了基于后缀树的方法，来自Skienna's book on the design of algorithms。后缀树是一种特殊的trie tree，您可以在其中将给定字符串的每个后缀插入到特里树中。 Trie树是一种在单个树中存储多个单词的方法：根是空字符串，每个边添加一个字符。我在下面使用了一个非常简单的实现作为概念证明。

#include <iostream>
#include <string>
using std::string;
using std::cout;

class Node
{
    Node* m_descendants[10];
    int m_count;
public:
    Node()
    {
        for(int i=0; i<10; ++i)  { m_descendants[i] = nullptr; }
        m_count = 0;
    }
    void Add(const char* str) {
        // Increment number of times we've reached this node
        m_count++;

        const int firstDigit = str[0] - '0';
        if (!(0 <= firstDigit && firstDigit <= 9)) return; // recursion base case 

        // Access descendant node correponding to current digit
        Node*& descendant = m_descendants[firstDigit];
        if (descendant == 0) { // create descendant if necessary
            descendant = new Node;
        }

        // Recurse on rest of string
        descendant->Add(str +1);
    }
    void Print(const string& str, int countAdj=0) const // debug function
    {
        for(int nextDigit=0; nextDigit<10; ++nextDigit) {
            const Node* node = m_descendants[nextDigit];
            if (node) {
                const int adjustedCount = node->Count() - countAdj;
                if (adjustedCount > 0) {
                    char c = '0' + nextDigit;
                    string strWithC = str;
                    strWithC += c;
                    cout << strWithC << ": " << adjustedCount << "\n";
                    node->Print(strWithC, countAdj);
                }
            }
        }
    }
    int SumRepeated() const
    {
        int sumRepeated = 0;
        for(int nextDigit=0; nextDigit<10; ++nextDigit) {
            const Node* node = m_descendants[nextDigit];
            if (node) {
                const int repeatCount = node->Count() -1;
                if (repeatCount > 0) {
                    sumRepeated += repeatCount;
                    sumRepeated += node->SumRepeated();
                }
            }
        }
        return sumRepeated;
    }
    int Count() const { return m_count; }
};

int main(int argc, const char* argv[])
{
    // Construct
    Node* const root = new Node;
    for(const char* str = "12412415635"; *str; ++str) {
        root->Add(str);
    }

    // Print
    root->Print(string(), 1);

    cout << "Sum repeated is " << root->SumRepeated() << "\n";

    return 0; // (nodes are leaked)
}

输出

1: 2
12: 1
124: 1
1241: 1
2: 1
24: 1
241: 1
4: 1
41: 1
5: 1
Sum repeated is 11

注意这里有一个额外的重复子字符串，即1241。

正如我所说，这是概念的证明，因此，例如，您希望使用字典而不是数组来存储后代，使用更大的m。而且，即使在整体算法方面，这种实现也不是最优的：它在时间和空间上是O（n ^ 2）。您可以通过折叠没有分支的路径来优化以获得O（n）空间，并使用巧妙的构造算法来获得O（n）时间。此外，正如其他一个答案中所指出的，您不需要处理长度达原始长度一半的子字符串。

Answer 3

以下是JavaScript中的内容:(输出或多或少是即时的，我认为JavaScript是最慢的之一）：

<script>

function f (s, m) {
  var i = 0, n = s.length, c = 0, H = {}, Hi = {}
  while (i < n-1) {
    for (var j=i+1; j<=Math.min (i + 1 + m,n - 1); j++) {
      if (s[i] == s[j]) {
        var i_= i, j_= j, tmp = ''
        while (s[i_] == s[j_] && i_ < j) {
          tmp += String (s[i_])
          i_++
          j_++
        }
        var k = tmp.length - 1
        while (k >= 0) {
          if (!H[tmp]) {
            H[tmp] = 1
            Hi[tmp] = i
            c++
          }
          else if (i == Hi[tmp]) {
            H[tmp]++
            c++
          }
          tmp = tmp.substr(0,k--)
        }
      }
    }
    i++
  }
  var t1 = ''
  for (var i in H) t1 += i + ", "
  return [t1,c]
}

var a1 = [1,2,4,1,2,4,1,5,6,3,5],
    a2 = []

for (var i=0;i<100000;i++) a2.push(Math.floor(Math.random()*10))

console.log(a1 +"\n"+ f(a1,10))
console.log(f(a2,10))

</script>

输出：

1,2,4,1,2,4,1,5,6,3,5
1, 2, 4, 5, 12, 24, 41, 124, 241, ,10

["0...6358, 3582, 038, 4304, 2068, 095, 
 9252, 37866, 3786, 7866, 7893, 8701, 0669, ", 771]

找到数组中重复子数组的数量

3 个答案: