【题14 剪绳子】Java实现

动态规划和贪婪算法

动态规划
求一个问题的最优解(最大值或最小值),而且该问题能够分解成若干子问题,并且子问题之间还有重叠的更小的子问题,可以考虑动态规划
(1) 分析是否能把大问题分解成小问题
(2) 分解后的每个小问题存在最优解
(3) 小问题的最优解组合起来能得到整个问题的最解

贪婪算法求解:
每一步都可以做出一个贪婪的选择,基于这个选择,确定能够得到最优解
1. 贪心算法在对问题求解时,不从整体最优上加以考虑,他所做出的是在某种意义上的局部最优解。
2. 选择的贪心策略必须具备无后效性,即某个状态以前的过程不会影响以后的状态,只与当前状态有关
3. 题目贪心策略:当n>=5时,尽可能多地剪长度为3的绳子;当剩下的绳子长度为4时,把绳子剪成两段长度为2的绳子

动态规划与贪心算法题目整理见

【题目】
给你一个长度为n的绳子,请把绳子剪成m段(m,n都是整数。n>1并且m>1).每段绳子的长度记为k[0],k[1],…k[m],请问k[0]*k[1]….k[m]。可能的最大乘积是多少?
例如:当绳子的程度是8时,我们把它剪成长度分别为2,3,3的三段,此时得到的最大乘积为18.

有两种不同解法
(1) 常规的需要O(n^2)时间和O(n)空间的动态规划思路。
(2) 接着用O(1)时间和空间的贪婪算法来分析解决问题。
动态规划求解:
分析:
(1)目标是求剪出各段绳子乘积的最大值f(n)。求一个问题的最优解——特点1.
(2)第1刀放在长度为i(0特点2
(3)把大问题分解成若干小问题,这些小问题之间还有互相重叠的更小的子问题——特点3
(4)子问题在分解大问题的过程中重复出现,为了避免重复求解子问题。
我们可以从下往上顺序先计算小问题最优解并存储下来,以此为基础求大问题最优解,从上往下分析问题,从下往上求解问题——特点4.
每一步都面临若干选择: f(n) = max(f(n) * f(n-i)) 0

方法:
定义函数f(n)把长度为n的绳子剪成若干段后各段长度乘积的最大值,剪第一刀,有n-1种可能选择,f(n) = max(f(n) * f(n-i)) 0 这是从上至下的递归公式,按照从下而上顺序计算,f(2),f(3), f(4),f(5) 得到f(n)
当绳子长度为2时,剪成长度为1 的两端,f(2) = 1
当绳子长度为3时,剪成长度分别为1,2,的两段或者都为1的三段,12>11*1 f(3) = 2

贪婪算法求解:
每一步都可以做出一个贪婪的选择,基于这个选择,确定能够得到最优解
分析:
如果绳子的长度大于5,则每次都剪出一段长度为3的绳子
如果剩下的绳子长度仍然大于5,则接着剪出一段长度为3的绳子,
接下来,重复这个步骤,直到剩下的绳子长度小于5,
剪出一段长度为3的绳子,就是每一步做出的贪婪选择。

按照下面的策略来剪绳子,得到各段绳子的长度的乘积将最大
当n>=5 尽可能多地剪长度为3的绳子。
当剩下的绳子长度为4时,把绳子剪成两段长度为2的绳子。
实现

package ti14;

public class Lian {
	//动态规划
	public static int getMaxResult(int length) {
        
        int[] res = null ;
        int max = 0 ;
        
        if(length < 2 ) {
            return 0 ;
        }
        
        if(length == 2) {
            return 1 ;
        }
        
        if(length == 3) {
            return 2 ;
        }
        
        res = new int[length+1] ;
        res[0] = 0 ;
        res[1] = 1 ;
        res[2] = 2 ;
        res[3] = 3 ;
        
        for(int i = 4 ; i <= length ; i ++) {
            max = 0 ;
            for(int j = 1 ; j <= i/2 ; j++) {
                
                int r = res[j] * res[i-j] ;
                
                if(max < r) {
                    max = r ;
                    res[i] =max ;
                }
                
            }
            
        }
        
        max = res[length] ;

        return max ;
        
    }
	//贪婪算法
	public static int getMaxResult1 (int length) {
    
		if(length < 2 ) {
			return 0 ;
		}
    
		if(length == 2) {
			return 1 ;
		}
    
		if(length == 3) {
			return 2 ;
		}
    
		int timesOf3 = length/3 ;
		if(length - timesOf3*3 == 1) {
			timesOf3 -= 1 ;
		}
    
		int timesOf2 = (length - timesOf3*3)/2 ;
    
		return (int) (Math.pow(3, timesOf3) * Math.pow(2, timesOf2)) ;//Math.pow(x,y)返回值:x 的 y 次幂
	}
	
	//测试
	public static void main(String[] args) {
        
        long curTime = System.nanoTime() ;
        
        System.out.println(getMaxResult(1));
        System.out.println(getMaxResult(3));
        System.out.println(getMaxResult(8));
        System.out.println(getMaxResult(50));
        System.out.println(System.nanoTime() - curTime);
        System.out.println("**************************************************");
        curTime = System.nanoTime() ;
        System.out.println(getMaxResult1(1));
        System.out.println(getMaxResult1(3));
        System.out.println(getMaxResult1(8));
        System.out.println(getMaxResult1(50));
        System.out.println(System.nanoTime() - curTime);
    }
}


【题14 剪绳子】Java实现_第1张图片

参考:
1.《剑指offer》
2.https://www.jianshu.com/p/43acdf2f23c5

你可能感兴趣的:(剑指offer)