实在愚钝,虽然是以前看过的算法,今天也是折腾了一天才稍微弄懂了一些。特此记下笔记
第一次遇到这个问题的场景是猴子摘桃问题,原题如下:
小猴子下山,沿着下山的路有一排桃树,每棵树都结了一些桃子。小猴子想摘桃子,但是有一些条件需要遵守,小猴子只能沿着下山的方向走,
不能回头,每颗树最多摘一个,而且一旦摘了一棵树的桃子,就不能再摘比这棵树结的桃子少的树上的桃子。那么小猴子最多能摘到几颗桃子呢?
举例说明,比如有5棵树,分别结了10,4,5,12,8颗桃子,那么小猴子最多能摘3颗桃子,来自于结了4,5,8颗桃子的桃树
首先讲第一种解法:
要明白这题最关键的一步就是要清楚,不要直接拿数组中的元素一个个去比较,只需要知道,前 i 个元素中最长的递增子序列(LIS)的长度,或者,以第 i 个元素结尾的LIS的长度 ,第1个元素结尾的LIS的只有他自己一个,所以result[0] = 1,以第2个元素结尾的LIS则之需要和第1个元素peach[0]比较即可,若大于第1个元素,则在result[0]++ 就是他的LIS ,若小于,则同样result[1]=1 , 很明显,第i个元素结尾的LIS起码都是1。。 以后的任意i值,都可以依次类推获得到结果。 以下是该方法的算法代码:
/*小猴子下山,沿着下山的路有一排桃树,每棵树都结了一些桃子。小猴子想摘桃子,但是有一些条件需要遵守,小猴子只能沿着下山的方向走, 不能回头,每颗树最多摘一个,而且一旦摘了一棵树的桃子,就不能再摘比这棵树结的桃子少的树上的桃子。那么小猴子最多能摘到几颗桃子呢? 举例说明,比如有5棵树,分别结了10,4,5,12,8颗桃子,那么小猴子最多能摘3颗桃子,来自于结了4,5,8颗桃子的桃树。*/ int peaches[] = new int[]{4,4,5,2,3,156,15,6156,156,165,15,6}; @Test public void test222(){ /*Scanner in = new Scanner(System.in ); System.out.print("请输入数的颗树:"); int trees = Integer.parseInt(in.nextLine().trim()); peaches = new int[trees]; for (int i = 0; i < peaches.length; i++) { peaches[i] = Integer.parseInt(in.nextLine().trim()); }*/ printArray(peaches); System.out.println(pick(peaches)); System.out.println(findMax2(peaches)); } /* 5 2 3 156 15 6156 156 165 15 6*/ // 思路:求出以位置所有 以 peach[i](存入result[i]中)结尾的最长递增子序列的长度--->根据每个 result[0~j], // 拿peach[i]和peach[j]比较,如果peach[i]>peach[j],且result[j]+1>result[i],很明显,就该把result[i]值加1 // 所以,这种方法起码能找出一个最长序列,有时候可以找出多条,但有个条件,结尾的peach[i] 一定不相同 int pick(int[] peaches) { int max = 1; int length = peaches.length; // sequences存储桃树peach[i]每个位置,最长序列的每个元素。 List<ArrayList<Integer>> sequences = new ArrayList<ArrayList<Integer>>(); // 记录每个位置的最长递增子序列的长度 int result[] = new int[length]; for (int i = 0; i < length; i++) { result[i] = 1; ArrayList<Integer> list= new ArrayList<Integer>(); // 相当于每个位置初始化设置result[i]=1并且把自己放进去 ---->为了存好没进入循环的以及进入循环没进入关键判断的元素 list.add(peaches[i]); for (int j = 0; j < i; j++) { //必須新new一個,每一次循环,都是一次新的比较和 , 即和result[0 ~ i-1]的比较 // 不能是clear,因为这个newL是被引用的,所以,不能修改原对象的值 ArrayList<Integer> newL = new ArrayList<Integer>(); //这里也要初始化一次 ----> 为了进入判断后失去了本身元素,导致后面连锁的错误 newL.add(peaches[i]); //关键判断: 如果是i位置大于j位置,且j位置的最长递增子序列的长度+1长于目前i位置的最长递增子序列的长度,则更新i位置的最长递增子序列 if (peaches[j] <= peaches[i] && result[j] + 1 > result[i]){ result[i] = result[j] + 1; //j为此时比较的位置上最大的序列集合存储的索引 newL.addAll(sequences.get(j)); list = newL; } } sequences.add(list); System.out.println(sequences); } for (int i : result) max = i > max ? i : max; System.out.println(sequences); System.out.println(Arrays.toString(result)); /* for(ArrayList<Integer> l : sequences){ // if(l.size() >= max){ System.out.println(l); } } */ return max; } /* * 第二种方法的思路很简单,即开辟一段新的空间存储相应长度LCS中的最大元素的最小元素,举个例子:1,2,5,4 ... 当扫描到5(i=2)的时候,maxV[3] = 5 , result[2] = 3 * ,maxV[3] 即指的是 长度为3的LCS中最大元素的最小元素,所以当扫描到3的时候,maxV[3]就更新为4了 , 因为 5>4 ,且他们的result的长度都为3 这样子,就可以直接比较当前的peach[i]和 * nMaxResult就可以算出当前i的result */ // 方法二 private int findMax2(int [] peaches){ int [] maxV = new int[peaches.length]; maxV[1] = peaches[0]; maxV[0] = -1; int [] result = new int[peaches.length]; for(int i=0 ; i<result.length ; i++){ result[i] = 1; } // 最长子序列变量 int nMaxResult = 1; for(int i=1 ; i<peaches.length ; i++){ int j; //只要中一个小于peaches[i],更新i的最长子序列的长度,退出遍历 //这里可以换成二分查找 for(j = nMaxResult ; j>=1 ; j--){ //for(j = result[i-1] ; j>=1 ; j--){ if(peaches[i] >= maxV[j] && result[i]<(j+1)){ result[i] = j+1; break; } } if(result[i] > nMaxResult){ nMaxResult = result[i]; maxV[result[i]] = peaches[i]; }else if( maxV[j]<peaches[i] &&peaches[i]<maxV[j+1] ){ // 持续更新LCS中最大元素的最小元素 , 保证后面的比较是正确的 // 比如 8 9 1 2 3 走完前两步后maxV[1] = 8 , maxV[2] = 9 再走完两部后maxV[1]=1 maxV[2]=2, // 这样就保证了当扫描第3的时候能够匹配成功,这就能够是LIS尽可能长了。 maxV[result[i]] = peaches[i]; } } System.out.println(Arrays.toString(result)); return nMaxResult; }
以上多了我自己添加了打印序列的代码,同学们也可以自己屏蔽掉(想看的话,是从后往前看哦,我懒得改了)。同时我也偷了个懒,顺便把第二种发放贴了上去了。在这里继续介绍下去...
第二种方法的思路很简单,即开辟一段新的空间存储相应长度LCS中的最大元素的最小元素,举个例子:1,2,5,4 ... 当扫描到5(i=2)的时候,maxV[3] = 5 , LIS[2] = 3 ,maxV[3] 即指的是 长度为3的LCS中最大元素的最小元素,所以当扫描到3的时候,maxV[3]就更新为4了 , 因为 5>4 ,且他们的LIS的长度都为3
这样子,就可以直接比较当前的peach[i]和nMaxLIS就可以算出当前i的LIS
这样做是有原因的! 其实现在这么做的话,效率还是n2 , 其实还有第三种代码,因为maxV中的记录肯定是满足maxV[1] < maxV[2] <maxV[3] ....细心的同学可以已经发现,这种规律可以用二分查找方法取代遍历 这样就可以把效率提高到 nlog2n (二分查找的效率是log2n)。依据单调递增,将上面便利部分,做以下改动
最后将上面的代码换成二分查找去匹配,效率应该会更有改善,有兴趣的同学可以尝试
以前纯属个人观点,如有错误还请大佬们海涵,还请大佬们指点
以下来自知乎,拿最长子序列做例子学习动态规划的。
链接:https://www.zhihu.com/question/23995189/answer/35324479
来源:知乎
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
动态规划中递推式的求解方法不是动态规划的本质。
我曾经作为省队成员参加过NOI,保送之后也给学校参加NOIP的同学多次讲过动态规划,我试着讲一下我理解的动态规划,争取深入浅出。希望你看了我的答案,能够喜欢上动态规划。
0. 动态规划的本质,是对问题 状态的定义和 状态转移方程的定义。引自维基百科
dynamic programming is a method for solving a complex problem by breaking it down into a collection of simpler subproblems.
动态规划是通过拆分问题,定义问题状态和状态之间的关系,使得问题能够以递推(或者说分治)的方式去解决。
本题下的其他答案,大多都是在说递推的求解方法,但如何拆分问题,才是动态规划的核心。
而拆分问题,靠的就是状态的定义和状态转移方程的定义。
首先想说大家千万不要被下面的数学式吓到,这里只涉及到了函数相关的知识。
我们先来看一个动态规划的教学必备题:
给定一个数列,长度为N,
求这个数列的最长上升(递增)子数列(LIS)的长度.
以
1 7 2 8 3 4
为例。
这个数列的最长递增子数列是 1 2 3 4,长度为4;
次长的长度为3, 包括 1 7 8; 1 2 3 等.
要解决这个问题,我们首先要定义这个问题和这个问题的子问题。
有人可能会问了,题目都已经在这了,我们还需定义这个问题吗?需要,原因就是这个问题在字面上看,找不出子问题,而没有子问题,这个题目就没办法解决。
给定一个数列,长度为N,
设为:以数列中第k项结尾的最长递增子序列的长度.
求中的最大值.
显然,这个新问题与原问题等价。
而对于来讲,
都是
的子问题:因为以第k项结尾的最长递增子序列(下称LIS),包含着以第
中某项结尾的LIS。
上述的新问题也可以叫做状态,定义中的“
为数列中第k项结尾的LIS的长度”,就叫做对状态的定义。
之所以把做“状态”而不是“问题” ,一是因为避免跟原问题中“问题”混淆,二是因为这个新问题是数学化定义的。
对状态的定义只有一种吗? 当然不是。
我们甚至可以二维的,以完全不同的视角定义这个问题:
给定一个数列,长度为N,
设为:
在前i项中的,长度为k的最长递增子序列中,最后一位的最小值..
若在前i项中,不存在长度为k的最长递增子序列,则为正无穷.
求最大的x,使得不为正无穷。
这个新定义与原问题的等价性也不难证明,请读者体会一下。
上述的就是状态,定义中的“
为:在前i项中,长度为k的最长递增子序列中,最后一位的最小值”就是对状态的定义。
2. 什么是状态转移方程?
上述状态定义好之后,状态和状态之间的关系式,就叫做状态转移方程。
设设A为题中数列,状态转移方程为:为:以数列中第k项结尾的最长递增子序列的长度.
(根据状态定义导出边界情况)
![]()
![]()
用文字解释一下是:
以第k项结尾的LIS的长度是:保证第i项比第k项小的情况下,以第i项结尾的LIS长度加一的最大值,取遍i的所有值(i小于k)。
设设A为题中数列,状态转移方程为:为:在数列前i项中,长度为k的递增子序列中,最后一位的最小值
若则
![]()
否则:![]()
(边界情况需要分类讨论较多,在此不列出,需要根据状态定义导出边界情况。)
大家套着定义读一下公式就可以了,应该不难理解,就是有点绕。
这里可以看出,这里的状态转移方程,就是定义了问题和子问题之间的关系。
可以看出,状态转移方程就是带有条件的递推式。
3. 动态规划迷思
本题下其他用户的回答跟动态规划都有或多或少的联系,我也讲一下与本答案的联系。
a. “缓存”,“重叠子问题”,“记忆化”:
这三个名词,都是在阐述递推式求解的技巧。以Fibonacci数列为例,计算第100项的时候,需要计算第99项和98项;在计算第101项的时候,需要第100项和第99项,这时候你还需要重新计算第99项吗?不需要,你只需要在第一次计算的时候把它记下来就可以了。
上述的需要再次计算的“第99项”,就叫“重叠子问题”。如果没有计算过,就按照递推式计算,如果计算过,直接使用,就像“缓存”一样,这种方法,叫做“记忆化”,这是递推式求解的技巧。这种技巧,通俗的说叫“花费空间来节省时间”。都不是动态规划的本质,不是动态规划的核心。
b. “递归”:
递归是递推式求解的方法,连技巧都算不上。
c. "无后效性",“最优子结构”:
上述的状态转移方程中,等式右边不会用到下标大于左边i或者k的值,这是"无后效性"的通俗上的数学定义,符合这种定义的状态定义,我们可以说它具有“最优子结构”的性质,在动态规划中我们要做的,就是找到这种“最优子结构”。
在对状态和状态转移方程的定义过程中,满足“最优子结构”是一个隐含的条件(否则根本定义不出来)。对状态和“最优子结构”的关系的进一步解释,什么是动态规划?动态规划的意义是什么? - 王勐的回答 写的很好,大家可以去读一下。
需要注意的是,一个问题可能有多种不同的状态定义和状态转移方程定义,存在一个有后效性的定义,不代表该问题不适用动态规划。这也是其他几个答案中出现的逻辑误区:
动态规划方法要寻找符合“最优子结构“的状态和状态转移方程的定义,在找到之后,这个问题就可以以“记忆化地求解递推式”的方法来解决。而寻找到的定义,才是动态规划的本质。
分治在求解每个子问题的时候,都要进行一遍计算
动态规划则存储了子问题的结果,查表时间为常数
这就像说多加辣椒的菜就叫川菜,多加酱油的菜就叫鲁菜一样,是存在误解的。
文艺的说,动态规划是寻找一种对问题的观察角度,让问题能够以递推(或者说分治)的方式去解决。寻找看问题的角度,才是动态规划中最耀眼的宝石!(大雾)