单序列型DP

  1. 相比一维DP，这种类型状态转移与过去每个阶段的状态都有关。

Perfect Squares :

方法一 ： 自底向上 递推 + memo

f(n) = min{f(i) + f(n-i), i = 1...n-1}

  1. class Solution {
  2.     public int numSquares(int n) {
  3.         int[] memo = new int[n];
  5.         for(int i = 1; i <= n; i++){
  6.             if(i * i <= n){
  7.                 memo[i*i - 1] = 1;
  8.             }
  9.         }
  11.         if(memo[n-1] == 1) return 1;
  13.         memo[1] = 2;
  14.         for(int i = 3; i <= n; i++){
  15.             if(memo[i-1] == 1) continue;
  17.             int left = 1;
  18.             int right = i - 1;
  20.             int mini = Integer.MAX_VALUE;
  21.             while(left <=  right){
  22.                 if(left + right == i){
  23.                     mini = Math.min(mini, memo[left - 1] + memo[right - 1]);
  24.                 }
  25.                 left ++; right--;
  26.             }
  27.             memo[i-1] = mini;
  28.         }
  30.         return memo[n - 1];
  31.     }
  32. }

方法二： 递推 + memo

另外，本题有个四平方数之和定理，具体参考

  1. class Solution {
  2.     public int numSquares(int n) {
  3.         int[] memo = new int[n + 1];
  4.         memo[0] = 0;
  6.         for(int i = 1; i <= n; i++){
  7.             int mini = Integer.MAX_VALUE;
  9.             for(int j = 1; j <= i; j ++){
  10.                 int t = j*j;
  12.                 if(t > i) break;
  13.                 if(t == i) mini = 1;
  14.                 else mini = Math.min(mini, memo[t] + memo[i-t]);
  15.             }
  17.             memo[i] = mini;
  18.         }
  19.         return memo[n];
  20.     }
  21. }

Longest Increasing Subsequence

方法一 ： 自底向上，递推 + memo

这道题的状态转移想了比较久，没有想出来，给出grandyang的参考.

参考中，还介绍了nlog(n)的解法，用了二搜法。

  1. class Solution {
  2.     public int lengthOfLIS(int[] nums) {
  3.         if(nums.length == 0) return 0;
  5.         int[] memo = new int[nums.length];
  6.         memo[0] = 1;
  8.         int maxi = 1;
  9.         for(int i = 1; i < nums.length; i++){
  11.             memo[i] = 1;
  13.             for(int j = i - 1; j >= 0; j--){
  14.                 if(nums[i] > nums[j])
  15.                 memo[i] = Math.max(memo[i], memo[j] + 1);
  16.             }
  17.             maxi = Math.max(memo[i], maxi);
  18.         }
  20.         return maxi;
  21.     }
  22. }

Increasing Triplet Subsequence : 求是否存在

方法一 ： 自底向上 递推 + memo

  1. class Solution {
  2.     public boolean increasingTriplet(int[] nums) {
  3.         if(nums.length == 0) return false;
  5.         int[] memo = new int[nums.length];
  6.         memo[0] = 1;
  8.         boolean exist = false;
  9.         for(int i = 1; i < nums.length; i ++){
  10.             memo[i] = 1;
  11.             for(int j = 0; j < i; j ++){
  12.                 if(nums[i] > nums[j]){
  13.                     memo[i] = Math.max(memo[j] + 1, memo[i]);
  14.                 }
  15.             }
  17.             if(memo[i] == 3){
  18.                 exist = true;break;
  19.             }
  20.         }
  22.         return exist;
  23.     }
  24. }

Coin Change

方法一: 自底向上

递推 + memo

如果直接用用模除，将得到错误结果

dp方法没有可优化了，用 递归 + 减枝还可以优化，参考

减枝是一种优化方法，一般用于dfs/bfs中，通过条件过滤掉对搜索空间树的搜索，参考

  1. class Solution {
  2.     public int coinChange(int[] coins, int amount) {
  4.         Arrays.sort(coins);
  5.         int[] memo = new int[amount + 1];
  7.         for(int i = 1; i <= amount; i++){
  9.             memo[i] = Integer.MAX_VALUE;
  11.             for(int j = coins.length - 1; j >= 0; j--){
  12.                 if(i < coins[j]) continue;
  14.                 if(i == coins[j]){
  15.                     memo[i] = 1;
  16.                     continue;
  17.                 }
  19.                 int m = i - coins[j];//此处若修改为 m = i % coins[j]会出错
  20.                 if(memo[m] != -1){
  21.                     memo[i] = Math.min(memo[i], 1 + memo[m]);
  22.                 }
  23.             }
  25.             memo[i] = (memo[i] == Integer.MAX_VALUE) ? -1 : memo[i];
  26.         }
  28.         return memo[amount];
  29.     }
  30. }

