How would I calculate the worst case time complexity of this recursive function?

Question

I don't believe this is efficient at all. I'm trying to create a faster implementation of this (preferably binary search or use of Sets perhaps), but for now this is where I'm at. I'm not sure if it's relevant, but I created a count variable just to see how many times the method was being called. It came to 577 times.

This is the "Subset Sum" algorithm, where I have to display all the subsets that add to a target sum, in this case 3165. It wasn't specifically stated that this problem was the algorithm, but I realized it was indeed the same concept.

My question is how can I know how efficient this program is, and are the method calls an indicator?

public class SubsetSumAlgorithm {

    static int count = 0;

    public static void main(String[] args) {

        int[] array = {26, 39, 104, 195, 403, 504, 793, 995, 1156, 1673};

        System.out.println("COLLECTIONS IN ARRAY THAT ADD TO 3165: ");
        findCollections(array, 0, 0, 3165, "");
        System.out.println("Method called " + count + " times.");//method calls
    }

    public static void findCollections(int[] array, int index, int currentPosition, int sum, String collection) {

        count++; //<---COUNTING THE METHOD CALLS HERE

        if (array.length < index || currentPosition > sum) {
            return;
        }
        //if sum is found, add to subset
        for (int i = index; i < array.length; i++) {
            if (currentPosition + array[i] == sum) {
                System.out.println(collection + " " + array[i]);
            }
            //otherwise, call the method again
            else if (currentPosition + array[i] < sum) {//recursive call
                findCollections(array, i + 1, currentPosition + array[i], sum, collection + " " + array[i]);
            }
        }
    }
}

And here is the output:

COLLECTIONS IN ARRAY THAT ADD TO 3165: 
26 195 793 995 1156
195 504 793 1673
Method called 577 times.

Answer 1

My question is how can I know how efficient this program is, and are the method calls an indicator?

The only way to derive the asymptotic run time of an algorithm is to actually get your hands dirty and do it manually. With this being said, trying to keep track of method calls while your algorithm runs isn't a reliable or reasonable way to derive the runtime of an algorithm.

To start trying to figure out how fast or slow your algorithm runs, we can start by deriving the recurrence from analyzing the run time of each line:

1    public static void findCollections(int[] array, int index, int currentPosition, int sum, String collection) {
2        if(array.length < index || currentPosition > sum)
3            return;
4        for(int i = index; i < array.length; i++) {
5            if(currentPosition + array[i] == sum) {
6                System.out.println(collection + " " + array[i]);
7            }
8            else if(currentPosition + array[i] < sum) {
9                findCollections(array, i + 1, currentPosition + array[i], sum, collection + " " + array[i]);
10           }
11       }
12   }

...

1    -
2    1
3    1
4    n+1
5    n
6    n
7    -
8    n
9    n*T(n-1)
10   -
11   -
12   -

One we've analyzed each line, we can derive the recurrence:

    T(n) = n*T(n-1) + 4n + 3
 => T(n) = n*T(n-1) + 4n + Θ(1)
 => T(n) = n*T(n-1) + 4n

Since we cannot use the Master Theorem, and attempting a recursion tree would get very messy and confusing very fast with this particular recurrence, we can solve this recurrence using the substitution method. We will set our initial guess to be 2^n since it looks to me like it'll probably be exponential:

Upper Bound O(2^n)

---

This would imply that

T(n) ≤ c * 2^n

if this proposition holds true, this means we also know that

T(n-1) ≤ c * 2^(n-1)

Therefore, we can now write our recurrence and attempt to prove our guess:

    c * 2^n ≥ n * (c * 2^(n-1)) + 4n
 => c * 2^n ≥ c * n * 2^(n-1) + 4n

this holds true for all n > 0 | c = 1, therefore T(n) = O(2^n)

Lower Bound Ω(2^n)

---

This would imply that

T(n) ≥ c * 2^n

if this proposition holds true, this means we also know that

T(n-1) ≥ c * 2^(n-1)

Therefore, we can now write our recurrence and attempt to prove our guess:

    c * 2^n ≤ n * (c * 2^(n-1)) + 4n
 => c * 2^n ≤ c * n * 2^(n-1) + 4n

this holds true for all n > 0 | c = 5000, therefore T(n) = Ω(2^n)

Conclusion Θ(2^n)

---

Since we've prove that the algorithm is both O(2^n) and Ω(2^n), therefore it is also, by definition, Θ(2^n). So basically, your algorithm's time complexity is Θ(2^n) which is very slow as it is exponential.

Answer 2

The number of calls to a Method are a decent indicator if you want to find the trend experimentally. You would need to run the function many times with varying inputs, collect the data, graph it, and find a best fit curve... This would assume that calls to findCollections directly correlate with the time it takes to execute. However, finding the worst case here isn't too hard. You just have to think about what input variables would cause your execution to go on the longest.

In this case if the sum variable is larger than the sum of the whole set you will see the worst execution (the most recursion). If this condition is true, then the method bellow would be equivalent to yours:

public static void findCollections(int[] array, int index, int currentPosition, int sum, String collection) {
    for(int i = index; i < array.length; i++) {
        findCollections(array, i + 1, currentPosition + array[i], sum, collection + " " + array[i]);
    }
}

Its easy to see here that this would cycle through all possible sub-sets of array. This makes your solution O(2^n) where n is the size of array