[POJ1088] 滑雪(递归dp)

最新推荐文章于 2021-12-21 14:48:01 发布

weixin_30938149

最新推荐文章于 2021-12-21 14:48:01 发布

阅读量117

点赞数

文章标签： java

原文链接：http://www.cnblogs.com/dick159/p/5258943.html

版权

Description

Michael喜欢滑雪百这并不奇怪，因为滑雪的确很刺激。可是为了获得速度，滑的区域必须向下倾斜，而且当你滑到坡底，你不得不再次走上坡或者等待升降机来载你。Michael想知道载一个区域中最长底滑坡。区域由一个二维数组给出。数组的每个数字代表点的高度。下面是一个例子

 1  2  3  4 5

16 17 18 19 6

15 24 25 20 7

14 23 22 21 8

13 12 11 10 9

一个人可以从某个点滑向上下左右相邻四个点之一，当且仅当高度减小。在上面的例子中，一条可滑行的滑坡为24-17-16-1。当然25-24-23-...-3-2-1更长。事实上，这是最长的一条。

Input

输入的第一行表示区域的行数R和列数C(1 <= R,C <= 100)。下面是R行，每行有C个整数，代表高度h，0<=h<=10000。

Output

输出最长区域的长度。

Sample Input

5 5
1 2 3 4 5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9

Sample Output

Source

SHTSC 2002

传送门: http://poj.org/problem?id=1088

这题是一道非常非常经典的经典的二维DP题目，在递归中进行二维DP，DP的好处就是记忆化搜索，省了不少重复的步骤（这也可以理解上着题是可以暴力的~只是需要跑重复的步骤罢了）。

好了，知道了这题是DP，首先就推一发递推公式（DP的思想不难，难就难在于递推公式的推导）。

在任意一点x(i,j),我们需要往相邻的4个方向上搜索,所以显然的,X1(i-1,j),X2(i+1,j),X3(i,j+1),X4(i,j-1)这4个方向递归。

所以.在某点(i,j)时: F(i,j) = MAX(F(i-1,j),F(i+1,j),F(i,j+1),F(i,j-1)) + 1 (这个加1自己好好想想.)

好了, 递推公式出来之后,万事好办.现在来推一发退出条件.

首先,显然的,1.所有点都访问过或者 2.该点已经访问过的时候. 就不需要跑了.

第1点很容易想到，就不说了.

第2点呢,假如存在某点 X1(i,j) ( 1<=i,j < N) 已被访问过，现在要以这点为起始点开始递归.得到结果L1,那么，必然存在点X0,使得L0>=L1.

所以说,2.该点已经访问过的时候,也可以是退出条件.

好了，上代码咯...

import java.util.Scanner;

public class Main {
   
    public static int[][] answer;
    
    public static void main( String[] args ) {
        Scanner sc = new Scanner( System.in );
        while( sc.hasNext() ) {
            int m = sc.nextInt();
            int n = sc.nextInt();
            //数据
            int matrix[][] = new int[ m ][ n ];
            //记录表
            answer = new int[m+1][n+1];
            for( int i = 0; i < m; i++ ) {
                for( int j = 0; j < n; j++ ) {
                    matrix[ i ][ j ] = sc.nextInt();
                }
            }
            for(int i=0;i<m;i++){
                for(int j=0;j<n;j++){
                    Main.slove( matrix, i, j );
                }
            }
            int ans = 0;
            //取出长度最大的结果
            for(int i=0;i<m;i++){
                for(int j=0;j<n;j++){
                   if(answer[i][j] > ans){
                       ans = answer[i][j];
                   }
                }
            }
            System.out.println(ans);
            answer = null;
            matrix = null;
        }
    }

    private static int slove( int[][] matrix, int i, int j ) {
        int max = 0;
        //退出条件2
        if(answer[i][j] > 0 ){
            return answer[i][j];
        }    
           if(constraint( i-1, j,matrix.length, matrix[i].length ) && matrix[i][j] > matrix[i-1][j]){
               int temp = slove( matrix, i-1, j );
               max = temp>max?temp:max;
           }
           
           if(constraint( i+1, j,matrix.length, matrix[i].length ) && matrix[i][j] > matrix[i+1][j]){
               int temp = slove( matrix, i+1, j );
               max = temp > max?temp:max;
           }
           if(constraint( i, j+1,matrix.length, matrix[i].length ) && matrix[i][j] > matrix[i][j+1]){
               int temp = slove( matrix, i, j+1 );
               max = temp > max?temp:max;
           }
           if(constraint( i, j-1,matrix.length, matrix[i].length ) && matrix[i][j] > matrix[i][j-1]){
               int temp = slove( matrix, i, j-1 );
               max = temp > max?temp:max;
           }
          answer[i][j] = max + 1;
        //退出条件1
        return answer[i][j];
    }
    //边界约束
    private static boolean constraint( int x, int y, int m, int n ) {
        if( x >= 0 && x < m && y >= 0 && y < n ) {
            return true;
        }
        return false;
    }
}