微软笔试3 Demo Day

题目

Demo Day

思路

一开始想用递归做，花了半天功夫写完超时，直接runtime error。但是同学的递归代码就能得40分，哭。。。
原来是hiho coder上提交的Java有格式要求，不能自己加package，以后复制代码需谨慎啊。。。

之后修改了递归的package依然报出Wrong Answer错误。。。，
看来需要重新整理下思路，看来讨论才知道，原来可以把一个block去掉，也能把一个block加上。。。

那什么时候需要加上block？
像这样的

<pre class="java" name="code">.......bbbbb
......bbbbbb
......bbbbbb
............

这种情况我们只需要在左上角第一行第二个加上block就可以实现机器人自动走出了，如下：

<pre class="java" name="code">.b.....bbbbb
......bbbbbb
......bbbbbb
............

又哭晕。。。

看了同学的解法才知道要走动态规划：

<pre class="java" name="code">dp定义：
    0 <= i <= N - 1;
    0 <= j <= M - 1;
    dp[i][j][0]：处于在i，j位置，当前向右走，达到该状态最小需要的调整次数。
    dp[i][j][1]：处于在i，j位置，当前向下走，达到该状态最小需要的调整次数。
递推关系：
    这里情况比较复杂，需要分边界情况和非边界，只列举出非边界情况：
    dp[i - 1][j - 1]    dp[i - 1][j][1]
    dp[i][j - 1][0]     dp[i][j]         b?
                        b?  
    i，j位置总共四种情况：
    1、向右走，从左直着来
    2、向右走，从上先到i，j，然后右转
    3、向下走，从上直着来
    4、向下走，从左先到i，j，然后下转
    如果右侧和下侧有block，需要加判断

这里我们看到，dp[i][j]只依赖于上侧和左侧的dp，所以我们在循环的时候是这么走的：

需要注意的是：循环的边界条件。写算法的边界条件真是太重要了。
包括：

• 循环的编辑
• 程序输入的编辑
• 算法考虑到达的边界

源代码（写了很久，痛）

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);
        int N, M;
        N = sc.nextInt();
        M = sc.nextInt();
        if (N <= 0 || M <= 0) {
            System.out.println(0);
            return;
        }
        char [][] block = new char [N][M];
        for (int i = 0; i < N; i++) {
            String temp = sc.next();
            block[i] = temp.toCharArray();
        }

        int [][][] dp = new int [N][M][2];

        dp[0][0][0] = block[0][0] == 'b' ? 1 : 0;
//        dp[0][0][1] = dp[0][0][0];
        int K = Math.max(M - 1, N - 1);
        for (int cr = 0; cr <= N + M - 2; cr++) {
            for (int i = 0; i <= K; i++) {
                int x = i;
                int y = cr - i;
                if (x > N - 1 || y > M - 1 || x < 0 || y < 0) {
                    continue;
                }
                if (x == 0) {
                    //right
                    if (y > 0) {
                        dp[x][y][0] = block[x][y] == 'b' ? dp[x][y - 1][0] + 1 : dp[x][y - 1][0];
                    }
                    //down
                    if (y == M - 1 || block[x][y + 1] == 'b') {
                        dp[x][y][1] = dp[x][y][0];
                    } else {
                        dp[x][y][1] = dp[x][y][0] + 1; 
                    }
                } else if (y == 0) {
                    //down
                    if (x > 0) {
                        dp[x][y][1] = block[x][y] == 'b' ? dp[x - 1][y][1] + 1 : dp[x - 1][y][1];
                    }
                    //right
                    if (x == N - 1 || block[x + 1][y] == 'b') {
                        dp[x][y][0] = dp[x][y][1];
                    } else {
                        dp[x][y][0] = dp[x][y][1] + 1; 
                    }
                } else if (x == N - 1 && y != M - 1) {
                    //right
                    if (y > 0) {
                        dp[x][y][0] = Math.min(dp[x - 1][y][1], dp[x][y - 1][0]);
                        dp[x][y][0] = block[x][y] == 'b' ? dp[x][y][0] + 1 : dp[x][y][0];
                    } else {
                        dp[x][y][0] = block[x][y] == 'b' ? dp[x - 1][y][1] + 1 : dp[x - 1][y][1];
                    }
                } else if (y == M - 1 && x != N - 1) {
                    //down
                    if (x > 0) {
                        dp[x][y][1] = Math.min(dp[x - 1][y][1], dp[x][y - 1][0]);
                        dp[x][y][1] = block[x][y] == 'b' ? dp[x][y][1] + 1 : dp[x][y][1];
                    } else {
                        dp[x][y][1] = block[x][y] == 'b' ? dp[x][y - 1][0] + 1 : dp[x][y - 1][0];
                    }
                } else if (y == M - 1 && x == N - 1) {
                    dp[x][y][0] = Math.min(dp[x - 1][y][1], dp[x][y - 1][0]); 
                    dp[x][y][1] = Math.min(dp[x - 1][y][1], dp[x][y - 1][0]); 
                    dp[x][y][0] += block[x][y] == 'b' ? 1 : 0;
                    dp[x][y][1] += block[x][y] == 'b' ? 1 : 0;
                } else {
                    //down
                    if (block[x][y + 1] == 'b') {
                        dp[x][y][1] = Math.min(dp[x - 1][y][1], dp[x][y - 1][0]);
                    } else {
                        dp[x][y][1] = Math.min(dp[x - 1][y][1], dp[x][y - 1][0] + 1);
                    }
                    dp[x][y][1] += block[x][y] == 'b' ? 1 : 0;
                    //right
                    if (block[x + 1][y] == 'b') {
                        dp[x][y][0] = Math.min(dp[x - 1][y][1], dp[x][y - 1][0]);
                    } else {
                        dp[x][y][0] = Math.min(dp[x - 1][y][1] + 1, dp[x][y - 1][0]);
                    }
                    dp[x][y][0] += block[x][y] == 'b' ? 1 : 0;
                }
            }
        }

        System.out.println(Math.min(dp[N - 1][M - 1][0], dp[N - 1][M - 1][1]));
//      System.out.println("Right:");
//      for (int i = 0; i < N; i++) {
//          for (int j = 0; j < M; j++) {
//              System.out.print(dp[i][j][0] + " ");
//          }
//          System.out.println("");
//      }
//      
//      System.out.println("Down:");
//      for (int i = 0; i < N; i++) {
//          for (int j = 0; j < M; j++) {
//              System.out.print(dp[i][j][1] + " ");
//          }
//          System.out.println("");
//      }
//        System.out.println(findMinR(block, 0, 0, N - 1, M - 1));
    }
}