Question

假设您有一个 n 数字列表。您可以选择 m 整数（让我们调用整数 a ）。对于每个整数 a ，请删除包含范围[ a - x，a + x ]内的每个数字，其中 x 是一个数字。可以清除列表的 x 的最小值是什么？

例如，如果您的数字列表是

1 3 8 10 18 20 25

和m = 2，答案是x = 5.

你可以选择两个整数5和20.这将清除列表，因为它删除了[5-5,5 + 5]和[20-5,20 + 5]之间的每个数字。

我该如何解决这个问题？我认为解决方案可能与动态编程有关。我不想要蛮力方法解决方案。

代码非常有用，最好是Java或C ++或C.

Answer 1

提示

假设您有列表

1 3 8 10 18 20 25

并想知道如果x等于2，将需要多少组来覆盖该集合。

您可以通过选择第一个整数为1 + x（1是列表中的最小数字）以贪婪的方式解决此问题。这将覆盖最多1 + x + x = 5的所有元素。然后只需重复此过程，直到涵盖所有数字。

所以在这种情况下，下一个未覆盖的数字是8，所以我们选择8 + x = 10并覆盖第二组中最多10 + x = 12的所有数字。

同样，第三组将涵盖[18,24]，第四组将涵盖[25,29]。

x的这个值需要4组。这太多了，所以我们需要增加x然后重试。

您可以使用二分法来识别覆盖m组中所有数字的x的最小值。

Answer 2

有效算法可以是（假设列表已排序） - ＆gt;

我们可以将列表视为＆＃39; m＆＃39;整数。
现在为每个小组计算＆＃39; last_element - first_element + 1＆＃39;，并将此值的最大值存储在变量中，例如＆＃39; ans＆＃39;。
现在＆＃39; x＆＃39;的价值是＆＃39; ans / 2＆＃39;。

我希望很清楚这个算法是如何工作的。

Answer 3

递归解决方案：

首先，你需要一个估计，你可以分成m组，然后估计（x）必须是〜（更好 - 下元素）/ 2 * m。估计的（x）可能是一个解决方案。如果有更好的解决方案，它在所有组中的x均低于预期（x）！你可以用第一组检查它，然后递归重复。问题在减少，直到你只有一个组：最后一个，你知道你的新解决方案是否更好，如果有更好的，你可以用它来丢弃另一个更糟糕的解决方案。

private static int estimate(int[] n, int m, int begin, int end) {
    return (((n[end - 1] - n[begin]) / m) + 1 )/2;
}

private static int calculate(int[] n, int m, int begin, int end, int estimatedX){
    if (m == 1){
        return estimate(n, 1, begin, end);
    } else {
        int bestX = estimatedX;
        for (int i = begin + 1; i <= end + 1 - m; i++) {
            // It split the problem:
            int firstGroupX = estimate(n, 1, begin, i);
            if (firstGroupX < bestX){
                bestX = Math.min(bestX, Math.max(firstGroupX, calculate(n, m-1, i, end, bestX)));
            } else {
                i = end;
            }
        }
        return bestX;
    }
}

public static void main(String[] args) {
    int[] n = {1, 3, 8, 10, 18, 20, 25};
    int m = 2;
    Arrays.sort(n);
    System.out.println(calculate(n, m, 0, n.length, estimate(n, m, 0, n.length)));
}

修改

长号版本：主要想法，它搜索＆＃34; islands＆＃34;距离并将问题分成不同的岛屿。喜欢分而治之，它分发了“m＆＃39;进入岛屿。

private static long estimate(long[] n, long m, int begin, int end) { return (((n[end - 1] - n[begin]) / m) + 1) / 2; } private static long calculate(long[] n, long m, int begin, int end, long estimatedX) { if (m == 1) { return estimate(n, 1, begin, end); } else { long bestX = estimatedX; for (int i = begin + 1; i <= end + 1 - m; i++) { long firstGroupX = estimate(n, 1, begin, i); if (firstGroupX < bestX) { bestX = Math.min(bestX, Math.max(firstGroupX, calculate(n, m - 1, i, end, bestX))); } else { i = end; } } return bestX; } } private static long solver(long[] n, long m, int begin, int end) { long estimate = estimate(n, m, begin, end); PriorityQueue<long[]> islands = new PriorityQueue<>((p0, p1) -> Long.compare(p1[0], p0[0])); int islandBegin = begin; for (int i = islandBegin; i < end -1; i++) { if (n[i + 1] - n[i] > estimate) { long estimatedIsland = estimate(n, 1, islandBegin, i+1); islands.add(new long[]{estimatedIsland, islandBegin, i, 1}); islandBegin = i+1; } } long estimatedIsland = estimate(n, 1, islandBegin, end); islands.add(new long[]{estimatedIsland, islandBegin, end, 1}); long result; if (islands.isEmpty() || m < islands.size()) { result = calculate(n, m, begin, end, estimate); } else { long mFree = m - islands.size(); while (mFree > 0) { long[] island = islands.poll(); island[3]++; island[0] = solver(n, island[3], (int) island[1], (int) island[2]); islands.add(island); mFree--; } result = islands.poll()[0]; } return result; } public static void main(String[] args) { long[] n = new long[63]; for (int i = 1; i < n.length; i++) { n[i] = 2*n[i-1]+1; } long m = 32; Arrays.sort(n); System.out.println(solver(n, m, 0, n.length)); }

Answer 4

我认为这同样是集群化的问题。例如，您可以使用k-means聚类算法：对m个类进行初始列表的分区，对于x，得到最大大小除以两个获得的类。

Answer 5

1）关于算法的时间和空间复杂性，你应该研究最佳案例，平均案例和最坏情况的复杂性。

2）我认为DavidPérezCabrera有正确的想法。我们假设平均情况（如下面的伪代码）

3）让整数列表用l

表示

    keepGoing = true
    min_x = ceiling(l[size-1]-l[0])/(2m)

    while(keepGoing)
    {
        l2 = l.copy
        min_x = min_x-1
        mcounter = 1

        while(mcounter <= m)
        {
            firstElement = l2[0]
//  This while condition will likely result in an ArrayOutOfBoundsException
//  It's easy to fix this.

            while(l2[0] <= firstElement+2*min_x)
            {   remove(l2[0])   }
            mcounter = mcounter+1
        }
        if(l2.size>0)
            keepGoing = false
    }
    return min_x+1

4）考虑

l = {1, 2, 3, 4, 5, 6, 7}, m=2 (gives x=2)
l = {1, 10, 100, 1000, 10000, 100000, 1000000}, m=2
l = {1, 10, 100, 1000, 10000, 100000, 1000000}, m=3

找到最窄间隔的算法，其中m将覆盖一组数字

5 个答案:

提示