【HackerRank】Coin on the Table

题目链接：Coin on the Table

一开始想用DFS做的，做了好久都超时。

看了题解才明白要用动态规划。

设置一个三维数组dp，其中dp[i][j][k]表示在时间k到达(i,j)所需要做的最小改动，那么递推式如下：

图片来源：Editorial，其中当从周围的格子可以直接移动到(i,j)时，delta=0；否则，需要改变周围格子的方向符号，delta=1。

即k-1时刻在(i,.j)周围的四个格子，然后在k时刻移动到(i,j)。并且，看这四个格子中的方向符号是否直接可以完成这次移动，否则就改变这四个格子的方向符号。

代码如下：

 import java.util.*;

 public class Solution {    

     public static void main(String[] args) {
         Scanner in = new Scanner(System.in);
         int n = in.nextInt();
         int m = in.nextInt();
         int K = in.nextInt();

         char[][] map= new char[n][m];
         int[][][] dp = new int[n][m][K+1];

         int star_x = 0;
         int star_y = 0;

         for(int i = 0;i < n;i++){
             String s = in.next();
             if(s.contains("*"))
             {
                 star_x = i;
                 star_y = s.indexOf("*");
             }
             map[i]=s.toCharArray();
         }

         for(int k=0;k <= K;k++){
             for(int i = 0;i < n;i++){
                 for(int j = 0;j < m;j++){
                     if(k==0)
                         dp[i][j][k] = (i==0&&j==0? 0:Integer.MAX_VALUE-1);
                     else{
                         dp[i][j][k] = CalcuMin(i,j,k,dp,map);
                     }
                 }
             }
         }

         int answer = Integer.MAX_VALUE-1;
         for(int k = 0;k <= K;k++){
             answer = Math.min(answer, dp[star_x][star_y][k]);
         }

         System.out.println(answer==Integer.MAX_VALUE-1?-1:answer);

     }

     private static int CalcuMin(int i, int j, int k,int[][][] dp, char[][] map) {
         // TODO Auto-generated method stub
         int mini = Integer.MAX_VALUE-1;
         int n = map.length;
         int m = map[0].length;

         if(i-1>=0){
             if(dp[i-1][j][k-1]+(map[i-1][j]=='D'?0:1) < mini )
                 mini = Math.min(mini,dp[i-1][j][k-1]+(map[i-1][j]=='D'?0:1));
         }

         if(i+1<n){
             if(dp[i+1][j][k-1]+(map[i+1][j]=='U'?0:1) < mini )
                 mini = Math.min(mini,dp[i+1][j][k-1]+(map[i+1][j]=='U'?0:1));
         }

         if(j-1>=0){
             if(dp[i][j-1][k-1]+(map[i][j-1]=='R'?0:1) < mini )
                 mini = Math.min(mini,dp[i][j-1][k-1]+(map[i][j-1]=='R'?0:1));
         }

         if(j+1<m){
             if(dp[i][j+1][k-1]+(map[i][j+1]=='L'?0:1) < mini )
                 mini = Math.min(mini,dp[i][j+1][k-1]+(map[i][j+1]=='L'?0:1));
         }
         return mini;
     }
 }