【Lintcode】975. 2 Keys Keyboard（配数学证明）

题目地址：

https://www.lintcode.com/problem/2-keys-keyboard/description

有一个笔记本，上面写了一个字符$A$，每次可以执行下面两个操作之一：
1、复制笔记本上已经存在的所有字符；
2、粘贴上一次复制过的字符。
问要让笔记本上恰好出现$n$个$A$至少需要多少次操作。

法1：动态规划。设$f[n]$为恰好出现$n$个$A$至少需要多少次操作。如果$n$是素数，那么执行第二个步骤的时候，”上一次“复制过的字符数量一定是$1$，否则的话，就会使得$n$有非$1$的约数，矛盾。所以如果$n$是素数，那么需要的操作次数就是$n$；考虑$n$的最大真因子$k$，我们接下来证明：$$f[n]=f[k]+n/k$$也就是说，如果素因子分解$n=p_1^{s_1}{p}_2^{s_2}...p_t^{s_t}$，那么$$f[n]=p_1{s}_1+p_2{s}_2+...+p_t{s}_t$$数学归纳法。当$n=1,2,3$的时候显然正确。假设结论对于$n-1$是成立的，对于$n$，假设最后一次执行copy的时候是笔记本上有$i$个字符的时候，那么总次数应该是$f[i]+n/i$，设$i=p_1^{r_1}{p}_2^{r_2}...p_t^{r_t}$，其中$r_j\le s_j$，所以$$f[i]+n/i=p_1{r}_1+p_2{r}_2+...+p_t{r}_t+p_1^{s_1-r_1}{p}_2^{s_2-r_2}...p_t^{s_t-r_t}$$也就是要证明$$p_1(s_1-r_1)+p_2(s_2-r_2)+...+p_t(s_t-r_t)\le p_1^{s_1-r_1}{p}_2^{s_2-r_2}...p_t^{s_t-r_t}$$令$s_m-r_m=x_m\ge 0$，即要证明：$$p_1{x}_1+...+p_t{x}_t\le p_1^{x_1}...p_t^{x_t}$$这可以由数学归纳法证明，当$t=1$的时候，$p_1{x}_1\le p_1^{x_1}$相当于要证$g(x_1)=p_1^{x_1-1}-x_1\ge 0$，$x_1=0,1$的时候都是对的，求导得$$g^{\prime }(x_1)=p_1^{x_1-1}\ln p_1-1\ge 0,x_1\ge 2$$所以$g(x_1)\ge 0$恒成立，所以$t=1$的时候成立；假设对于$t-1$成立，则由归纳假设知$$p_1{x}_1+...+p_t{x}_t\le p_1^{x_1}...p_{t-1}^{x_{t-1}}+p_t{x}_t$$即要证明$h(x_t)=p_1^{x_1}...p_{t-1}^{x_{t-1}}(p_t^{x_t}-1)-p_t{x}_t\ge 0$，当$x_t=0,1$的时候都成立，求导得$$h^{\prime }(x_t)=p_1^{x_1}...p_{t-1}^{x_{t-1}}{p}_t^{x_t}\ln p_t-p_t\ge 0,x_t\ge 2$$所以$h(x_t)\ge 0$，由数学归纳法，$p_1{x}_1+...+p_t{x}_t\le p_1^{x_1}...p_t^{x_t}$成立，所以对于任意的$i|n$，都有$f[i]+n/i\ge f[k]+n/k$，所以当$i$取$n$的最大真因子的时候操作次数最少。所以算法成立。代码如下：

public class Solution {
    /**
     * @param n: The number of 'A'
     * @return: the minimum number of steps to get n 'A'
     */
    public int minSteps(int n) {
        // Write your code here
        int[] dp = new int[n + 1];
    
        for (int i = 2; i <= n; i++) {
            dp[i] = i;
            for (int j = i / 2; j >= 1; j--) {
            	// 找到最大真因子了
                if (i % j == 0) {
                    dp[i] = dp[j] + i / j;
                    break;
                }
            }
        }
        
        return dp[n];
    }
}

时空复杂度$O(n)$。

注解：
这里的动态规划的意味看起来并不浓厚。实际上

if (i % j == 0) {
	dp[i] = dp[j] + i / j;
	break;
}

这一句，如果改为：

if (i % j == 0) {
	dp[i] = Math.min(dp[i], dp[j] + i / j);
}

那么按照最后一步分类的意味会更加明显（这里是按照多少个字符的时候最后一次执行copy来分类的），更有动态规划的味道。只不过可以用数学证明，数到最大真因子的时候就能得到最优解而break出来了而已。

法2：根据上面的公式$f[n]=p_1{s}_1+p_2{s}_2+...+p_t{s}_t$可以直接计算。代码如下：

public class Solution {
    /**
     * @param n: The number of 'A'
     * @return: the minimum number of steps to get n 'A'
     */
    public int minSteps(int n) {
        // Write your code here
        int res = 0;
        for (int i = 2; i <= n; i++) {
        	// 累加s个p
            while (n % i == 0) {
                res += i;
                n /= i;
            }
        }
        
        return res;
    }
}

时间复杂度$\sum s_i$，空间$O(1)$。