动态规划

台阶问题

题目：
有n级台阶，一个人每次上一级或者两级，问有多少种走完n级台阶的方法。为了防止溢出，请将结果Mod 1000000007

给定一个正整数int n，请返回一个数，代表上楼的方式数。保证n小于等于100000。

测试样例：
1
返回：1

代码：

import java.util.*;

public class GoUpstairs {
    public int countWays(int n) {

        if(n==1){
            return 1;
        }

        if(n==2){
            return 2;
        }

        int f1 = 1;
        int f2 = 2;
        int result = 0;

        //迭代求解
        for(int i=3;i<=n;i++){
            result = (f1 + f2)%1000000007;
            f1 = f2;
            f2 = result;
        }

        return result;


    }
}

矩阵最小路径和

题目：
有一个矩阵map，它每个格子有一个权值。从左上角的格子开始每次只能向右或者向下走，最后到达右下角的位置，路径上所有的数字累加起来就是路径和，返回所有的路径中最小的路径和。

给定一个矩阵map及它的行数n和列数m，请返回最小路径和。保证行列数均小于等于100.

测试样例：
[[1,2,3],[1,1,1]],2,3
返回：4

代码：

import java.util.*;

public class MinimumPath {
    public int getMin(int[][] map, int n, int m) {
        //定义一个整形二维数组，存储每个位置点的最短路径
        int[][] result = new int[n][m];
        //起点位置为map[0]][0]
        result[0][0] = map[0][0];
        //最上面一行的每个格子路径只能是以此顺着最上面的格子走
        for(int i=1;i<m;i++){
            result[0][i] = result[0][i-1]+map[0][i];
        }
        //最左边的走法同最上面一行的走法
        for(int i=1;i<n;i++){
            result[i][0] = result[i-1][0] + map[i][0];
        }

        //其他格子位置的算法
        for(int i=1;i<n;i++){
            for(int j=1;j<m;j++){
                //两者选取较小的
                result[i][j] = Math.min(result[i-1][j]+map[i][j],result[i][j-1]+map[i][j]);
            }
        }

        return result[n-1][m-1];
    }
}

最长上升子序列

题目：
这是一个经典的LIS(即最长上升子序列)问题，请设计一个尽量优的解法求出序列的最长上升子序列的长度。

给定一个序列A及它的长度n(长度小于等于500)，请返回LIS的长度。

测试样例：
[1,4,2,5,3],5
返回：3

代码：
import java.util.*;

public class LongestIncreasingSubsequence {
public int getLIS(int[] A, int n) {
//边界条件判定
if(A==null||n==0){
return 0;
}
//result数组中存放的是以A[i]元素结尾的最长上升子序列的长度
int[] result = new int[n];
result[0] = 1;
//最长递增子序列长度
int resultMax = 1;

    //循环寻找
    for(int i=1;i<n;i++){

        //寻找比当前元素小的元素中子序列最长的
        int max = 0;
        for(int j=i-1;j>=0;j--){

          if(A[i]>A[j]&&result[j]>max){

              max = result[j];
          }  

        }

       //加1表示当前元素的最长子序列
        result[i] = max+1;


        if(result[i]>resultMax){
            resultMax = result[i];
        }
    }

    return resultMax;

}

}

字符串最长公共子序列问题

题目：
给定两个字符串A和B，返回两个字符串的最长公共子序列的长度。例如，A=”1A2C3D4B56”，B=”B1D23CA45B6A”，”123456”或者”12C4B6”都是最长公共子序列。

给定两个字符串A和B，同时给定两个串的长度n和m，请返回最长公共子序列的长度。保证两串长度均小于等于300。

测试样例：
“1A2C3D4B56”,10,”B1D23CA45B6A”,12
返回：6

代码：

import java.util.*;

public class LCS {
    public int findLCS(String A, int n, String B, int m) {
        //边界条件判定
        if(A==null||B==null||n<1||m<1){
            return 0;
        }

        char[] strA = A.toCharArray();
        char[] strB = B.toCharArray();
        int[][] res = new int[n+1][m+1];

        //为了防止数组越界，从1开始
        for(int i=1;i<n+1;i++){
            for(int j=1;j<m+1;j++){
                //三种情况
                //第一种情况：A,B的第i位和第j位元素相同，则res[i][j] = res[i-1][j-1]+1
                //第二种情况：res[i][j]与res[i][j-1]的值相同
                //第三种情况：res[i][j]与res[i-1][j]的值相同
                if(strA[i-1]==strB[j-1]){
                    res[i][j] = res[i-1][j-1] + 1;
                }else{
                    res[i][j] = Math.max(res[i][j-1],res[i-1][j]);
                }


            }
        }


        return res[n][m];  



    }
}