Integer Break

方法一 ： 自底向上， 递推 + memo

与coin change很像

  1. class Solution {
  2.     public int integerBreak(int n) {
  3.         int[] memo = new int[n + 1];
  4.         memo[0] = 1;
  5.         memo[1] = 1;
  6.         memo[2] = 1;
  8.         for(int i = 3; i <= n; i++){
  9.             int a = i / 2 + 1;
  10.             for(int j = 1; j < a; j++){
  11.                 int x = Math.max(j, memo[j]);
  12.                 int y = Math.max(i - j, memo[i - j]);
  13.                 memo[i] = Math.max(memo[i], x * y);
  14.             }
  15.         }
  17.         return memo[n];
  18.     }
  19. }

Largest Divisible Subset

方法一 ： 自底向上， 递推 + memo

  1. class Solution {
  2.     public List<Integer> largestDivisibleSubset(int[] nums) {
  3.         if(nums.length < 1) return new ArrayList<>();
  5.         List<List<Integer>> memo = new ArrayList<List<Integer>>();
  6.         Arrays.sort(nums);
  8.         int gIdx = 0;
  9.         int gLen = 0;
  11.         List<Integer> li = new ArrayList<>();
  12.         li.add(nums[0]);
  13.         memo.add(li); // 1
  15.         for(int i = 1; i < nums.length; i ++){
  16.             int longIdx = i;
  17.             int longLen = 0;
  19.             for(int j = 0; j < i; j++){
  20.                 int tlen = memo.get(j).size();
  21.                 if(nums[i] % memo.get(j).get(tlen - 1) == 0){
  22.                     if(longLen < tlen){
  23.                         longLen = tlen; longIdx = j;
  24.                     }
  25.                 }
  26.             }
  28.             if(longIdx == i){
  29.                 List<Integer> li2 = new ArrayList<>();
  30.                 li2.add(nums[i]);
  31.                 memo.add(li2);
  32.             }
  33.             else{
  34.                 List<Integer> li3 = new ArrayList<>(memo.get(longIdx));
  35.                 li3.add(nums[i]);
  36.                 memo.add(li3);
  37.                 if(memo.get(i).size() > gLen){
  38.                     gIdx = i; gLen = memo.get(i).size();
  39.                 }
  40.             }
  41.         }
  43.         if(gLen == 0) return memo.get(0);
  44.         return memo.get(gIdx);
  45.     }
  46. }

Combination Sum IV

方法一： 自顶向下 回溯法 TimeLimitExceed, 11 / 17

  1. class Solution {
  2.     public int combinationSum4(int[] nums, int target) {
  3.         Arrays.sort(nums);
  4.         return dfs(nums, target);
  5.     }
  7.     int dfs(int[] nums, int tgt){
  9.         if(tgt == 0){
  10.             return 1;
  11.         }
  12.         else if(tgt < 0){
  13.             return 0;
  14.         }
  16.         int sumC = 0;
  17.         for(int i = 0; i < nums.length; i ++){
  18.             int newTgt = tgt - nums[i];
  19.             if(newTgt >= 0){
  20.                 sumC += dfs(nums, newTgt);
  21.             }
  22.             else{
  23.                 break;
  24.             }
  25.         }
  27.         return sumC;
  28.     }
  29. }

方法二：自底向上 递推 + memo

  1. class Solution {
  2.     public int combinationSum4(int[] nums, int target) {
  3.         Arrays.sort(nums);
  5.         int[] memo = new int[target + 1];
  6.         memo[0] = 0;
  8.         for(int i = 1; i <= target; i++){
  10.             for(int j = 0; j < nums.length; j++){
  11.                 if(i < nums[j]){
  12.                     continue;
  13.                 }
  15.                 if(i == nums[j]){
  16.                     memo[i] += 1;
  17.                 }
  18.                 else{
  19.                     int t = i - nums[j];
  20.                     if(memo[t] != 0){
  21.                         memo[i] += memo[t];
  22.                     }
  23.                 }
  24.             }
  26.         }
  28.         return memo[target];
  29.     }
  30. }

646. Maximum Length of Pair Chain

方法一 ： 耗时47ms

