HDOJ1195 Open the Lock

题意：

给俩个四位数，第一个变到到第二个最少需要多少步

每一个只能  每一位+-1（一次操作一个数 不能同时操作不同位）

1-1=0则变9  9+1=10则变1

或者相邻俩位数字交换 第一位和第四位不算相邻位

解题思路：

将四位数转换成四位数组，每一个四位数对应一个位置，这样可以用广搜寻找俩个位置之间的最短路径

广搜原理点此

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


public class Main{

    static Number[][][][] numbers=new Number[10][10][10][10];
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        for (int i = 1; i < numbers.length; i++) {
            for (int j = 1; j < numbers[i].length; j++) {
                for (int j2 = 1; j2 < numbers[i][j].length; j2++) {
                    for (int k = 1; k < numbers[i][j][j2].length; k++) {
                        numbers[i][j][j2][k]=new Number(i, j, j2, k);
                    }
                }
            }
        }
        while(sc.hasNext()){
            int n=sc.nextInt();
            while(n-->0){
                for (int i = 1; i < numbers.length; i++) {
                    for (int j = 1; j < numbers[i].length; j++) {
                        for (int j2 = 1; j2 < numbers[i][j].length; j2++) {
                            for (int k = 1; k < numbers[i][j][j2].length; k++) {
                                numbers[i][j][j2][k].isVisit=false;
                                numbers[i][j][j2][k].time=0;
                            }
                        }
                    }
                }
                String s1=sc.next();
                String s2=sc.next();
                Number first=numbers[s1.charAt(0)-'0'][s1.charAt(1)-'0'][s1.charAt(2)-'0'][s1.charAt(3)-'0'];
                first.isVisit=true;
                NumberQueue queue=new NumberQueue();
                queue.push(first);
                searchNumberBFS(queue,numbers[s2.charAt(0)-'0'][s2.charAt(1)-'0'][s2.charAt(2)-'0'][s2.charAt(3)-'0']);
            }
        }
    }
    static int dir[][]={{1,0,0,0},{-1,0,0,0},
                         {0,1,0,0},{0,-1,0,0},
                         {0,0,1,0},{0,0,-1,0},
                         {0,0,0,1},{0,0,0,-1}};
    private static void searchNumberBFS(NumberQueue queue,Number number) {
        while(!queue.isEmpty()){
            Number num=queue.pop();
            for (int i = 0; i < dir.length; i++) {
                int a=num.a+dir[i][0];
                a=change(a);
                int b=num.b+dir[i][1];
                b=change(b);
                int c=num.c+dir[i][2];
                c=change(c);
                int d=num.d+dir[i][3];
                d=change(d);
                if(ajust(queue, number, num, a, b, c, d))
                    return;
            }
            int a=num.a;
            int b=num.b;
            int c=num.c;
            int d=num.d;
            if(ajust(queue, number, num, b, a, c, d))
                return;
            if(ajust(queue, number, num, a, c, b, d))
                return;
            if(ajust(queue, number, num, a, b, d, c))
                return;
            
        }
    }
    private static boolean ajust(NumberQueue queue, Number number, Number num,
            int a, int b, int c, int d) {
        if(!numbers[a][b][c][d].isVisit){
            numbers[a][b][c][d].time=num.time+1;
            if(a==number.a&&b==number.b&&c==number.c&&d==number.d){
                System.out.println(number.time);
                return true;
            }
            numbers[a][b][c][d].isVisit=true;
            queue.push(numbers[a][b][c][d]);
        }
        return false;
    }
    private static int change(int a) {
        a=(a==10?1:a);
        a=(a==0?9:a);
        return a;
    }
    static class Number{
        int a,b,c,d;
        int time;
        boolean isVisit;
        public Number(int a, int b, int c, int d) {
            this.a = a;
            this.b = b;
            this.c = c;
            this.d = d;
        }
    }
    static class NumberQueue{
        LinkedList<Number> lkl=new LinkedList<Number>();
        public void push(Number b){
            lkl.add(b);
        }
        public Number pop(){
            return lkl.pollFirst();
        }
        public boolean isEmpty(){
            return lkl.isEmpty();
        }
    }
}