[Leetcode] 650. 2 Keys Keyboard 解题报告

题目：

Initially on a notepad only one character 'A' is present. You can perform two operations on this notepad for each step:

1. Copy All: You can copy all the characters present on the notepad (partial copy is not allowed).
2. Paste: You can paste the characters which are copied last time.

Given a number n. You have to get exactly n 'A' on the notepad by performing the minimum number of steps permitted. Output the minimum number of steps to get n 'A'.

Example 1:

Input: 3
Output: 3
Explanation:
Intitally, we have one character 'A'.
In step 1, we use Copy All operation.
In step 2, we use Paste operation to get 'AA'.
In step 3, we use Paste operation to get 'AAA'.

Note:

1. The n will be in the range [1, 1000].

思路：

1、O(n^2)的动态规划：

我们定义dp[i][j]表示在粘贴板上有j个A，文本中有i个A的情况下最小的生成步数，则递推公式为：当j < i 时，dp[i][j] = min(dp[i - j][j] + 1)；而dp[i][i] = min(dp[i][j] + 1), 其中j < i。这样最后返回dp[n].begin()和dp[n].end()中间的最小数即可。不过这种O(n^2)的空间复杂度没有通过测试。

2、O(n)的动态规划：

其实可以把DP的时间复杂度降低到O(n)的。我们定义dp[i]表示生成i个A所需要的最小步数，则首先把dp[i]初始化为i（这是因为当n >= 2的时候，我们可以通过先复制一个A，然后不断粘贴实现）。然后让j从i - 1不断循环到2，检查j，如果j是i的因数，那么就可以通过首先生成j个A，然后将这j个A复制后，粘贴 (i / j) - 1次实现。这样就可以顺利通过测试了。注意到这里dp[i]只依赖于另外一个dp[j]，所以这种动态规划可以进一步简化成为递归实现（见下面代码片段中的version 2）。

3、递推法：

在网上看到的既不用动态规划，也不用递归的版本，我觉得这是最优秀的一个解法了：当n >= 2的时候，我们的最优策略就是尽可能地生成n的最大因数个A（例如 n / d个），然后将其复制1遍，再粘贴 d - 1次。为了让n / d尽可能的大，我们就让d尽可能的小，所以我们让d从2开始循环。当找到一个d之后，我们接下来只需要解决生成n /d个A的问题，所以在循环中让n变为n / d即可。这样算法的时间复杂度就直接降低到了O(logn)，可谓已经到了极致了。

代码：

1、O(n^2)的动态规划：

class Solution {
public:
    int minSteps(int n) {
        vector<vector<int>> dp(n + 1, vector<int>(n + 1, INT_MAX));
        dp[1][0] = 0, dp[1][1] = 1;
        for (int i = 1; i <= n; ++i) {
            for (int j = 1; j < i; ++j) {
                if (dp[i - j][j] < INT_MAX) {
                    dp[i][j] = min(dp[i][j], dp[i - j][j] + 1);
                }
                if (dp[i][j] < INT_MAX) {
                    dp[i][i] = min(dp[i][i], dp[i][j] + 1);
                }
            }
        }
        return *(min_element(dp[n].begin(), dp[n].end()));
    }
};

2、O(n)的动态规划：

class Solution {
public:
    int minSteps(int n) {
        // version 1: DP
        if (n == 1) {
            return 0;
        }
        vector<int> dp(n + 1, INT_MAX);
        for (int i = 2; i <= n; ++i) {
            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];
        // version 2: recursion
        /*if (n == 1) {
            return 0;
        }
        for (int i = n - 1; i > 1; --i) {
            if (n % i == 0) {
                return minSteps(i) + n / i;
            }
        }
        return n;*/
    }
};

3、递推法：

class Solution {
public:
    int minSteps(int n) {
        int s = 0;
        for (int d = 2; d <= n; ++d) {  // we want to make d copies of n / d 'A's
            while (n % d == 0) {
                s += d;
                n /= d;
            }
        }
        return s;
    }
};