之前写给同学的代码，关于搜索的一些题型

　　其中有用到一些我自己写的类（栈，队列）改成JDK自带的即可。。。

　　　　迷宫最短路径长度、最短路径、最大区域面积

import java.util.Scanner;

class BestMaze{    //这是我总结作业中，关于最佳图的问题，的类
    int[] d1;
    int[] d2; 
    int[][] map;
    int m, n, count, minlen;
    int l = 0;        //l是指墙数(当然是有墙的情况才用)
    Queue<Point> q;
    Stack<Point> s;
    Point[] wall;
    public BestMaze(){
        this(0,0,null,null);
    }
    public BestMaze(int m, int n, int[] d1, int[] d2){
        this.m = m;
        this.n = n;
        this.d1 = d1;    //搜索中纵坐标(也就是x)的偏移值数组
        this.d2 = d2;    //搜索中横坐标(也就是y)的偏移值数组
        this.count = -1;
        map = new int[m+1][n+1];
        wall = new Point[(m+1)*(n+1)];    //纯英文意思就是，墙(就是这个位置走不了的意思)
    }
    public boolean meetWall(Point p){    //判断是否撞墙
        if(!(p.x>=0 && p.x<m && p.y>=0 && p.y<n))
            return false;
        for(int j = 0; j < l; j++)
            if(wall[j].x == p.x && wall[j].y == p.y)
                return false;
        return true;
    }
    public void Bestlen(Point start, Point end){    //队列广搜，蒽
        map = new int[m+1][n+1];
        q = new LinkedQueue<Point>();
        map[start.x][start.y] = 1;    //先把起始点标记了，不要跑路的时候又踩了这里
        start.step = 0;
        q.add(start);
        
        while(!q.isEmpty()){
            Point front = q.poll();    //队头搞出来
            
            if(front.x == end.x && front.y == end.y){    //判断是否到达终点，到就停
                minlen = front.step;
                break;
            }
            
            for(int i = 0; i < d1.length; i++){
                //移动的下一个点，定义为前一个点的偏移值后的位置
                Point move = new Point(front.x+d1[i], front.y+d2[i], front.step+1);
                
                boolean flag = meetWall(move);    //判断墙，也可以结合某点是否走过使用
                
                if(flag && map[move.x][move.y]==0){
                    q.add(move);
                    map[move.x][move.y] = move.step;    //记录能到这个点的最快步数
                }
            }
        }
        map[start.x][start.y] = 0;    //起始点当然还是要变回0的嘛
    }
    public void BestCount(Point start, Point end){    //其实是深搜，蒽
        //最快到达的次数有多少种的方法，类似上面的地方就不备注了
        map = new int[m+1][n+1];
        s = new LinkedStack<Point>();    //注意这里用栈！
        s.push(start);
        start.step = 0;
        
        while(!s.isEmpty()){
            Point front = s.pop();
            
            if(front.x == end.x && front.y == end.y)
                    count++;
            
            for(int i = 0; i < d1.length; i++){
                Point move = new Point(front.x+d1[i], front.y+d2[i], front.step+1);
                
                boolean flag = meetWall(move);
                
                if(flag && (map[move.x][move.y]==map[front.x][front.y]+1))
                    s.push(move);
                //这里是不需要标记步数的，只要能走就入栈
            }
        }
    }
    public int BestArea(){    //这个也是深搜，想看效果可以把测试输出的地方取消备注，调用就可以了
        int max = 0, t;
        s = new LinkedStack<Point>();
        
        for(int i = 0; i < m; i++)
            for(int j = 0; j < n; j++){
                if(map[i][j] == 1){        //这里是"1"是未走的路
                    t = 1;
                    s.push(new Point(i, j));
                    map[i][j] = 0;         //"0"是墙
                    
                    while(!s.isEmpty()){
                        Point f = s.pop();
                        for(int k = 0; k < d1.length; k++){
                            int dx = f.x + d1[k];
                            int dy = f.y + d2[k];
                            
                            if(dx>=0 && dx<m && dy>=0 && dy<n && map[dx][dy] == 1){
                                s.push(new Point(dx, dy));
                                map[dx][dy] = 0;    //走过就变成墙，也可以染色(某一块区域同一个数字)
                                t++;
                            }
                        }
                    }
//                    outMap();        //这是测试输出的地方
//                    System.out.println(t);
                    if(max < t)        //这是找面积最大的
                        max = t;
                }
            }
        
        return max;
    }
    //求最短路径，返回点集
    public Point[] Bestload(Point start, Point end){
//        Bestlen(start, new Point(-1, -1));    //广搜全图
        Bestlen(start, end);    //广搜终点
//        outMap();    广搜后再深搜
        
        s = new LinkedStack<Point>();
        s.push(start);
        while(!s.isEmpty()){
            Point front = s.peek();
            boolean t = true;
            
            if(front.x == end.x && front.y == end.y){
                break;
            }
            for(int i = 0; i < d1.length; i++){
                Point move = new Point(front.x+d1[i], front.y+d2[i]);
                
                boolean flag = meetWall(move);    //判断是否撞墙
                
                if(flag && (map[move.x][move.y]==map[front.x][front.y]+1)){
                    wall[l++] = move;    //走过的地方设置为墙
                    s.push(move);
//                    System.out.println("入栈："+move + ",,"+map[move.x][move.y]);
                    t = false;
                    break;        //确定一次走路只走一点
                }
            }
            if(t){    //若此点四周都是墙，就丢了
//                System.out.println("出--" + s.peek());
                s.pop();
            }
        }
        int len = map[end.x][end.y]+1;        //结果集的长度肯定是深搜后到达终点的最小步数
        Point[] result = new Point[len];
        
//        StringBuffer sb = new StringBuffer();    //调试，查看结果
        while(!s.isEmpty())
        {
            result[--len] = s.peek();    //倒序装回点集
//            sb.insert(0, s.peek());                //调试，查看结果
            s.pop();
        }
        
//        System.out.println(sb.toString());        //调试，查看结果
        return result;
    }
    public void outMap(){    //查看图的情况
        for(int i = 0; i < m; i++){
            for(int j = 0; j < n; j++)
                System.out.print(map[i][j] + " ");
            System.out.println();
        }
    }

