剑指offer--剪绳子（记忆化递归 || dp || 数学）

题目描述

给你一根长度为n的绳子，请把绳子剪成整数长的m段（m、n都是整数，n>1并且m>1，m<=n），每段绳子的长度记为k[1],...,k[m]。请问k[1]x...xk[m]可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。

输入描述:

输入一个数n，意义见题面。（2 <= n <= 60）

输出描述:

输出答案。

示例1

输入

8

输出

18

解题思路：

给出几种方法，看到这道题的样例，想起来均值不等式，a+b>=2sqrt(ab)，当且仅当a = b时不等式中的等号才会成立。

a+b类比于绳子的长度，思路也就清晰了，枚举全部分段情况下的乘积，维护一个值始终保持最大值即可，因为n的范围不是特别大，一遍过的。代码如下：

​
public class Solution {
    public int cutRope(int target) {
        int ans = -1 ;
        if(target == 0) return 0 ;
        for(int i = 1; i<=target; ++i) {
            int temp = target,sum = 1,frag = i;
            while(frag > 0) {
                int e = temp/frag ;
                sum *= e;
                temp -= e ;
                --frag ;
            }
            ans = Math.max(ans,sum) ;
        }
        return ans ;
    }
}

​

 

第二大类方法都是在暴力搜索的基础上进行延伸的，主要思想是，在预处理一些特殊情况下的长度（比如n=2，结果应为1，n=3，结果为2，但是递归过程中，就不需要拆分了，自身就是最大的乘积）之后，进行递归。

递归的终结条件是，当n<=4时，直接返回n自身即可，小于等于4的值再进行拆分没有任何意义了。

然后for循环的条件是小于n的全部整数，维护一个值始终保持当前状态与dfs(n-i)*i的最大状态，最后直接返回维护的最大值即可。C++代码如下，没写这个方法，直接粘过来：

class Solution {
public:
    int back_track(int n) {
        if (n <= 4) {
            return n;
        }

        int ret = 0;
        for (int i = 1; i < n; ++i) {
            ret = max(ret, i * back_track(n - i));
        }
        return ret;
    }
    int cutRope(int number) {
        if (number == 2) {
            return 1;
        }
        else if (number == 3) {
            return 2;
        }
        return back_track(number);
    }
};

由于递归过程中，有重复计算到的n的取值。所以空间换取时间，添加一个记忆化数组，记忆已经计算过的n的分段乘积最大值。

这种记忆化数组的用法好比在，判断二叉树是否是平衡二叉树的算法中自顶向下的方法。先递归得到每个节点所在的深度，最后从根节点向下检索。得到各节点的所在深度过程中，会遇到同一个节点重复计算的情况，因此利用记忆化数组保存节点的信息，终止条件中添加判断，如果当前节点的深度，在记忆化数组中已经存在，直接返回即可。

这种方法的代码如下：

class Solution {
public:
  int back_track(int n, vector<int> &mark) {
      if (n <= 4) {
          return n;
      }
      // 在方法一的基础上添加
      if (mark[n] != -1) {
          return mark[n];
      }
 
      int ret = 0;
      for (int i = 1; i < n; ++i) {
          ret = max(ret, i * back_track(n - i));
      }
      // 添加部分
      return mark[n] = ret;
  }
  int cutRope(int number) {
      if (number == 2) {
          return 1;
      }
      else if (number == 3) {
          return 2;
      }
      // 添加部分
      vector<int> mark(number, -1);
      return back_track(numberm, mark);
  }
};

动态规划的方法也是大同小异，C++代码如下：

class Solution {
public:
    int cutRope(int number) {
        if (number == 2) {
            return 1;
        }
        else if (number == 3) {
            return 2;
        }

        vector<int> f(number + 1, -1);
        for (int i = 1; i <= 4; ++i) {
            f[i] = i;
        }
        for (int i = 5; i <= number; ++i) {
            for (int j = 1; j < i; ++j) {
                f[i] = max(f[i], j * f[i - j]);
            }
        }
        return f[number];
    }
};