LeetCode650. 2 Keys Keyboard

Get the recursion relationship

Apparently, there is some kind of recurrence relationship between the minimum number of steps needed for numbers smaller than n and n. Thus in order to come up with a DP solution, first we need to do is to find out this recurrence relationship and write up the recursion solution. After that, we can analyze the repetitive work we did and optimize the solution to a DP one.

In order to find out the recurrence relationship, we need to clarify 2 part:

1. What are the base cases?

2. What is the relationship between previous state and current state? i.e. solution for numbers smaller than n and solution for n.

So for the first question, the answer is obvious, the base cases should be: 1, 0, 2, 2 and 3,3.

For the second question, it’s more tricky. Notice that in order to get n by copy and paste, the only previous conditions, say, i, we need to consider are divisor of n, i.e. n % i == 0. Thus for a recursion solution, we can loop through 2 to n - 1 and find out the minimum number of steps.

Given the number of steps needed for i, say, minSteps(i), the number of steps needed for n are minSteps(i) + n/i. This is because: if we already got i A, then we need to get another (n/i) - 1 A. Thus we need one copyAll operation and (n/i) -1 paste operation. This is a total of (n/i) - 1 + 1 steps in addition to minSteps(i).

Hence we get the following recursion solution.

Time Complexity: Between O(n^2) to O(n^3). Because we are not checking every number less than n, thus is less than 1 + 2^2 + ... + n^2.

Space Complexity: O(1). O(n) at most for recursion stack.

class Solution {
    public int minSteps(int n) {
        if (n == 1) {
            return 0;
        } else if (n <= 3) {
            return n;
        }
        int min = Integer.MAX_VALUE;
        for (int i = 2; i <= n; i++) {
            if (n % i == 0) {
                min = Math.min(min, minSteps(n / i) + i);
            }
        }

        return min;
    }
}

Optimize it to DP

In the above recursion solution, we are checking results for i again and again, i.e. checking minSteps(i) again and again. Thus we can use an array to memorize this information to make it more efficient, resulting in a DP solution.

Time Complexity: Less than O(n^2).

Space Complexity: O(n).

class Solution {
    public int minSteps(int n) {
        int[] dp = new int[n + 1];
        dp[1] = 0;
        for (int i = 2; i <= n; i++) {
            // worst case for each number, copy the first A and paste the A all the way to n.
            dp[i] = i;
            for (int j = i - 1; j > 1; j--) {
                if (i % j != 0) continue;
                dp[i] = Math.min(dp[i], dp[j] + i / j);
            }
        }

        return dp[n];
    }
}

Further optimization

Actually there is a fact that each time the solution path to get n A is a determinate one for any n. It is the one that we greedily find every maximum divisor for current n and so on. Thus give use the following solution.

class Solution {
    public int minSteps(int n) {
        int[] dp = new int[n + 1];
        dp[1] = 0;
        for (int i = 2; i <= n; i++) {
            // worst case for each number, copy the first A and paste the A all the way to n.
            dp[i] = i;
            for (int j = i - 1; j > 1; j--) {
                if (i % j == 0) {
                    dp[i] = dp[j] + i / j;
                    break;
                }
            }
        }

        return dp[n];
    }
}

A math solution

class Solution {
    public int minSteps(int n) {
        int ret = 0;
        for (int i = 2; i <= n; i++) {
            while (n % i == 0) {
                ret += i;
                n /= i;
            }
        }

        return ret;
    }
}