    public static void migonglujing(String[] args) {    //最短迷宫路径的main方法
        Scanner sc = new Scanner(System.in);
        int id = 1;
        int[] d1 = {0, 1, 1, 1, 0, -1, -1, -1};
        int[] d2 = {1, 1, 0, -1, -1, -1, 0, 1};
        while(sc.hasNext()){
            int m = sc.nextInt();
            int n = sc.nextInt();
//            if(m == 0 && n == 0)    break;
            BestMaze maze = new BestMaze(m, n, d1, d2);
            int l = 0;
            for(int i = 0; i < m; i++)
                for(int j = 0; j < n; j++)
                    if(sc.nextInt() == 1)    //输入为1，是墙
                        maze.wall[l++] = new Point(i, j);
            maze.l = l;        //确定墙的数量
            Point[] result = maze.Bestload(new Point(0, 0), new Point(m-1, n-1));
            for(int i = 0; i < result.length-1; i++)
                System.out.print(result[i] + "->");
            System.out.print(result[result.length-1]);
            
        }
        System.gc();sc.close();
    }
    
    public static void Qishijuhui(String[] args) {    //这是骑士聚会问题的main方法
        Scanner sc = new Scanner(System.in);
        int id = 1;
        int[] d1 = {-2, -1, 1, 2, 2, 1, -1, -2};
        int[] d2 = {1, 2, 2, 1, -1, -2, -2, -1};
        while(sc.hasNext()){
            int n = sc.nextInt();
            int m = sc.nextInt();
//            if(m == 0 && n == 0)    break;
            BestMaze[] maze = new BestMaze[m];    //求出每个骑
            for(int i = 0; i < m; i++){
                 maze[i] = new BestMaze(n, n, d1, d2);
                 maze[i].Bestlen(new Point(sc.nextInt(), sc.nextInt()), new Point(-1, -1));
            }
//        //    查看广搜后的结果,你可以取消备注看看。。。
//            int[][] count = new int[n][n];
//            
//            for(int i = 0; i < m; i++){
//                for(int j = 0; j < n; j++){
//                    for(int k = 0; k < n; k++){
//                        count[j][k] += maze[i].map[j][k];
//                        System.out.print(maze[i].map[j][k] + "\t");
//                    }
//                    System.out.println();
//                }
//                if(i == m-1){
//                    System.out.println("------------总步数--------------");
//                    for(int j = 0; j < n; j++){
//                        for(int k = 0; k < n; k++)
//                            System.out.print(count[j][k] + "\t");
//                        System.out.println();
//                    }
//                }
//                System.out.println("-------------------------------");
//            }
//        //    下面开始找最佳位置(所有骑士到这里的总天数最小，天数相等情况下要最晚到的骑士步数最小的)            

            int[][] countday = new int[n][n];    
            int minday = 99999;
            int lastday = 0;
            Point bestposition = null;
            
            for (int i = 0; i < n; i++)
                for (int j = 0; j < n; j++) {
                    int day = 0;
                    int last = 0;    //这个位置上，最晚到达的骑士的天数
                    
                    for (int k = 0; k < m; k++) {    //求所有骑士到这位置的总天数
                        day += maze[k].map[i][j];
                        if (maze[k].map[i][j] > last)    //记住最晚的那个
                            last = maze[k].map[i][j];
                    }
                    if (minday > day) {        //要天数最小的位置
                        minday = day;
                        bestposition = new Point(i, j);
                        lastday = last;
                    }
                    //天数相等情况下，要最晚到达的骑士的步数最小的位置
                    else if (minday == day && last < lastday) {
                        bestposition = new Point(i, j);
                        lastday = last;
                    }
                    countday[i][j] = day;
                }
            System.out.println("最佳聚会位置: " + bestposition);
            System.out.println("最晚到达聚会的骑士走了" + lastday +"天");
            System.out.println("总步数为: " + countday[bestposition.x][bestposition.y]);
        }
        
        System.gc();sc.close();
    }
}

 　　一个黑白区域面积的题目，类似染色问题

