Question

我有一个₁到_n的数组，每个_n包含 m 个元素。我有另一个对称 n X n 矩阵 b ，包含数组之间的距离。我想从每个数组x ₁到x _n中选择一个元素，限制为以下约束。（a ₁是一个数组，x ₁取自₁的单个值）

对于每个x _i（最初是_iu）和x _j（最初是_jv >），其中i与j不同，u和v是原始数组索引，我们有| u - v | ＆lt; = b _ij。
x ₁与x _n的总和是所有可能的此类集合的最大值。

一个例子

a1 = [1, 2, 3, 8, -1, -1, 0, -1]
a2 = [1, 2, 4, 0, -1, 1, 10, 11]

b  = |0, 2|
     |2, 0|

所选值为x ₁ = 8且x ₂ = 4.可以注意到我们没有从第二个中选择10或11，因为最接近的可能其中任何一个的值都只是0。

现在，当我只有两个数组时，我可以在O（n ²）时间在java中执行以下操作，我想，找到最大总和， 12 在这种情况下。如何为超过2个阵列实现更好的解决方案？

int[][] a = new int[][]{{1, 2, 3, 8, -1, -1, 1, -1}, {1, 2, 4, 0, -1, 1, 10, 11}};
int[][] b = new int[][]{{0, 2}, {2, 0}};
int maxVal = Integer.MIN_VALUE;
for (int i = 0; i < a[0].length; i++) {
    for (int j = Math.max(i - b[0][1], 0); j < Math.min(a[1].length, i + b[0][1]); j++) {
        maxVal = Math.max(maxVal, a[0][i] + a[1][j]);
    }
}
System.out.println("The max val: "+maxVal);

Answer 1

这里不能使用动态编程，因为没有最佳子结构：b_1n条目可能会破坏从x_1到x_ {n-1}的高价值路径。所以一般来说可能很难避免指数时间。但是，对于一组合理限制选择的b_ij，有一种直截了当的回溯方法应该具有合理的性能：

在每个步骤中，已从某些a_i中选择了一个值，但尚未从其他步骤中进行选择。（选择的数组不必是列表的前缀，甚至是连续的。）
如果已为每个数组做出选择，请返回（从此递归调用中）获得的分数。
考虑到，对于每对选定的数组和剩余的数组，后者中可供选择的索引间隔给出了前者选择距离的限制。
将每个剩余数组的这些间隔相交。如果任何交叉点为空，请拒绝此建议的选择集并回溯。
否则，选择剩余的数组，其中包含最小选项集。将每个选项添加到建议的选择集并递归。返回找到的最佳分数以及为获得它而做出的选择（如果有的话），或拒绝和回溯。

识别最受约束的阵列对性能至关重要：它构成了模糊信念传播的一种形式，有效地修剪了与先前选择所必需的当前选择不相容的未来选择。根据您期望的输入类型，根据可实现的分数进行进一步的优先级排序/修剪可能是有价值的。

我的35行Python实现，给定10x10小整数随机矩阵，b_ij为常数2，在几秒钟内运行。 b_ij = 3（允许每对数组的10个值中最多7个！）花了大约一分钟。

从比预定义距离更近的阵列中查找更高的值

1 个答案: