zoukankan      html  css  js  c++  java
  • [Coding Made Simple] Subset Sum Problem

    Given a set of non negative integers and a target value, find if there exists a subset in the given set whose sum is target.

     Solution 1. Enumerate all possible subsets and check if their sum is the target

      The runtime of this solution is O(2^n).  This enumeration algorithm is similar with the problem Subsets. The difference is 

    that Subsets has to get all possible subsets. But this problem can terminate the check earlier if for one element arr[startIdx]

    including it in the subset and not including it both returns a false check. This is correct because for any subsets, it either has

    arr[startIdx] or does not have it.

     1 import java.util.Arrays;
     2 public class Subsets {
     3     public boolean findIfExistSubset(int[] arr, int target){
     4         if(target == 0){
     5             return true;
     6         }
     7         if(arr == null || arr.length == 0 || target < 0){
     8             return false;
     9         }
    10         Arrays.sort(arr);
    11         if(target < arr[0] || target >= arr[arr.length - 1] * arr.length){
    12             return false;
    13         }
    14         return helper(arr, 0, 0, target);
    15     }
    16     private boolean helper(int[] arr, int startIdx, int currSum, int target){
    17         if(currSum == target){
    18             return true;
    19         }
    20         if(currSum > target){
    21             return false;
    22         }
    23         if(startIdx >= arr.length){
    24             return false;
    25         }
    26         currSum += arr[startIdx];
    27         if(helper(arr, startIdx + 1, currSum, target)){
    28             return true;
    29         }
    30         currSum -= arr[startIdx];
    31         if(helper(arr, startIdx + 1, currSum, target)){
    32             return true;
    33         }
    34         return false;
    35     }
    36 }

    Solution 2. Dynamic Programming, runtime is O(arr.length * target), space complexity is O(arr.length * target)

     State: T[i][j]: if total sum j can be found from a subset from arr[0......i - 1];

    Function: T[i][j] = T[i - 1][j] || T[i - 1][j - arr[i - 1]],  if j >= arr[i - 1];  if the current target j is >= arr[i - 1], it means that we can possibly select arr[i - 1] as part of the subset. T[i][j] will be either not selecting arr[i - 1] (T[i - 1][j]) or selecting arr[i - 1] (T[i - 1][j - arr[i - 1]]);

        T[i][j] = T[i - 1][j], if j < arr[i - 1]; if j < arr[i - 1], it means we can't select arr[i - 1].

         i - 1 here indicates that for each element in arr[], it can only be selected at most once.  

    Init: T[i][0] = true for i in [0, arr.length]; this means when the target is 0, then for set arr[0.... i - 1] we always have the empty set that sums up to 0.

    Answer: T[arr.length][target]

     1 public boolean findIfExistSubsetDp(int[] arr, int target){
     2     boolean[][] T = new boolean[arr.length + 1][target + 1];
     3     for(int i = 0; i <= arr.length; i++){
     4         T[i][0] = true;
     5     }
     6     for(int i = 1; i <= arr.length; i++){
     7         for(int j = 1; j <= target; j++){
     8             if(j >= arr[i - 1]){
     9                 T[i][j] = T[i - 1][j] || T[i - 1][j - arr[i - 1]];
    10             }
    11             else{
    12                 T[i][j] = T[i - 1][j];
    13             }
    14         }            
    15     }
    16     return T[arr.length][target];
    17 }

    Optimized Dp solution with O(target) space

     1 public boolean findIfExistSubsetDp(int[] arr, int target){
     2     boolean[][] T = new boolean[2][target + 1];
     3     T[0][0] = true;
     4     for(int i = 1; i <= arr.length; i++){
     5         T[i % 2][0] = true;
     6         for(int j = 1; j <= target; j++){
     7             if(j >= arr[i - 1]){
     8                 T[i % 2][j] = T[(i - 1) % 2][j] || T[(i - 1) % 2][j - arr[i - 1]];
     9             }
    10             else{
    11                 T[i % 2][j] = T[(i - 1) % 2][j];
    12             }
    13         }            
    14     }
    15     return T[arr.length % 2][target];
    16 }

     Follow up question: 

    What about if we change the condition so that each element in the input set can be selected more than once? 

    The change needs to make is that when the current element arr[i - 1] can be selected, we don't exclude it from

    being selected again.

    T[i][j] = T[i - 1][j] || T[i][j - arr[i - 1]];  

     1 public boolean findIfExistSubsetDp(int[] arr, int target){
     2     boolean[][] T = new boolean[arr.length + 1][target + 1];
     3      for(int i = 0; i <= arr.length; i++){
     4          T[i][0] = true;
     5      }
     6      for(int i = 1; i <= arr.length; i++){
     7          for(int j = 1; j <= target; j++){
     8              if(j >= arr[i - 1]){
     9                  T[i][j] = T[i - 1][j] || T[i][j - arr[i - 1]];
    10              }
    11              else{
    12                  T[i][j] = T[i - 1][j];
    13              }
    14          }            
    15     }
    16     return T[arr.length][target];
    17 }

    Related Problems

    Subsets

    Backpack(Knapsack) problems

  • 相关阅读:
    DbUtil组件及C3P0数据库连接池组件的使用
    servlet过滤器
    JDBC实现往MySQL插入百万级数据
    学会怎样使用Jsp 内置标签、jstl标签库及自定义标签
    一种c#深拷贝方式完胜java深拷贝(实现上的对比)
    JSP三个指令及9个内置对象
    java web工程的错误页面的简单配置
    理解java Web项目中的路径问题
    web应用程序servlet的映射名称的规则及请求过程
    tomcat上servlet程序的配置与处理servlet请求过程
  • 原文地址:https://www.cnblogs.com/lz87/p/7284541.html
Copyright © 2011-2022 走看看