import java.awt.*;
import java.util.*;

public class Main{
    static Scanner sc = new Scanner(System.in);

    static int[] d1 = {0, 0, 1, -1};
    static int[] d2 = {1, -1, 0, 0};
    static int dfs(int[][] map, int m, int n, int i, int j, int num){
            int t = 1;
            Stack<Point> stack = new Stack<Point>();
            map[i][j] = 0;
            stack.push(new Point(i, j));
            while(!stack.isEmpty()){
                Point p = stack.pop();
                for(int k = 0; k < 4; k++){
                    int dx = p.x + d1[k];
                    int dy = p.y + d2[k];
                    if(dx>0 && dx<m && dy>=0 && dy<n && map[dx][dy] == num){
                        map[dx][dy] = 0; t++;
                        stack.push(new Point(dx, dy));
                    }
                }
            }
            return t;
    }
    
    public static void main(String[] args) {
        while(sc.hasNext()){
            int m = sc.nextInt();
            int n = sc.nextInt();
            int[][] map = new int[m][n];
            
            for(int i = 0; i < m; i++){
                String s = sc.next();
                for(int j = 0; j < n; j++){
                    if(s.charAt(j) == 'D')
                        map[i][j] = -1;
                    if(s.charAt(j) == 'W')
                        map[i][j] = 1;
                }
            }

            int maxD = 0, maxW = 0, t;
            for(int i = 0; i < m; i++){
                for(int j = 0; j < n; j++){
                    if(map[i][j] == 1){
                        t = dfs(map, m, n, i, j, 1);
                        maxW = maxW>t? maxW:t;
                    }
                    if(map[i][j] == -1){
                        t = dfs(map, m, n, i, j, -1);
                        maxD = maxD>t? maxD:t;
                    }
                }
            }
            System.out.println(maxW + " " + maxD);
        }
        System.gc();sc.close();
    }
    
}