Question

我仔细阅读了所有子集和主题，但仍然存在针对以下问题实现算法的问题。

给定N个整数的数组A（N <= 20）其中

一[1] - ; = 20
值不必是唯一的

和整数K（K <= 20）。

规则：

等于K的数组项目用K“覆盖”。
如果两个或多个数组的总和等于K，则也包括这些数字。
数组中的每个数字只能被覆盖一次。

示例：

N = 6，整数：1,1,2,3,4,5

K = 4

可能的覆盖范围：

覆盖
- 4被覆盖。
- 1,1,2被覆盖为1 + 1 + 2 = 4.
覆盖
- 4被覆盖。
- 1,3覆盖为1 + 3 = 4.

K = 5

可能的覆盖范围：

覆盖
- 5被覆盖。
- 1,1,3涵盖为1 + 1 + 3 = 5.
覆盖
- 5被覆盖。
- 1,4被覆盖为1 + 4 = 5.
- 2,3被覆盖为2 + 3 = 5.

目标：

对于给定的数组A和整数K，找到所有可能的“覆盖范围”。我需要所有的覆盖范围，而不仅仅是覆盖大多数数组项目的覆盖范围。

我尝试了两种方法：

Brut force算法。检查所有可能尺寸的所有可能子集都有效，但即使只有10个数字也需要花费太多时间。我需要它在不超过500毫秒的时间内完成。
首先，我按降序对数组进行排序。然后，对于每个可能数量的子和，我创建“槽”。我遍历数组并按照以下规则将数字放入插槽中：
- 如果数字的总和等于K，则将数字放入广告位。
- 将数字放入所有插槽总和最少的插槽中。
- 将数字放入槽中，使得壁橱总和为所有槽的K.

嗯，第二种方法可以正常运行。但我发现没有找到一些覆盖范围的情况。

如果有人提出解决这个问题的想法，我将不胜感激。

我希望我能很好地解释这个问题。

感谢。

Answer 1

我没有现成的答案，但我建议你看一下'Bin packing problem'，这可能对我有用。

主要问题是找到给出数字K的所有可能的总和。所以试试这个：

Collection All_Possible_Sums_GivingK;

find_All_Sums_Equal_To_K(Integer K, Array A)
{
    /* this function after finding result
    add it to global Collection AllPossibleSumsGivingK; */
    find_All_Elements_Equal_To_K(Integer K, Array A); 

    Array B = Remove_Elements_Geater_Or_Equal_To_K(Integer K, Array A);

    for all a in A {
        find_All_Sums_Equal_To_K(Integer K-a, Array B-a) 
    }
}

Answer 2

我从先前给出的不同子集和变量的答案中修改了这个：https://stackoverflow.com/a/10612601/120169

我在这里使用上述数字在K = 8的情况下运行它，其中我们在两个“覆盖范围”之一的两个不同位置重复使用1。让我知道它对你有用。

public class TurboAdder2 {
    // Problem inputs
    // The unique values
    private static final int[] data = new int[] { 1, 2, 3, 4, 5 };
    // counts[i] = the number of copies of i
    private static final int[] counts = new int[] { 2, 1, 1, 1, 1 };
    // The sum we want to achieve
    private static int target = 8;

    private static class Node {
        public final int index;
        public final int count;
        public final Node prevInList;
        public final int prevSum;
        public Node(int index, int count, Node prevInList, int prevSum) {
            this.index = index;
            this.count = count;
            this.prevInList = prevInList;
            this.prevSum = prevSum;
        }
    }

    private static Node sums[] = new Node[target+1];

    // Only for use by printString and isSolvable.
    private static int forbiddenValues[] = new int[data.length];

    private static boolean isSolvable(Node n) {
        if (n == null) {
            return true;
        } else {
            while (n != null) {
                int idx = n.index;
                // We prevent recursion on a value already seen.
                // Don't use any indexes smaller than lastIdx
                if (forbiddenValues[idx] + n.count <= counts[idx]) {
                    // Verify that none of the bigger indexes are set
                    forbiddenValues[idx] += n.count;
                    boolean ret = isSolvable(sums[n.prevSum]);
                    forbiddenValues[idx] -= n.count;
                    if (ret) {
                        return true;
                    }
                }
                n = n.prevInList;
            }
            return false;
        }
    }

    public static void printString(String prev, Node n, int firstIdx, int lastIdx) {
        if (n == null) {
            printString(prev +" |", sums[target], -1, firstIdx);
        } else {
            if (firstIdx == -1 && !isSolvable(sums[target])) {
                int lidx = prev.lastIndexOf("|");
                if (lidx != -1) {
                    System.out.println(prev.substring(0, lidx));
                }
            }
            else {
                while (n != null) {
                    int idx = n.index;
                    // We prevent recursion on a value already seen.
                    // Don't use any indexes larger than lastIdx
                    if (forbiddenValues[idx] + n.count <= counts[idx] && (lastIdx < 0 || idx < lastIdx)) {
                        // Verify that none of the bigger indexes are set
                        forbiddenValues[idx] += n.count;
                        printString((prev == null ? "" : (prev + (prev.charAt(prev.length()-1) == '|' ? " " : " + ")))+data[idx]+"*"+n.count, sums[n.prevSum], (firstIdx == -1 ? idx : firstIdx), idx);
                        forbiddenValues[idx] -= n.count;
                    }
                    n = n.prevInList;
                }
            }
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < data.length; i++) {
            int value = data[i];
            for (int count = 1, sum = value; count <= counts[i] && sum <= target; count++, sum += value) {
                for (int newsum = sum+1; newsum <= target; newsum++) {
                    if (sums[newsum - sum] != null) {
                        sums[newsum] = new Node(i, count, sums[newsum], newsum - sum);
                    }
                }
            }
            for (int count = 1, sum = value; count <= counts[i] && sum <= target; count++, sum += value) {
                sums[sum] = new Node(i, count, sums[sum], 0);
            }
        }
        printString(null, sums[target], -1, -1);
    }
}

子集和的变体

2 个答案: