拼多多笔试_探险家冒险和大数问题

import java.util.*;

        /*有两个用字符串表示的非常大的大整数,算出他们的乘积，也是用字符串表示。不能用系统自带的大整数类型。
        输入描述:
        空格分隔的两个字符串，代表输入的两个大整数

        输出描述:
        输入的乘积，用字符串表示

        输入例子1:
        72106547548473106236 982161082972751393

        输出例子1:
        70820244829634538040848656466105986748*/
public class Main {
    public static void convert(char[] c){
        for (int i = 0; i < c.length / 2; i++) {
            c[i] += c[c.length - 1 - i];
            c[c.length - 1 - i] = (char)(c[i] - c[c.length - 1 - i]);
            c[i] = (char)(c[i] - c[c.length - 1 - i]);
        }
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        String s1 = scanner.next();
        String s2 = scanner.next();

        //转换为字符数组
        char[] c1 = s1.toCharArray();
        char[] c2 = s2.toCharArray();

        //创建结果数组，储存最终结果
        int[] res = new int[c1.length + c2.length + 3];
        for (int i = 0; i < res.length; i++) {
            res[i] = 0;
        }
        //对s1与s2数组的高低位交换处理
        convert(c1);convert(c2);

        //不考虑进位对c1与c2的各个位置相乘
        for (int i = 0; i < c1.length; i++) {
            for (int j = 0; j < c2.length; j++) {
                res[i+j] += Integer.parseInt(String.valueOf(c1[i]))
                            * Integer.parseInt(String.valueOf(c2[j]));
            }
        }

        //进位处理
        for (int i = 0; i < res.length; i++) {
            //获取进位
            int carry = res[i] / 10;
            res[i] = res[i] % 10;
            if(carry > 0){
                res[i + 1] += carry;
            }
        }

        //输出处理，先查找前导0的位置
        int indexOfNonZero = 0;
        for (int i = res.length -1; i >=0 ; i--) {
            if(res[i] > 0){
                indexOfNonZero = i;
                break;
            }
        }
        //从后往前输出
        for (int i = indexOfNonZero; i >= 0 ; i--) {
            System.out.print(res[i]);
        }

    }

}

import java.util.*;
/*假设一个探险家被困在了地底的迷宫之中，要从当前位置开始找到一条通往迷宫出口的路径。迷宫可以用一个二维矩阵组成，
    有的部分是墙，有的部分是路。迷宫之中有的路上还有门，每扇门都在迷宫的某个地方有与之匹配的钥匙，
    只有先拿到钥匙才能打开门。请设计一个算法，帮助探险家找到脱困的最短路径。如前所述，迷宫是通过一个
    二维矩阵表示的，每个元素的值的含义如下 0-墙，1-路，2-探险家的起始位置，3-迷宫的出口，大写字母-门，
    小写字母-对应大写字母所代表的门的钥匙
        输入描述:
        迷宫的地图，用二维矩阵表示。第一行是表示矩阵的行数和列数M和N
        后面的M行是矩阵的数据，每一行对应与矩阵的一行（中间没有空格）。M和N都不超过100, 门不超过10扇。

        输出描述:
        路径的长度，是一个整数

        输入例子1:
        5 5
        02111
        01a0A
        01003
        01001
        01111

        输出例子1:
        7*/
public class Main {
    static class Node{
        int x;
        int y;
        int key;
        public Node(int x,int y,int key){
            this.x = x;
            this.y = y;
            this.key = key;
        }
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int m = scanner.nextInt();
        int n = scanner.nextInt();
        char[][] datas = new char[m][n];
        for (int i = 0; i < m; i++) {
            char[] chars = scanner.next().toCharArray();
            datas[i] = chars;
        }

        //寻找初始位置和结束位置
        int startX = 0;int startY = 0;
        int endX = 0;int endY = 0;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if(datas[i][j] == '2'){
                    startX = i;
                    startY = j;
                    continue;
                }
                if(datas[i][j] == '3'){
                    endX = i;
                    endY = j;
                }
            }
        }

        System.out.println(bfs(m,n,startX,startY,endX,endY,datas));

    }

    public static int bfs(int m, int n,int startX,int startY,int endX,int endY,char[][] datas){
        //定义4个方向,上下左右
        int [] xx ={0,0,1,-1};
        int [] yy ={1,-1,0,0};

        LinkedList<Node> queue = new LinkedList<>();

        //1024正好是十个钥匙的状态
        int[][][] keys = new int[m][n][1024];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                for (int k = 0; k < 1024; k++) {
                    keys[i][j][k] = Integer.MAX_VALUE;
                }
            }
        }
        /**
         * keys的作用：
         *      1>第3维key的作用保证每个位置都携带一个钥匙的状态，这样当发现某个位置是门或者是钥匙的时候就可以及时的更新
         *      2>这个三维数组的目的是判断当前位置和当前钥匙状态下，是否访问过，没有访问过就+1,并添加至队列
         *              访问过就不再添加；其实就是记录步数！！
         */
        
        queue.add(new Node(startX,startY,0));
        keys[startX][startY][0] = 0;

        while(queue.size() > 0){

            Node node = queue.poll();
            
            
            int x = node.x;
            int y = node.y;
            int key = node.key;

            //判断是否到达最后位置
            if(x == endX && y == endY){
                return keys[x][y][key];
            }

            //从四个方向开始找临节点
            for (int i = 0; i < 4; i++) {

                x = node.x + xx[i];
                y = node.y + yy[i];
                key = node.key;

                //判断当前位置是否出界
                if(!(x >=0 && x < m && y>=0 && y < n && datas[x][y] !='0')){
                    //出界
                    continue;
                }

                //看当前位置是否有钥匙，更新钥匙状态
                if(datas[x][y] >= 'a' && datas[x][y] <= 'j'){
                    key = key | (0x1 << (datas[x][y] - 'a'));
                }

                //看当前位置是否是门
                if(datas[x][y] >= 'A' && datas[x][y] <= 'J'){
                    if(!((key & (0x1 <<(datas[x][y] - 'A'))) > 0)){
                        //没有对应的钥匙，退出当前位置
                        continue;
                    }
                }

                //判断当前状态是否走过
                if (keys[x][y][key] == Integer.MAX_VALUE) {
                    keys[x][y][key] = keys[node.x][node.y][node.key] + 1;
                    queue.add(new Node(x, y, key));
                }
            }
        }
        return Integer.MAX_VALUE;
    }

}