蓝桥杯-跳跃（DFS+DP）

题目描述

小蓝在一个 �n 行 �m 列的方格图中玩一个游戏。

开始时，小蓝站在方格图的左上角，即第 11 行第 11 列。

小蓝可以在方格图上走动，走动时，如果当前在第 �r 行第 �c 列，他不能走到行号比 �r 小的行，也不能走到列号比 �c 小的列。同时，他一步走的直线距离不超过 33。

例如，如果当前小蓝在第 33 行第 55 列，他下一步可以走到第 33 行第 66 列、第 33 行第 77 列、第 33 行第 88 列、第 44 行第 55 列、第 44 行第 66 列、第 44 行第 77 列、第 55 行第 55 列、第 55 行第 66 列、第 66 行第 55 列之一。

小蓝最终要走到第 �n 行第 �m 列。

在图中，有的位置有奖励，走上去即可获得，有的位置有惩罚，走上去就要接受惩罚。奖励和惩罚最终抽象成一个权值，奖励为正，惩罚为负。

小蓝希望，从第 11 行第 11 列走到第 �n 行第 �m 列后，总的权值和最大。请问最大是多少？

方法一：DFS搜索

搜索出顶点到底点的所有路径，并求出所经过路径的最大权值和

import java.util.*;
public class P1 {
    static Scanner scanner = new Scanner(System.in);
    static int n= scanner.nextInt();
    static int m= scanner.nextInt();
    static int []dx={0,0,0,1,2,3,1,2,1};
    static int [][]arr=new int[n][m];
    static int []dy={1,2,3,0,0,0,1,1,2};
    static boolean[][]mark=new boolean[n][m];
    static int max_length = Integer.MIN_VALUE;
    public static void main(String[] args) {
        for (int i = 0; i < n; i++) {
            for (int j =0; j < m ; j++) {
                arr[i][j]= scanner.nextInt();
            }
        }

        dfs(0,0,arr[0][0]);
        System.out.println(max_length);

    }
    public static void  dfs(int x,int y,int length){
        if (x==n-1&&y==m-1){
            max_length= Math.max(max_length,length);
        }
        mark[x][y]=true;
        for (int i = 0; i < dx.length; i++) {
            int nx=x+dx[i];
            int ny=y+dy[i];
            if ( nx < n && ny < m){
                if ( mark[nx][ny] == false ) dfs(nx,ny,length+arr[nx][ny]);
            }
            mark[x][y]=false;
        }
    }
}

方法二：DP动态规划

定义dp[i][j]为前面的点到该点所走过的路径的最大权值和

import java.util.*;

public class P2 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n=scanner.nextInt();
        int m=scanner.nextInt();
        int []dx={0,0,0,-1,-2,-3,-1,-2,-1};
        int []dy={-1,-2,-3,0,0,0,-1,-1,-2};

        int[][] map = new int[n+1][m+1];
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                map[i][j]= scanner.nextInt();
            }
        }

        int [][]dp=new int[n+1][m+1];

        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                int max_value=-100;

                for (int k = 0; k < dx.length; k++) {
                    if(i+dx[k]>0&&j+dy[k]>0) max_value=Math.max(max_value,dp[i+dx[k]][j+dy[k]]);
                }
                if(i==1&&j==1){
                    dp[1][1]=map[1][1];
                }
                else dp[i][j]=max_value+map[i][j];
            }
        }
        System.out.println(dp[n][m]);
    }
}