我将解释一种算法，该算法(我认为)应该具有N³的时间复杂度和N²的内存复杂度(N是任务数)。我将尝试首先描述它的来源以及它是如何工作的，但如果你只想要伪代码，你可以跳到最后。

步骤 1：为输入数据重新编制索引

首先，我想以矩阵(或"涂鸦")的方式表示您的输入数据。如果我从您的示例中获取一个子集：

+--------+---+---+---+---+---+---+---+---+---+----+----+----+
|        | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 |
+--------+---+---+---+---+---+---+---+---+---+----+----+----+
| Task 1 | X | X | X | X | X |   |   |   |   |    |    |    |
| Task 2 |   |   | X | X |   |   |   |   |   |    |    |    |
| Task 3 |   |   |   |   | X | X |   |   |   |    |    |    |
| Task 4 |   |   |   |   |   |   | X | X | X | X  | X  | X  |
+--------+---+---+---+---+---+---+---+---+---+----+----+----+

目前，您的数据按行编制索引：task[taskIndex] // --> time interval of this task。如果我们按列重新索引会发生什么：availableTasks[timeIndex] // --> set of tasks that can be executed at this time？

通过此数据结构的朴素实现，我们可以编写以下朴素算法(伪C++)：

int MAX_TIME = 2000000000; // 2,000,000,000
// reindexed input
std::unordered_set<int>; availableTasks[MAX_TIME];
// main algorithm
int bestTotal = -1; // result
int r1, r2; // time values to get bestTotal
// brute force: try all pair of time values:
for (int t1 = 0; t1 <= MAX_TIME-1; t1++) {
for (int t2 = t1; t2 <= MAX_TIME; t2++) {
int count = union(availableTasks[t1], availableTasks[t2]).size();
if (count > bestCount) {
r1 = t1; r2 = t2;
bestCount = count;
}
}
}

好消息：时间复杂度不再是指数级的！坏消息：

1. 巨大的内存使用：由于MAX_TIME，即使任务很少，availableTasks也会达到几GB。
2. 荒谬的执行时间：双循环大约有 2*10¹⁸次迭代。在 4Ghz CPU 上，迭代/周期为 1 次(非常乐观)，已经十多年了。

因此，任何实用的解决方案都不能暴力破解所有时间值对。

第 2 步：限制时间值候选者。

让我们举一个简单的案例，其中包含 2 个任务：

• 任务 0：[1;1 499 999]
• 任务 1： [500 000; 1 999 999]

直觉上，你会说没有必要测试 2,000,000 个时间值。您会认为有 4 个时间间隔的时间值(不包括上限)：

• 间隔 A： [1; 500 000[
间隔 B： [500 000
• ; 1 500 000[
• 间隔 C： [1 500 000; 2 000 000[
• 间隔 D： [2 000 000;MAX_TIME[

如果在同一时间间隔内选择了Ta和Tb，则我们有availableTasks[Ta] == availableTasks[Tb].所以基本上，我们只需要在每个间隔中测试一个时间值。我将选择下限来表示每个区间：1 |500,000 |1,500,000 |2,000,000。

_{注意：在数学术语中，我们通过定义等价关系来划分时间值集：t1~t2 <=> availableTasks[t1] == availableTasks[t2]，然后从每个等价类中选择一个代表性元素。}

这些代表性价值从何而来？容易：

tasks[0][0] // 1
tasks[1][0] // 500,000
tasks[0][1] + 1 // 1,500,000
tasks[1][1] + 1 // 2,000,000

第一个候选限制规则：如果我们测试集合S={tasks[*][0], tasks[*][1]+1}中的所有对，我们一定会找到最佳解决方案。

这应该已经限制了足够的值，以使算法在合理的时间内工作，但我们可以做得更简单、更快。前一组中的值可以解释如下：

1. t=tasks[k][0]：任务 k 不能在上一个间隔(以t-1结束)执行，但可以在从t开始的间隔内执行
2. t=tasks[k][1]：任务 k 可以在前一个间隔内执行(结束于t-1)，但不能在t处的间隔内执行

从这个角度来看，在情况 2 中从t开始的间隔是一个无用的候选者：除非有一个验证tasks[l][0] == tasks[k][1]+1l(意思是：在时间 t，有另一个任务变得可执行，所以 t 也落在情况 1 中)，前一个区间中的任何时间值都需要一个更好的候选(因为availableTasks[t-1]严格包含availableTasks[t])。因此：

更好的候选限制规则：如果我们测试集合S={tasks[*][0]}中的所有对，我们肯定会找到最佳解决方案。

算法(未经测试，伪C++)

生成重新索引的输入数据：

int n = 1000; //number of tasks
// availableTasks[timeIndex] : set of tasks executable at timeIndex.
// Only candidate values are stored in the map.
std::map<int, std::unordered_set<int>> availableTasks;
for ( timeCandidate : task[*][0] ) {
auto& set = availableTasks[timeCandidate];
for ( int taskIndex = 0; taskIndex < n; taskIndex++) {
if (timeCandidate in task[taskIndex]) {
set.insert(task);
}
}
}

主要算法：

int bestTotal = -1; // result
int r1, r2; // time values to get bestTotal
auto& map = availableTasks; // alias
for (auto it1=map.begin(); it1 != map.end(): it1++) {
int t1 = it1->first;
auto& set1 = it1->second;
auto it2 = it1; // copy the iterator
it2++;
for (; it2 != map.end(); it2++) {
int t2 = it2->first;
auto& set2 = it2->second;
// assuming here that union().size() can be computed in O(n) time.
int count = union(set1, set2).size();
if (count > bestCount) {
r1 = t1; r2 = t2;
bestCount = count;
}
}
}

如果这个算法有效，我认为有可能在空间和时间复杂性方面进一步完善它。但是这篇文章已经很长^^了。首先，我建议您检查此内容是否正确，以及它是否满足您的性能要求。