这是一道变型的Longest Increase Subsequence；注意，这里有二维数组的排序方法

  1. class Solution {
  2.     public int findLongestChain(int[][] pairs) {
  3.         int len = pairs.length;
  4.         if(len < 2) return len;
  5.         Integer[][] p = new Integer[len][2];
  6.         for(int i = 0; i < len; i ++){
  7.             p[i][0] = pairs[i][0];
  8.             p[i][1] = pairs[i][1];
  9.         }
  11.         Arrays.sort(p, new Comparator<Integer[]>(){
  12.             public int compare(Integer[] o1, Integer[] o2){
  13.                 return o1[0] - o2[0];
  14.             }
  15.         });
  17.         int[] dp = new int[len];
  18.         dp[0] = 1;
  20.         for(int i = 1; i < len; i ++){
  22.             int maxi = 1;
  23.             for(int j = 0; j < i; j ++){
  24.                 if(p[j][1] < p[i][0]){
  25.                     maxi = dp[j] + 1;
  26.                 }
  27.             }
  29.             dp[i] = maxi;
  30.         }
  32.         return dp[len - 1];
  33.     }
  34. }

方法二 ： 使用自己的快排，耗时3ms

  1. class Solution {
  2.     public int findLongestChain(int[][] pairs) {
  3.         if (pairs == null)
  4.             return 0;
  5.         int len = pairs.length;
  6.         if (len < 2)
  7.             return len;
  8.         qsort(pairs, 0, len - 1);
  9.         int sum = 1;
  10.         int end = pairs[0][1];
  11.         for (int i = 1; i < len; ++i) {
  12.             if (pairs[i][0] > end) {
  13.                 ++sum;
  14.                 end = pairs[i][1];
  15.             }
  16.         }
  17.         return sum;
  18.     }
  20.     private void qsort(int[][] pairs, int begin, int end) {
  21.         if (begin >= end)
  22.             return;
  23.         int key = pairs[begin][1];
  24.         int[] keyPair = pairs[begin];
  25.         int i = begin, j = end;
  26.         while(i < j) {
  27.             while(i < j && key <= pairs[j][1])
  28.                 --j;
  29.             pairs[i] = pairs[j];
  30.             while(i < j && key >= pairs[i][1])
  31.                 ++i;
  32.             pairs[j] = pairs[i];
  33.         }
  34.         pairs[i] = keyPair;
  35.         qsort(pairs, begin, i - 1);
  36.         qsort(pairs, i + 1, end);
  37.     }
  38. }

650. 2 Keys Keyboard

方法一：递推 + memo

还有递推方法，参考

  1. class Solution {
  2.     public int minSteps(int n) {
  3.         int[] dp = new int[n];
  4.         dp[0] = 0;
  6.         for(int i = 2; i <= n; i++){
  8.             int halfi = i >> 1;
  9.             int mini = i;
  10.             for(int j = 2; j <= halfi; j++){
  11.                 if(i % j == 0){
  12.                     mini = Math.min(mini, dp[j-1] + 1 + i / j - 1);
  13.                 }
  14.             }
  15.             dp[i-1] = mini;
  16.         }
  18.         return dp[n-1];
  19.     }
  20. }

376. Wiggle Subsequence :

方法一： 递推 + memo

这道题是LIS的变形，原理都一样

  1. class Solution {
  2.     public int wiggleMaxLength(int[] nums) {
  3.         if(nums.length == 0) return nums.length;
  5.         int[][] dp = new int[nums.length][2];
  7.         dp[0][0] = dp[0][1] = 1;
  9.         for(int i = 1; i < nums.length; i ++){
  11.             dp[i][0] = dp[i][1] = 1;
  12.             for(int j = 0; j < i; j ++){
  13.                 if(nums[i] > nums[j]){
  14.                     dp[i][0] = Math.max(dp[i][0], dp[j][1] + 1);
  15.                 }
  16.                 if(nums[i] < nums[j]){
  17.                     dp[i][1] = Math.max(dp[i][1], dp[j][0] + 1);
  18.                 }
  19.             }
  20.         }
  22.         return Math.max(dp[nums.length - 1][0], dp[nums.length - 1][1]);
  23.     }
  24. }

