【leetcode】Weekly Contest 92

　　emm，两天打的周赛，万年三题qaq，不过这次题目好像比上次的难一丢丢。

1.Transpose Matrix

　　把矩阵A[i][j]的每个元素改成B[j][i]，超级超级大水题，然后wa了两发qaq。

    public int[][] transpose(int[][] A) {
        int row = A.length;
        int clon = A[0].length;
        int[][] res = new int[clon][row];
        for(int i = 0;i<row;i++){
            for(int j = 0; j<clon;j++){
                res[j][i] = A[i][j];
            }
        }
        return res;
    }

2. Smallest Subtree with all the Deepest Nodes

　　一开始脑子抽了，没理解到底求的是什么，看了两三遍才反应过来求含最深节点的根节点（emm，这个题意有点难解释，看例子比较好）。

　　然后发现其实求每个节点的深度，如果其左孩子节点和右孩子节点最大深度是一样的就返回该节点（所求的根节点），如果不是，就进入深度大的那个节点继续判断即可。

　　我的代码就是先求每个节点的深度，然后再去找所求节点，怕递归太深超时就用hashmap记录了每个节点的深度，这样就不需要重复计算。

    HashMap<TreeNode, Integer> map;
    public TreeNode subtreeWithAllDeepest(TreeNode root) {
        if(root == null){
            return null;
        }
        map = new HashMap<>();
        while(getDeepth(root.left) != getDeepth(root.right)){
            if(getDeepth(root.right) > getDeepth(root.left)){
                root = root.right;
            }else {
                root = root.left;
            }
        }
        return root;
    }
    public int getDeepth(TreeNode root){
        if(root == null){
            return 0;
        }else if(map.containsKey(root)){
            return map.get(root);
        }else {
            int deepth = Math.max(getDeepth(root.left), getDeepth(root.right))+1;
            map.put(root, deepth);
            return deepth;
        }
    }

3. Prime Palindrome

　　第三题题意很简单，就是给一个数字，求不小于该数字的最小回文素数，emm，第一反应就是暴力肯定不行，然后就陷入了沉思中。

　　那么肯定要先找出一种遍历回文数或素数的办法，因为素数遍历不用暴力法我不会qaq，找依次遍历回文数好像简单很多，note提示了答案肯定小于2*10^8，那么我们只需要最大遍历到四位数，再把后半部分补全即可，这样只需要遍历最大1w次，再判断每个是否是素数即可。

　　不过奇数位和偶数位判断好像很麻烦的样子，又想到了偶数位回文数肯定不可能是素数（除了11），因为会被11整除啦，比如abba，可以拆成1111*a+110*（b-a）。那么生成回文数的方法只需要写一个就好啦！

    boolean isPrime(int n){//判断是否是素数
        if(n == 1){
            return false;
        }
        if(n == 2){
            return true;
        }
        int k = (int) Math.sqrt(n);
        for(int i = 2;i<=k;i++){
            if(n%i==0){
                return false;
            }
        }
        return true;
    }
    
    int getPalindrome(int n){//生成奇数位回文数
        int res=n/10;
        while(n!=0)
        {
            res=res*10+n%10;//从低到高依次把该位数字添加到末尾
            n/=10;
        }
        return res;
    }
    
    public int primePalindrome(int N) {
        if(N<=11){//小于11直接遍历即可
            for(int i = N;i<=11;i++){
                if(isPrime(i)){
                    return i;
                }
            }
        }
        for(int i = 10;;i++){//比11大就遍历回文数
            int palindrome = getPalindrome(i);
            if(palindrome<N){
                continue;
            }
            if(isPrime(palindrome)){
                return palindrome;
            }
        }
    }

4.Shortest Path to Get All Keys

 　　其实，补完题发现不是很难qaq，没做出来一个原因是明明想着用bfs搜就好了，但是写的时候被一股神秘力量操控，一直在想用递归写bfs，等反应过来的时候时间不太够了，这种限时训练还是需要提高思维和编码能力。

　　bfs搜的时候把key也记录下来就好啦，不难不难（逃。

class Path {
        int bitMask;//记录key的数量，111（7）表示有三把钥匙，abc
        int x;
        int y;

        public Path(int x, int y, int bitMask) {
            this.x = x;
            this.y = y;
            this.bitMask = bitMask;
        }

        @Override
        public boolean equals(Object o) {
            Path p = (Path) o;
            return bitMask == p.bitMask && x == p.x && y == p.y;
        }

        @Override
        public int hashCode() {//用set的时候改写一下hashcode和equals
            return 1331 * bitMask + 31 * x + 101 * y;
        }
    }

    private static final int[][] directions = new int[][]{{0, 1}, {0, -1}, {1, 0}, {-1, 0}};

    public int shortestPathAllKeys(String[] grid) {
        char[][] board = new char[grid.length][grid[0].length()];
        int[] num = new int[1];
        Path start = new Path(0, 0, 0);
        initialize(grid, start, num, board);

        Queue<Path> queue = new LinkedList<>();
        Set<Path> visited = new HashSet<>();

        queue.offer(start);
        visited.add(start);
        int step = 0;

        while(!queue.isEmpty()) {
            int size = queue.size();

            for(int i = 0; i < size; i++) {
                Path current = queue.poll();

                if(current.bitMask == (1 << num[0]) - 1) {
                    return step;
                }

                for(int[] direction : directions) {
                    int x = direction[0] + current.x;
                    int y = direction[1] + current.y;
                    int bitMask = current.bitMask;

                    if(x >= 0 && x < grid.length && y >= 0 && y < grid[0].length()) {
                        char ch = board[x][y];

                        if(ch == '#') {
                            continue ;
                        }
                        else if(ch >= 'a' && ch <= 'f') {
                            bitMask |= 1 << (ch - 'a');
                        }
                        else if(ch >= 'A' && ch <= 'F' && ((bitMask >> (ch - 'A')) & 1) == 0) {
                            continue ;
                        }

                        if(visited.add(new Path(x, y, bitMask))) {
                            queue.offer(new Path(x, y, bitMask));
                        }
                    }
                }
            }
            step++;
        }
        return -1;

    }

    private void initialize(String[] grid, Path start, int[] num, char[][] board) {//找到起点和key有多少个
        for(int i = 0; i < grid.length; i++) {
            for(int j = 0; j < grid[0].length(); j++) {
                char ch = grid[i].charAt(j);
                board[i][j] = ch;

                if(ch == '@') {
                    start.x = i;
                    start.y = j;
                }

                if(ch >= 'a' && ch <= 'f') {
                    num[0]++;
                }
            }
        }
    }

　　代码很长，主要就是bfs以及用一个int记录key是否已经拿到了，注释也写啦，题目也说了key一定是前k个小写字母。