此递归算法有什么好的迭代解决方案？

Question

Problem : Given an array and a target number, print the number of ways the target number can be written as a unique combination of elements in the array.

Example :

array = {1,2,3} target = 4
4 = {2,2}, {3,1}, {1,1,1,1} //numbers can be repeatedly selected from the array.
Ans: 3 ways

Recursive Solution

F(4) = F(4-1) + F(4-2) + F(4-3)
F(4) = F(3) + F(2) + F(1)
...

Total sum is the sum of each recursive call to the function with the array value subtracted as the argument.

Conceptually recurrence can be expressed as (ironically as an iteration):

for(int i=0; i<array.length; i++)
   sum+=F(target - array[i]);

Base Cases:

F(0) = 1 //Implies sums to target
F(<0) = 0 //Implies cannot sum to target

However, even for a trivial case as above, it results in a StackOverflowError. How best to iterate the solution below:

Code

public class CombinationSum {

    private int[] array;
    private int target;

    public CombinationSum(int[] array, int target)
    {
        this.array = array;
        this.target = target;
    }

    public int recurSum(int val)
    {
        int sum = 0;

        if(val < 0 )
            return 0;
        else if(val == 0)
            return 1;
        else 
        {
            for(int i = 0; i<array.length; i++)
            {
                sum+= recurSum(target-array[i]); //heavy recursion here?

            }

            return sum;
        }
    }

    public static void main(String[] args)
    {
        int target = 4;
        int[] array = {1,2,3};

        CombinationSum cs = new CombinationSum(array, target);

        System.out.println("Number of possible combinations: "+cs.recurSum(target));
    }

}

Answer 1

Pseudo Code

F[0]=1;

for(i=1;i<=n;++i){
  F[i]=0;
  for(j=1;j<i++j){
    F[i]+=F[i-j];
  }

}

print F[n];

Answer 2

Here is a solution in Python.

#input is a list A of positive integers, and a target integer n
#output is a list of sublists of A (repeats OK!) with sum n
#permutations will appear
def make_list(A,n):
    A = list(set(A)) #eliminate repeats in A
    L = []
    if n > 0:
        for a in A:
            if type(make_list(A,n-a)) == list:
                for l in make_list(A,n-a):
                    l.append(a)
                    L.append(l)
    elif n == 0:
        L = [[]]
    else: L = -1
    return L

#returns the count of distinct lists in make_list(A,n)
def counter(A,n):
    b = []
    for l in make_list(A,n):    
        if sorted(l) not in b:
            b.append(sorted(l))
    return len(b)