leetcode动态规划笔记三---单序列型的更多相关文章

  1. leetcode动态规划笔记二

    动态规划 题目分类 一维dp 矩阵型DP Unique Paths II : 矩阵型DP,求所有方法总数 Minimum Path Sum:矩阵型,求最大最小值 Triangle : 矩阵型,求最大最 ...

  2. leetcode动态规划笔记一---一维DP

    动态规划 刷题方法 告别动态规划,连刷 40 道题,我总结了这些套路,看不懂你打我 - 知乎 北美算法面试的题目分类,按类型和规律刷题 题目分类 一维dp House Robber : 求最大最小值 ...

  3. 【Python】学习笔记三：序列

    sequence(序列) sequence(序列)是一组有序的元素的集合,序列可以有任何元素,也可以没有元素 元组与表的区别:一旦建立,tuple的各个元素不可再变更,而list的各个元素可以再变更 ...

  4. AngularJS学习笔记(三) 单页面webApp和路由(ng-route)

    就我现在的认识,路由($route)这个东西(也许可以加上$location)可以说是ng最重要的东西了.因为angular目前最重要的作用就是做单页面webApp,而路由这个东西是能做到页面跳转的关 ...

  5. Leetcode 413. Arithmetic Slice 算术序列切片(动态规划，暴力)

    Leetcode 413. Arithmetic Slice 算术序列切片(动态规划,暴力) 题目描述 如果一个数组1.至少三个元素2.两两之间差值相同,那么这个数组就是算术序列 比如下面的数组都是算 ...

  6. 吴恩达《深度学习》-第五门课 序列模型(Sequence Models)-第三周 序列模型和注意力机制（Sequence models & Attention mechanism）-课程笔记

    第三周 序列模型和注意力机制(Sequence models & Attention mechanism) 3.1 序列结构的各种序列(Various sequence to sequence ...

  7. 《MFC游戏开发》笔记三 游戏贴图与透明特效的实现

    本系列文章由七十一雾央编写,转载请注明出处. 313239 作者:七十一雾央 新浪微博:http://weibo.com/1689160943/profile?rightmod=1&wvr=5 ...

  8. 学习笔记(三)--->《Java 8编程官方参考教程（第9版）.pdf》:第十章到十二章学习笔记

    回到顶部 注:本文声明事项. 本博文整理者:刘军 本博文出自于: <Java8 编程官方参考教程>一书 声明:1:转载请标注出处.本文不得作为商业活动.若有违本之,则本人不负法律责任.违法 ...

  9. 构建高性能WEB站点笔记三

    构建高性能WEB站点笔记三 第10章 分布式缓存 10.1数据库的前端缓存区 文件系统内核缓冲区,位于物理内存的内核地址空间,除了使用O_DIRECT标记打开的文件以外,所有对磁盘文件的读写操作都要经 ...

随机推荐

  1. 京东 PC 首页 2019 改版前端总结 原创： 何Jason,EC,小屁 凹凸实验室 今天

    京东 PC 首页 2019 改版前端总结 原创: 何Jason,EC,小屁 凹凸实验室 今天

  2. JS 数组对象的某一项抽离出来放在外面

    数组类型: shamDeviceData: [ { "projectKey":"5555", "productKey":"5555 ...

  3. 一起入门Python1之python的介绍

    之前在某安全论坛发表的一些关于python的文章,但是由于一些问题一直没有完成,那个论坛也歇菜了.放到这儿来吧. 说句默心掏肺的话,我也是才学习python.之所以要这个版主,是为了锻炼自己,也是为了 ...

  4. 服务器端实时推送技术之SseEmitter的用法

    这是SpringMVC提供的一种技术,可以实现服务端向客户端实时推送数据.用法非常简单,只需要在Controller提供一个接口,创建并返回SseEmitter对象,发送数据可以在另一个接口调用其se ...

  5. Python3基础 函数 参数 多个参数都有缺省值，需要指定参数进行赋值

             Python : 3.7.3          OS : Ubuntu 18.04.2 LTS         IDE : pycharm-community-2019.1.3    ...

  6. 003-结构型-05-桥接模式（Bridge）

    一.概述 将抽象部分与它的具体实现部分分离.使它们都可以独立地变化.通过组合的方式建立两个类之间联系,而不是继承. Bridge 模式又叫做桥接模式,是构造型的设计模式之一.Bridge模式基于类的最 ...

  7. Python - Django - ORM F查询和Q查询

    models.py: from django.db import models # 出版社 class Publisher(models.Model): id = models.AutoField(p ...

  8. Mysql8.0.17版本不能自动创建activiti表的坑

    maven项目如下: 配置好数据库,和activiti的配置之后,开始执行流程部署 package com.yuanqiao.first_activiti.deployment; import jav ...

  9. 迅速生成项目-react-static

    推荐指数:

  10. 测试框架nunit之assertion断言使用详解

    任何xUnit工具都使用断言进行条件的判断,NUnit自然也不例外,与其它的xUnit(如Junit.phpUnit.pythonUnit)相比,由于大量使用了Generic.Attribute等语言 ...