LeetCode650. 2 Keys Keyboard

迷南。 2022-06-05 06:26 181阅读 0赞

# 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;
        }
    }