动态规划
-动态规划方法方法代表了这一类问题（最优子结构or子问题最优性）的有一半解法，是设计方法或者策略，不是具体算法
-本质是递推，核心是找到状态转移的方式，写出dp方程
-形式:记忆性递归
递推01背包问题
有n个重量和价值分别为wi，vi的物品，从这些物品中挑选出总重量不超过n的物品，求所有挑选方案中的值总和的最大值 1<=n<=1002 1<=wi,vi<=100 1<=w<=10000 输入 、n=4 (w,v)={(2,3),(1,2),(3,4),(2,2)} w=5 输出 7{选择第0，1，3号物品} 因为对每个物品只有选和不选两种情况，所以这个问题称为01背包 public class Case_01背包问题{ static int[] w={2,1,3,2};//重量表 static int[] v={3,2,4,2};//价值表 static int n=4;//物品数量 static int W=5;//背包的承重极限 public static void main(String[] args){ int ww=W; int ans=dfs(0,ww); System.out.println(ans); } static int dfs(int i,int ww){ if(w<=0)return 0;//装不进去 if(i==n)return 0;//每东西可选了 int v2=dfs(i+1,ww);//不选择当前物品 if(ww>=w[i]){ int v1=v[i]+dfs(i+1,ww-w[i]);//选择当前物品 return max(v1,v2);; }else{ return v2; } } static int[][] rec; } 重叠求解，记忆性递归 重叠子问题，不重复求解 public static void main(String[] args){ int ww=W; int ans=dfs(0,ww); System.out.println(ans); rec=new int[n][w+1]; for(int i=0;i<n;i++){ Arrays.fill(rec[i],-1);//每一行都填充为-1 } ans=m(m,v,0,n,W); System.out.println(ans); } static int m(int i,int ww){ mif(w<=0)return 0;//装不进去 if(i==n)return 0;//每东西可选了 //计算之前做查询 if(rec[i][ww]>=0){ return rec[i][ww]; } int v2=m(i+1,ww);//不选择当前物品 if(ww>=w[i]){ int v1=v[i]+m(i+1,ww-w[i]);//选择当前物品 ans=max(v1,v2);; }else{ ans=v2; } //计算之后做保存 rec[i][ww]=ans; return ans; } 01背包问题dp（dynamic programming） (w,v) 0 1 2 3 4 5 (2,3) 0 0 3 3 3 3 (1,2) 0 2 要2+0，不要3 5=要2+3，不要3 5=要2+3，不要3 5=要2+3，不要3 (3,4) 0 2 3 5=4+0,5 6=4+2,5 7=4+3，5 (2,2) 0 2 3 5 6 7 定义从小到大的背包，初始化第一行，然后根据第一行去推其他行 看当前背包是否能装下给这个物品，若是装不下，则取上一行相同容量背包的最大价值为当前这个背包的价值 若是能装下，则要比较两种情况，选与不选，若选择这个物品，这加上这个物品的价值，背包则减去这个物品的容量， 剩余的容量肯定比之前小，则在上一行找剩余容量的最大价值，两者相加，即为选择这个物品的最大价值，若是不选， 则取上一行的最大价值为当前最大价值，比较选与不选两者的最大值，取最大值作为当前背包的最大价值 当dp到最后，右下角即为答案 static int dp(){ int[][] dp=new int[n][w+1]; //初始化dp表的第一行 for(int i=0;i<W+1;i++){ if(i>=w[0]){//每种容量0号的物体 dp[0][i]=v[0]; }else{ dp[0][i]=0; } } //其他行 for(int i=1;i<n;i++){ for(int j=0;j<W+1;j++){ if(j>=w[i]){//要的起 int i1=v[i]+dp[i-1][j-w[i]];//选择当前物品 int i2=dp[i-1][j];//不选 dp[i][j]=max(i1,i2); }else{ dp[i][j]=dp[i-1][j]; } } } return dp[n-1][W]; }
钢条分割
Serling公司，购买长钢条，将其切割为短钢条出售,切割工序本身没有成本支出，公司管理层希望知道最佳的切割方案 假定我们知道Serling公司出售一段长为i英寸的的钢条价格为pi(i=1,2,...单位为美元)，钢条长度均为整英寸 | 长度i | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | | - | - | - | - | - | - | - | - | - | - | 价格pi | 1 | 5 | 8 | 16 | 10 | 17 | 17 | 20 | 24 | 30 | 钢条切割问题是这样的，给定一段长度为n英寸的钢条和一个价格表pi(i=1,2...n),求切割钢条方案，使得售价收益rn最大， 注意，如果长度为n英寸的钢条的价值pn足够大，最优解可能就是完全不需要切割 递归->记忆性递归->dp public class Case_钢条切割{ //有重复子问题 static int r(int x){ if(x==0){ return 0; } int ans=0; for(int i=1;i<=x;i++){//取不同种切法的最大值 int v=p[i-1]+r(x-i);//p[i-1即]从不切开始 ans=max(v,ans); } return ans; } static int[] vs=new int[n+1]; static int r1(int x){ if(x==0){ return 0; } int ans=0; for(int i=1;i<=x;i++){//取不同种切法的最大值 if(vs[x-i]==-1) vs[x-i]=r1(x-i); int v=p[i-1]+vs[x-i];//p[i-1]为这么长的钢材不切割时的价钱从不切开始 ans=max(v,ans); } vs[x]=ans; return ans; } static int dp(){ vs[0]=0; for(int i=1;i<=n;i++){//拥有钢条长度 for(int j=1;j<=i;j++){ vs[i]=max(p[j]+vs[i-j],vs[i]); } } return vs[n]; } }
数字三角形
在数字三角形中寻找一条从顶部到底边的路径，使得路径上所经过的数字之和最大 路径上的每一步都只能网左下或右下走。只需要求出这个最大和即可，不必给出具体路径。 三角形的行数大于1小于等于100，数字为（0~9） 输入格式: 5//表示三角形的行数。接下来输入三角形 7 3 8 8 1 0 2 7 4 4 4 5 2 6 5 要求输出最大和 dfs public static int maxSumUsingRecursive(int[][] triangle,int i,int j){ int rowIndex=triangle.length; if(i==rowIndex-1){ return triangle[i][j]; }else{ //顶点的值+max(左侧支线的最大值，右侧支路的最大值) return triangle[i][j]+Math.max(maxSumUsingRecursive(triangle,i+1,j),maxSumUsingRecursive(triangle,i+1,j+1)); } } dp递推 打表法 public static int maxSumUsingDp(int[][],int i,int j){ int rowCount=triangle.length;//行数 int columnCount=triangle[rowCount-1].length;//最后一行的列数 int[][] dp=new int[rowCount][ColumnCount]; for(int k=0;k<columnCount;k++){ dp[rowCount-1][k]=trianle[rowCount-1][k]//初始化最后一行 } for(int k=rowCount-2;k>=0;k--){ for(int l=0;l<k;l++){ dp[k][l]=triangle[k][l]+max(dp[k+1][l+1]) } } return dp[0][0]; } 可以用滚动数组，来表示，底下一层求完，就没用了,可以覆盖掉 public static int maxSumUsingDp(int[][],int i,int j){ int rowCount=triangle.length;//行数 int columnCount=triangle[rowCount-1].length;//最后一行的列数 int[] dp=new int[ColumnCount]; for(int k=0;k<columnCount;k++){ dp[k]=trianle[rowCount-1][k]//初始化最后一行 } for(int k=rowCount-2;k>=0;k--){ for(int l=0;l<k;l++){ dp[l]=triangle[k][l]+max(dp[k+1][l+1]) } } return dp[0][0]; }
最长公共子序列
求最大公共子序列 AB34C A1BC2结果为ABC 更多案例请看测试用例 ArrayList<Character>dfs(String s1,String s2){ int len1=s1.length(); int len2=s2.length(); ArrayList<Character> ans=new ArrayList<>; for(int i=0;i<len1;i++){ //以i字符开头的公共子序列 ArrayList<Character> list=new ArrayList<>; //和s2的每个字符【【比较 for(int j=0;j<len2;j++){ if(s1.charAt(i)==s2.charAt(j)){//如果相同 list.add(A1.charAt(i)); list.addAll(dfs(s1.substring(i+1),s2.substring(j+1))); break; } } if(list.size()>ans.size()){//以不同字符开头公共序列，求最长 ans=list; } } } dp B A 3 4 C s1 A 0 1 1 1 1 1 0 1 1 1 1 B 1 1 1 1 1 C 1 1 1 1 2 2 1 1 1 1 2 s2 当找到相同的字符,每个位置，都找左、上、和左上角+1的最大值，若没有找到相同字符，则找左、上 的最大值 String solution(String s1,String s2){ int len1=s1.length(); int len2=s2.length(); int[][] dp=new int[len1+1][len2+1];//动规数组 int flag=0; //初始化第一行 for(int i=1;i<=len1;i++){ if(flag==1){ dp[i][1]=1; }else if(s1.charAt(i-1)==s2.charAt(0){ dp[i][1]=1; flag=1; }else{ dp[i][1]=0; } } for(int i=2;i<=len1;i++){//M for(int j=2;j<=len2;j++){ int maxOfleftAndUp=Math.max(dp[i-1][j],dp[i][j-1]); if(s1.charAt(i-1)==s2.charAt(j-1)){//从1开始的数组，所以要i-1 dp[i][j]=Math.max(maxOfleftAndUp,dp[i-1][j-1]+1); }else{ dp[i][j]=maxOfLeftAndUp; } } } return parseDp(dp,s1,s2); } //还原子最长子序列 private String parseDp(int[][] dp,String s1,String s2){ int M=s1.length(); int N=s2.length(); StringBuilder sb=new StringBuilder(); while(M>0&&N>0){ //比左和上大，一定是当前位置的字符相等 if(dp[M][N]>Math.max(dp[M-1][N],dp[M][N-1])){ sb.insert(0,s1.charAt(M-1)); M--; N--; }else{//一定选择的是左边和上边的大者 if(dp[M-1][N]>dp[M][N-1]){ M--;//往上移 }else{ N--;//往左移 } } } return sb.toString(); } dp状态转移方程 用已知来推未知
完全背包问题
有n个重量和价值分别为wi，vi的物品，从这些物品中挑选出总重量不超过w的物品，求所有挑选方案中的价值总和的最大值 (w,v)={(2,3),(1,2),(3,4),(2,2)} 0 1 2 3 4 5 6 7 8 9 10 (2,3) 0 0 3 3 6 6 9 9 12 12 15 (1,2) 0 2 2+2 2+4...... (3,4) 0 2 4 6 (2,2) 两个核心式子: 拿一个后，剩余容量找当前行和上一行的最大值，一个不拿，找上一行该列的值，比较拿与不拿的最大值 该行前面就包含了不选的情况，当容量不足时，取上一行该容量的价值 因为需要选的物品重量价值不同，会出现当前行的该容量的价值比上一行的价值要大的情况 dp[i][j]=Math.max(v[i]+dp[i][ww-w[i]],dp[i-1][j]) 上一行的该列，意味着旧的该容量价值的最大值，新的该容量的价值与旧的取最大值 因此上面求出来的dp还要和上一行dp比较一下 dp[i][j]=Math.max(dp[i][j],d[i-1][j])
最长递增子序列
输入4 2 3 1 5 6 输出3（因为 2 3 5 组成了最长递增子序列） public class Case_最长递增子序列{ public static void main(String[] args){ int[] arr={4,2,3,1,5}; System.out.println(f(arr)); } private static int f(int[] arr){ for(int i=0;i<arr.length;i++){ int p=i; int cnt=0; for(int j=i+1;j<arr.length;j++){ if(arr[j]>arr[p]){ cnt++; p=j; } } if(cnt>maxCnt){ maxCnt=cnt;} } //maxCnt=max(maxCnt,cnt); } return maxCnt; } dp 4 2 3 1 5 6 1 1 2 1 3 4 并不是说最后一个就是最大递增子序列 把每位求出来，最后再整体作一个max static int[] dp=new int[arr.length]; private static int dp(int[] arr){ dp[0]=1;//初始化第一位为1 for(int i=0;i<arr.length;i++){//每个位置 cnt=1; for(int j=i-1;j>=0;j--){//向前找比当前位置小的 if(arr[i]>arr[j]){ cnt=max(dp[j]+1,cnt); } } dp[i]=cnt; } int ans=-1; for(int i=0;i<sb.length;i++){ ans=max(ans,dp[i]); } return ans; } dp[i] 长度为i最长递增子序列（LIS）最末尾的数 避免陷入思维定势 初始化第一个元素，遍历剩余的元素，若是比最后一个dp元素大，则添加到其后面，若是比它小，则放在dp数组第一个大于arr的元素位置上 4 2 3 1 5 6 4 8 5 9 4[1] 2[1] 3[2] 1[1] 3[2] 1[1] 3[2] 5[3] 1[1] 3[2] 5[3] 6[4] 1[1] 3[2] 4[3] 5[4] 8[5] 9[6] 结果为6 private static int dp1(int[] arr){ dp=new int[arr.length]; dp[1]=arr[0];//长度为1的最长递增子序列，初始化为第一个元素 int p=1;//记录dp更新的最后位置 for(int i=1;i<arr.length;i++){ if(arr[i]>dp[p]){ dp[p+1]=arr[i]; p++; }else{ //扫描dp数组，替换第一个比arr大的 //可以用二分法，优化查找 for(int j=0;j<=0;j++){ if(dp[i]>arr[i]){ dp[i]=arr[i]; break; } } } } return 0; }
小结 动态规划用于解决多阶段决策最优化问题 三要素: -阶段 -状态 -决策 两个条件: -最优子结构(最优化原理) -无后效性:当前状态是前面状态的完美总结 是否可以用动态规划，否则用搜索 -模型匹配:多做题，掌握经典模型 一维:上升子序列模型，背包波形 二维:最长公共子序列问题 -寻找规律:规模由小到大，或者由大到小，做逐步分许 -放宽条件或增加条件 一般过程 -找到过程演变中变化的量（状态），以及变化的规律（状态转移方程） -确定一些初始状态，通常需要dp数组来保存 -利用状态转移方程，退出最终答案 解法 -自顶向下，递归:如果有重叠子问题，带备忘录 -自底向上，递推 贪心和动规 可以用局部最优解来推导全局最优解,即动态规划 贪心:这一阶段的解，由上一阶段直接推导出 动规:当前问题的最优解，不能从上一阶段子问题简单得出，需要前面多杰阶段多层子问题共同计算出，因此需要保留历史上求解过的子问题及其最优解