双数据类型的子集总和？答案

【问题标题】：Subset sum for double data-type?双数据类型的子集总和？
【发布时间】：2017-09-04 06:04:20
【问题描述】：

我有以下适用于整数的子集和代码。如何将此代码扩展为双数据类型输入？例如，当输入为 1.01、2.65、3.08、4.07、5.12（例如）且输出为 15.62（例如）时，如何扩展相同的代码。这些输入和输出是示例，即使它们不同，代码也应该可以工作。

// A Java program to count all subsets with given sum.
import java.util.ArrayList;
public class subset_sum
{
// dp[i][j] is going to store true if sum j is
// possible with array elements from 0 to i.
static boolean[][] dp;

static void display(ArrayList<Integer> v)
{
    System.out.println(v);
}

// A recursive function to print all subsets with the
// help of dp[][]. Vector p[] stores current subset.
static void printSubsetsRec(int arr[], int i, int sum,
                            ArrayList<Integer> p)
{
    // If we reached end and sum is non-zero. We print
    // p[] only if arr[0] is equal to sun OR dp[0][sum]
    // is true.
    if (i == 0 && sum != 0 && dp[0][sum])
    {
        p.add(arr[i]);
        display(p);
        p.clear();
        return;
    }

    // If sum becomes 0
    if (i == 0 && sum == 0)
    {
        display(p);
        p.clear();
        return;
    }

    // If given sum can be achieved after ignoring
    // current element.
    if (dp[i-1][sum])
    {
        // Create a new vector to store path
        ArrayList<Integer> b = new ArrayList<>();
        b.addAll(p);
        printSubsetsRec(arr, i-1, sum, b);
    }

    // If given sum can be achieved after considering
    // current element.
    if (sum >= arr[i] && dp[i-1][sum-arr[i]])
    {
        p.add(arr[i]);
        printSubsetsRec(arr, i-1, sum-arr[i], p);
    }
}

// Prints all subsets of arr[0..n-1] with sum 0.
static void printAllSubsets(int arr[], int n, int sum)
{
    if (n == 0 || sum < 0)
        return;

    // Sum 0 can always be achieved with 0 elements
    dp = new boolean[n][sum + 1];
    for (int i=0; i<n; ++i)
    {
        dp[i][0] = true;
    }

    // Sum arr[0] can be achieved with single element
    if (arr[0] <= sum)
        dp[0][arr[0]] = true;

    // Fill rest of the entries in dp[][]
    for (int i = 1; i < n; ++i)
        for (int j = 0; j < sum + 1; ++j)
            dp[i][j] = (arr[i] <= j) ? (dp[i-1][j] ||
                    dp[i-1][j-arr[i]])
                    : dp[i - 1][j];
    if (dp[n-1][sum] == false)
    {
        System.out.println("There are no subsets with" +
                " sum "+ sum);
        return;
    }

    // Now recursively traverse dp[][] to find all
    // paths from dp[n-1][sum]
    ArrayList<Integer> p = new ArrayList<>();
    printSubsetsRec(arr, n-1, sum, p);
}

//Driver Program to test above functions
public static void main(String args[])
{
    int arr[] = {1, 2, 3, 4, 5};
    int n = arr.length;
    int sum = 10;
    printAllSubsets(arr, n, sum);
}
}

输出：[4, 3, 2, 1] [5, 3, 2] [5, 4, 1]

【问题讨论】：

这个问题和 Python 有什么关系？
你不能合理地使用 double 这个算法，但是你可以缩放输入直到它们是整数。
这个算法的复杂度是多少？它是否适用于非常大或范围很广的整数（例如在放大双精度时会得到）？
@Thilo 它看起来像标准算法，所以它是伪多项式，它不喜欢宽整数。不过，他的示例输入应该没问题。
@Andreas 我认为这不适合这个问题，仅仅因为涉及浮点并不意味着它是那个著名问题的欺骗。这里问题的很大一部分是我们正在做 DP（如果我们做了明显的改变）双打作为数组的索引。

标签： java algorithm subset-sum

【解决方案1】：

我通过简单地通过计算小数位将双精度转换为整数并将其乘以 100（比如说）找到了这个问题的答案，因为算法使用加法，这种变化不会影响最终值，在这种情况下，我将最终值除以 100 到获取结果并以双精度数据类型显示

【讨论】：