Question

我有一个算法问题。

假设我们有一系列标签，如下面的

E1 B1 B2 E2 B3 E3

索引没有任何意义，我使用它们来区分不同的B和E.

该任务列举了可以构造的所有可能的BE对序列。

例如，从上面的例子我可以构建

B1 E2

B1 E3

B1 E2 B3 E3

B2 E2

B2 E3

B2 E2 B3 E3

B3 E3

我希望我找到所有这些，序列的长度（对的数量）当然不受限制。对总是B E，其中B表示开头，E表示结束。

问题是我无法想出一些通用的东西。

Answer 1

认为这应该可以解决问题。它当然没有优化。

var labels = ['E1', 'B1', 'B2', 'E2', 'B3', 'E3'];
var results = [];
var temp_results = [];
var i, j, index, new_item;

// Utility function to add an array inside an other array if it isn't in it yet.
function pushIfNotExists(container, insert) {
  var found = false;
  var i, different;
  container.forEach(function(item) {
    if (item.length === insert.length) {
      different = false;
      for (i = 0; i < item.length; i++) {
        if (item[i] !== insert[i]) {
          different = true;
        }
      }
      if (!different) {
        found = true;
      }
    }
  });

  if (!found) {
    container.push(insert);
  }
}

// This loops makes the basic (2 labels) sequences.
for (i = 0; i < labels.length; i++) {
  if (labels[i].charAt(0) === 'B') {
    for (var j = i + 1; j < labels.length; j++) {
      if (labels[j].charAt(0) === 'E') {
        temp_results.push([labels[i], labels[j]]);
      }
    }
  }
}

// This loops combines the sequences
while (temp_results.length > results.length) {
  results = temp_results.slice(0);
  for (i = 0; i < results.length; i++) {
    index = labels.indexOf(results[i][results[i].length - 1]);
    for (j = index + 1; j < results.length; j++) {
      if (labels.indexOf(results[j][0]) > index) {
        new_item = results[i].concat(results[j]);
        if (temp_results.indexOf(new_item) === -1) {
          pushIfNotExists(temp_results, new_item);
        }
      }
    }
  }
}

console.log(results);

Answer 2

一些（不完整的）想法......

   E1 B1 B2 E2 B3 E3
pos 1  2  3  4  5  6

posB = indices of B  // 2, 3, 5
posE = indices of E  // 1, 4, 6

output = {}     

append_list_of_len_2():
    for i = 1 to len( posB ):
       j = first elem in posE greater than i
       for( ; j < len( posE ); j++ ):
           output.append( {i, j} )

算法枚举序列

2 个答案: