某飞笔试题

题目

首行输入两个数，n和m。接下来输入一个m*n的字符地图。’.‘是可以直接走的，’#'是障碍，需要破坏掉才能走！问从左上角走到右下角（保证左上角和右下角都是‘.’）最少需要破坏多少个障碍物？
2<=m<=1000
2<=n<=1000
地图的点一定是 . 或者 # 。

思路

利用深搜，虽然可以做出来，但是必定超时！

利用广搜，开辟一个dp数组，进行广搜，当前数值先标记为Integer的最大值，深搜后，假设走当前路径所要破坏的障碍数目小于dp数组所存在的数目，那么就进行改变。走到最后，就是最终结果

代码

import java.util.Deque;
import java.util.LinkedList;
import java.util.Scanner;

class Element{
    int x;
    int y;
    public Element(int x,int y)
    {
        this.x=x;
        this.y=y;
    }
}

public class Main{
    static int n;
    static int m;
    static char map[][]=new char[1024][1024];
    static int dp[][] = new int[1024][1024];
    static int direction[][]= {{0,1},{1,0},{0,-1},{-1,0}};//方向数组
    static Deque<Element> deque = new LinkedList<>();

    public static void main(String[] args) {
        Scanner reader = new Scanner(System.in);
        n = reader.nextInt();   // 行
        m = reader.nextInt();   // 列
        for (int i=0;i<n;++i)
        {
            String temp = reader.next();
            for (int j=0;j<m;++j)
            {
                map[i][j]=temp.charAt(j);
                dp[i][j]=Integer.MAX_VALUE;
            }
        }

        dp[0][0]=0; // 需要破坏的障碍数目为0
        deque.add(new Element(0,0));
        bfs();
        System.out.println(dp[n-1][m-1]);
    }

    private static void bfs()
    {
        while (!deque.isEmpty())
        {
            Element temp = deque.poll();
            int t_x=0;
            int t_y=0;
            for (int g=0;g<4;++g)
            {
                t_x=temp.x+direction[g][0];
                t_y=temp.y+direction[g][1];
                if (check(t_x,t_y,dp[temp.x][temp.y]))
                {
                    if (map[t_x][t_y]=='#')
                    {
                        dp[t_x][t_y]=dp[temp.x][temp.y]+1;
                        deque.add(new Element(t_x,t_y));
                    }
                    else
                    {
                        dp[t_x][t_y]=dp[temp.x][temp.y];
                        deque.add(new Element(t_x,t_y));
                    }
                }
            }
        }
    }

    // 不越界
    private static boolean check(int x, int y,int now)
    {
        // 不越界，且 到达当前位置需要破坏的值 小于 位置上的值
        return x>=0 && x<m && y>=0 && y<n && now < dp[x][y];
    }
}
	

总结

虽然笔试已经做完了，这是交卷后的想法，不知道还有没有缺陷，目前是没有发现的！