算法学习 | 动态规划~大事化小、小事化了

目录

动态规划

动态规划相关OJ题

斐波那契数列

拆分词句

三角形 

不同的路径数目(一) 


动态规划

动态规划是分治思想的延伸,在将大问题化解为小问题的分治过程中,保存对这些小问题已经处理好的结果,并供后面处理更大规模的问题时直接使用这些结果.

动态规划具备如下三个特点:

①把原来的问题分解成了几个相似的子问题;

②所有的子问题都只需要解决一次;

③储存子问题的解.

动态规划的本质就是对问题状态的定义和状态转移方程的定义,动态规划问题一般从以下四个角度考虑:①状态定义;②状态间的转移方程定义;③状态的初始化;④返回结果

动态规划一般适用于求最大值/最小值,判断可行或是不可行,求方案个数等等

动态规划相关OJ题

从最基础的题目开始逐渐深入了解动态规划的思想.

斐波那契数列

OJ链接: JZ10 斐波那契数列

题目描述 

大家都知道斐波那契数列,现在要求输入一个正整数 n ,请你输出斐波那契数列的第 n 项。

要求:空间复杂度 O(1),时间复杂度 O(n) ,本题也有时间复杂度 O(logn)O(logn) 的解法

例如

输入:4

返回值:3

说明:

根据斐波那契数列的定义可知,fib(1)=1,fib(2)=1,fib(3)=fib(3-1)+fib(3-2)=2,fib(4)=fib(4-1)+fib(4-2)=3,所以答案为3。

dp状态分析 

状态:F(n)

状态递推:F(n) = F(n-1) + F(n-2)

初始值:F(1) = F(2) = 1

返回结果:F(n)

public class Solution {
    public int Fibonacci(int n) {
        if (n <= 0) {
            return 0;
        }
        int dp[] = new int[n + 1];
        dp[0] = 0;
        dp[1] = 1;
        for (int i = 2; i <= n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }
}

拆分词句

OJ链接:CC12 拆分词句

题目描述

给定一个字符串s和一组单词dict,判断s是否可以用空格分割成一个单词序列,使得单词序列中所有的单词都是dict中的单词(序列可以包含一个或多个单词)。

例如:
给定s=“nowcode”;
dict=["now", "code"].
返回true,因为"nowcode"可以被分割成"now code".

dp状态分析

由于java的substring方法左闭右开,因此i从1开始. 

子状态:前n个字符是否可以被成功拆分

状态定义:F(i),前i个字符是否可以被拆分

状态方程:F(i) = ( i < j && F(j) && dict.contains(s.substring(j, i)) )

初始值:初始值F(0)设为true.

返回结果:F(n)

import java.util.*;
public class Solution {
    public boolean wordBreak(String s, Set dict) {
        if (s.length() == 0) {
            return false;
        }
        if (dict.isEmpty()) {
            return false;
        }
        //定义状态数据
        boolean[] dp = new boolean[s.length() + 1];
        //默认初始值为true
        dp[0] = true;
        for (int i = 1; i <= s.length(); i++) {
            for (int j = i - 1; j >= 0; j--) {
                if (dp[j] && dict.contains(s.substring(j, i))) {
                    dp[i] = true;
                    break;
                }
            }
        }
        return dp[s.length()];
    }
}

三角形 

OJ链接:CC31 三角形 

题目描述 

给出一个三角形,计算从三角形顶部到底部的最小路径和,每一步都可以移动到下面一行相邻的数字,

例如,给出的三角形如下:

[[20],[30,40],[60,50,70],[40,10,80,30]]

最小的从顶部到底部的路径和是20 + 30 + 50 + 10 = 110。 

dp状态分析

状态定义:F(i, j):从(0, 0)到(i, j)的最短路径和

状态方程:F(i, j) = min( F(i - 1, j - 1),F(i - 1, j) ) + triangle[i][j]

初始值:F(0, 0) =  triangle[0][0]

返回结果:min(F(n - 1, i))

import java.util.*;
public class Solution {
    public int minimumTotal(ArrayList> triangle) {
        if (triangle.isEmpty()) {
            return 0;
        }
        List> dp = new ArrayList<>();
        for (int i = 0; i < triangle.size(); i++) {
            dp.add(new ArrayList<>());
        }
        //定义初始状态
        dp.get(0).add(triangle.get(0).get(0));
        for (int i = 1; i < triangle.size(); i++) {
            int curSum = 0;
            for (int j = 0; j <= i; j++) {
                //处理左边界
                if (j == 0) {
                    curSum = dp.get(i - 1).get(0);
                } else if (j == i) { //处理右边界
                    curSum = dp.get(i - 1).get(j - 1);
                } else {
                    curSum = Math.min(dp.get(i-1).get(j), dp.get(i-1).get(j-1));
                }
                dp.get(i).add(curSum + triangle.get(i).get(j));
            }
        }
        int size = triangle.size();
        int ret = dp.get(size - 1).get(0);
        for (int i = 1; i < size; i++) {
            if (ret > dp.get(size - 1).get(i)) {
                ret = dp.get(size - 1).get(i);
            }
        }
        return ret;
    }
}

不同的路径数目(一) 

OJ链接:不同的路径数目(一)

题目描述

算法学习 | 动态规划~大事化小、小事化了_第1张图片

 示例

输入:2,1

返回:1

输入:2,2

返回:2

dp状态分析

状态:F(i, j):从(0,0)到(i,j)的路径数目

状态方程:F(i,j) = F(i,j-1) + F(i-1,j)

初始值:F(0,i) = 1,F(i,0) = 1

返回值:F(m - 1,n - 1) 

 

import java.util.*;

public class Solution {
    public int uniquePaths (int m, int n) {
        // write code here
        if (m < 1 || n < 1) {
            return 0;
        }
        int[][] dp = new int[m][n];
        for (int i = 0; i < m; i++) {
            dp[i][0] = 1;
        }
        for (int i = 1; i < n; i++) {
            dp[0][i] = 1;
        }
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                dp[i][j] = dp[i][j-1] + dp[i-1][j];
            }
        }
        return dp[m-1][n-1];
    }
}

 

 

你可能感兴趣的:(算法训练,Java,算法,学习,动态规划)