1、斐波那契数列

题目描述：

有一楼梯共M级，刚开始时你在第一级，若每次只能跨上一级或二级，要走上第M级，共有多少种走法？

输入：

输入数据首先包含一个整数N，表示测试实例的个数，然后是N行数据，每行包含一个整数M（1<=M<=40）,表示楼梯的级

输出：

对于每个册数用例，请输入不同走法的数量

import java.util.Scanner;


public class Main{

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner scanner=new Scanner(System.in);
        int n=scanner.nextInt();//有n组数据
        int []jl=new int[n];//用于记录每组数据结果的数组
        for (int i = 0; i < n; i++) {
            int x=scanner.nextInt();
            jl[i]=dp(x-1);
        }
        for (int i = 0; i < jl.length; i++) {
            System.out.println(jl[i]);
        }
        
    }
    public static int  dp(int m) {
        int[]dp=new int[m+1];
        dp[0]=1;
        dp[1]=1;
        for (int i = 2; i <=m; i++) {
            dp[i]=dp[i-1]+dp[i-2];
        }
        return dp[m];
    }

}

2、数塔问题

题目描述：

在讲述DP算法的时候，一个经典的例子就是数塔问题，它是这样描述的：

有如下所示的数塔，要求从顶层走到底层，若每一步只能走到相邻的结点，则经过的结点的数字之和最大是多少？

输入：

输入数据首先包括一个整数C,表示测试实例的个数，每个测试实例的第一行是一个整数N(1 <= N <= 100)，表示数塔的高度，接下来用N行数字表示数塔，其中第i行有个i个整数，且所有的整数均在区间[0,99]内。

输出：

对于每个测试实例，输出可能得到的最大和，每个实例的输出占一行。

import java.util.Scanner;


public class Main{

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner scanner=new Scanner(System.in);
        int n=scanner.nextInt();
        int[]jl=new int[n];
        for (int k = 0; k < n; k++) {
            int x=scanner.nextInt();
            int[][]arr=new int[x][];
            for (int i = 0; i < x; i++) {
                arr[i]=new int[i+1];
                for (int j = 0; j <= i; j++) {
                    arr[i][j]=scanner.nextInt();
                }
            }
            jl[k]=dp(arr, 0, 0);
        }
        for (int i = 0; i < jl.length; i++) {
            System.out.println(jl[i]);
        }
        
    }
    public static int dp(int[][]arr,int i,int j) {
        int rowCount=arr.length;//行数
        int columCount=arr[rowCount-1].length;//最后一行列数
        int[][]dp=new int[rowCount][columCount];
        for (int k = 0; k < columCount; k++) {
            dp[rowCount-1][k]=arr[rowCount-1][k];
        }
        for (int k = rowCount-2; k >=0; k--) {
            for (int l = 0; l <= k; l++) {
                dp[k][l]=Math.max(dp[k+1][l], dp[k+1][l+1])+arr[k][l];
            }
        }
        return dp[i][j];
    }
}

3、矩阵取数问题

题目描述：

一个N*N矩阵中有不同的正整数，经过这个格子，就能获得相应价值的奖励，从左上走到右下，只能向下向右走，求能够获得的最大价值。

例如：3 * 3的方格。

1 3 3

2 1 3

2 2 1

能够获得的最大价值为：11。

输入：

第1行：N，N为矩阵的大小。（2<=N<=500）

第2-N+1行：每行N个数，中间用空格隔开，对应格子中奖励的价值。（1<=N[i]<=10000）

输出：

输出能够获得的最大值。

输入样例：

3

1 3 3

2 1 3

2 2 1

输出样：

11

import java.util.Scanner;


public class Main{

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		         Scanner scan = new Scanner(System.in);
		         int n = scan.nextInt();
		         int[] dp = new int[n+1];
		         int[] readMax = new int[n+1];
		         for(int i=0;i<n;i++){
		             for(int k=1;k<n+1;k++){
		                readMax[k] = scan.nextInt();
		                //System.out.println("readMax["+k+"]="+readMax[k]);
		             }
		             for(int j=1;j<n+1;j++){
		                 dp[j] = Math.max(dp[j],dp[j-1])+readMax[j];
		                 //System.out.println("dp["+j+"]="+dp[j]);
		             }
		         }
		         System.out.println(dp[n]);
		     }

}

4、最大子段和

题目描述：

给定n个整数(可能有负数)组成的序列a1，a2，...，an，求该序列的最大子段和。如果所有整数都是负数，那么定义其最大子段和为0。

输入：

输入n个整数

输出：

最大子段和

import java.util.Scanner;


public class dp08 {

	/**
	 * @param args
	 * 最大子段和
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[]arr={-2,1,-3,4,-1,2,1,-5,4};
		int[]dp=new int[arr.length];
		dp[0]=-1;//初始化数组
		int max=-1;//初始化最大值
		for (int i = 1; i < dp.length; i++) {
			dp[i]=Math.max(arr[i], arr[i]+dp[i-1]);
			max=dp[i]>max?dp[i]:max;//判断当前最大和是否超过max；
		}
		System.out.println(max);
	}

}