目录

        🌈前言 

        🚚动态规划介绍

        🔗动态规划与递归的关系

        📋动态规划的基本步骤 

🌈前言 

🚚动态规划介绍

🔗动态规划与递归的关系

//递归求斐波那契数列的第N项
public static long Fac(int n)
{
    if(n == 1 || n == 2)
    {
        return 1;
    }

    return Fac(n-1) + Fac(n-2);
}

public static long Fac(int n)
{
    if(n <= 2)
    {
        return 1;
    }
 
    long dp[100] = {0};
    
    //初始化第一个元素和第二个元素
    dp[1] = 1;
    dp[2] = 1;
    
    int i = 0;
    for(i = 3; i <= n; i++)
    {
        dp[i] = dp[i-1] + dp[i-2];
    }
    
    return dp[n];
}

public static long Fac(int n)
{
    if(n <= 2)
    {
        return 1;
    }
    
    //初始化
    int preFirst = 1;//preFirst = dp[i-1]
    int preSecond = 1;//preSecond = dp[i-2]
    int ans = 0;//ans = dp[i]

    int i = 0;
    for(i =3; i <= n; i++)
    {
        ans = preFirst + preSecond;
        preSecond = preFirst;
        preFirst = ans;
    }

    return ans;
} 
    

public static int Labyrinth(int n, int m)
{
    if(m == 1 && n == 1)
    {
        return 1;
    }
    
    //处理边界情况
    if(m == 1 || n == 1)
    {
        return 1;
    }

    return Labyrinth(m-1, n) + Labyrinth(m, n-1);
}

public static int Labyrinth(int m, int n){
        int[][] dp = new dp[n][m];
        //初始化
        dp[0][0] = 1;
        
        for(int i=0; i<n; i++){
            for(int j=0; j<m; j++){
                if(i == 0 || j == 0){
                    dp[i][j] = 1;
                }

                dp[i][j] = dp[i-1][j] + dp[i][j-1];
            }
        }
        
        return dp[n-1][m-1];
} 

public static int Labyrinth(int m, int n){
        int[][] dp = new int[2][m];
        //初始化
        dp[0][0] = 1;
      
        for(int i=0; i<n; i++){
            for(int j=0; j<m; j++){
                if(i == 0 || j == 0){
                    dp[i%2][j] = 1;
                    continue;
                }

                if(i%2 == 0)//偶数行用1行的元素
                	dp[i%2][j] = dp[i%2][j-1] + dp[i%2+1][j];
                else//奇数行用第0行的元素
                	dp[i%2][j] = dp[i%2][j-1] + dp[i%2-1][j];
                
            }
        }
        return dp[(n+1)%2][m-1];
} 

public class Solution {
    /**
     * @param obstacleGrid: A list of lists of integers
     * @return: An integer
     */
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        // write your code here
        int n = obstacleGrid.length;//获取行
        int m = obstacleGrid[0].length;//获取列

        if (m == 0 || n == 0) {
            return 0;
        }

        int[][] dp = new int[n][m];
        
        //处理特殊情况
        if (obstacleGrid[0][0] == 1 || obstacleGrid[n - 1][m - 1] == 1) {
            return 0;
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (obstacleGrid[i][j] == 1) {
                    dp[i][j] = 0;
                } else {
                    if (i == 0 && j == 0) {
                        dp[i][j] = 1;
                    } else {
                        if (i == 0) {
                            dp[i][j] = dp[i][j - 1];
                        } else {
                            if (j == 0) {
                                dp[i][j] = dp[i - 1][j];
                            } else {
                                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
                            }
                        }
                    }
                }
            }
        }
        return dp[n - 1][m - 1];
    }
}

📋动态规划的基本步骤 

public class Solution {
    /**
     * @param grid: a list of lists of integers
     * @return: An integer, minimizes the sum of all numbers along its path
     */
    public int minPathSum(int[][] grid) {

        int n = grid.length;
        int m = grid[0].length;

        int[][] dp = new int[2][m];//开辟滚动数组

        int old = 0;
        int now = 1;

        int t1, t2;
        for(int i=0; i<n; i++){
            //old and now swap
            now = old;
            old = 1-now;

            for(int j=0; j<m; j++){
                if(i == 0 && j == 0){
                    dp[now][j] = grid[i][j];
                    continue;
                }

                dp[now][j] = grid[i][j];
                if(i > 0){
                    t1 = dp[old][j];
                }else{
                    t1 = Integer.MAX_VALUE;//i=0时，该行的上面元素为无穷大
                }

                if(j>0){
                    t2 = dp[now][j-1];
                }else{
                    t2 = Integer.MAX_VALUE;//j=0时，该行的左边元素为无穷大
                }
                
                //选择较小的值到dp[now][j]
                if(t1 > t2){
                    dp[now][j] += t2;
                }else{
                    dp[now][j] += t1;
                }

            }
        }
        return dp[now][m-1];
    }
}