LeetCode 剑指 Offer 刷题代码 （1）

面试题13. 机器人的运动范围

地上有一个m行n列的方格，从坐标 [0,0] 到坐标 [m-1,n-1] 。一个机器人从坐标 [0, 0] 的格子开始移动，它每次可以向左、右、上、下移动一格（不能移动到方格外），也不能进入行坐标和列坐标的数位之和大于k的格子。例如，当k为18时，机器人能够进入方格 [35, 37] ，因为3+5+3+7=18。但它不能进入方格 [35, 38]，因为3+5+3+8=19。请问该机器人能够到达多少个格子？

class Element{
        public int x;
        public int y;

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

    public int movingCount(int m, int n, int k) {
        int count = 0;
        Boolean tag[][] = new Boolean[101][101];

        for(Boolean []arr : tag)
            Arrays.fill(arr,false);

        ArrayDeque<Element> deque = new ArrayDeque<>();
        deque.add(new Element(0,0));
        tag[0][0] = true;

        while (!deque.isEmpty()){
            Element tmp = deque.poll();
            count++;
            if( tmp.x+1 <m && caculator(tmp.x+1,tmp.y,k) && !tag[tmp.x+1][tmp.y]) {
                tag[tmp.x+1][tmp.y] = true;
                deque.add(new Element(tmp.x+1,tmp.y));
            }
            if( tmp.x-1 >=0 && caculator(tmp.x-1,tmp.y,k) && !tag[tmp.x-1][tmp.y]) {
                tag[tmp.x-1][tmp.y] = true;
                deque.add(new Element(tmp.x-1,tmp.y));
            }
            if( tmp.y+1 <n && caculator(tmp.x,tmp.y+1,k) && !tag[tmp.x][tmp.y+1]) {
                tag[tmp.x][tmp.y+1] = true;
                deque.add(new Element(tmp.x,tmp.y+1));
            }
            if( tmp.y-1 >=0 && caculator(tmp.x,tmp.y-1,k) && !tag[tmp.x][tmp.y-1]) {
                tag[tmp.x][tmp.y-1] = true;
                deque.add(new Element(tmp.x,tmp.y-1));
            }
        }
        return count;
    }

    boolean caculator(int x, int y,int k) {
        int sum=0;
        while(x!=0){
            sum += x%10;
            x=x/10;
        }
        while(y!=0){
            sum += y%10;
            y=y/10;
        }
        return sum<=k;
    }

面试题12. 矩阵中的路径

请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一格开始，每一步可以在矩阵中向左、右、上、下移动一格。如果一条路径经过了矩阵的某一格，那么该路径不能再次进入该格子。例如，在下面的3×4的矩阵中包含一条字符串“bfce”的路径（路径中的字母用加粗标出）。

[[“a”,“b”,“c”,“e”],
[“s”,“f”,“c”,“s”],
[“a”,“d”,“e”,“e”]]

但矩阵中不包含字符串“abfb”的路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入这个格子。

public boolean exist(char[][] board, String word) {
        char[] words = word.toCharArray();

        for(int i=0; i<board.length; i++)
            for(int j=0; j<board[i].length; j++)
                if(board[i][j] == words[0]){
                    boolean ans = dfs(board, i, j, 0, words);
                    if(ans)
                        return true;
                }
        return false;
    }
    private boolean dfs(char [][] board, int x, int y, int index, char []words){
        if(x<0 || x>=board.length || y<0 || y>=board[x].length || board[x][y]!=words[index])
            return false;
        if(index == words.length-1)
            return true;

        char tmp = board[x][y];
        board[x][y] = '|';
        boolean ans = dfs(board, x+1, y, index+1, words) || dfs(board, x-1, y, index+1, words)
                || dfs(board, x, y+1, index+1, words) || dfs(board, x, y-1, index+1, words);
        board[x][y] = tmp;
        return ans;
    }

面试题11. 旋转数组的最小数字

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如，数组 [3,4,5,1,2] 为 [1,2,3,4,5] 的一个旋转，该数组的最小值为1。

public int minArray(int[] numbers) {
        int left = 0, right = numbers.length-1, mid;
        while(left!=right){
            mid = (left+right)/2;
            if(numbers[mid] > numbers[right])
                left = mid+1;
            else if (numbers[mid] < numbers[right])
                right = mid;
            else
                right--;
        }
        return numbers[left];
    }

面试题10- II. 青蛙跳台阶问题

一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。

答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。

private static int []arr = new int [101];
    static {
        Arrays.fill(arr,-1);
    }
    public int numWays(int n) {
        if(n==0 || n==1 )
            return arr[n]=1;
        if(arr[n]!=-1)
            return arr[n];
        arr[n] = (numWays(n-1)+numWays(n-2)) % 1000000007;
        return arr[n];
    }

面试题10- I. 斐波那契数列

写一个函数，输入 n ，求斐波那契（Fibonacci）数列的第 n 项

public int fib(int n) {
        if(n==0)
            return 0;
        if(n==1)
            return 1;

        int a=0,b=1,c=0;
        for(int i=2; i<=n; i++){
            c = (a+b) % 1000000007;
            a = b;
            b = c;
        }
        return c;
    }

面试题09. 用两个栈实现队列

用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 )

class CQueue {
        private Stack<Integer> stackIn = new Stack<Integer>();
        private Stack<Integer> stackOut = new Stack<Integer>();

        public CQueue() {

        }

        public void appendTail(int value) {
            stackIn.add(value);
        }

        public int deleteHead() {
            if(stackOut.isEmpty()){
                while(!stackIn.isEmpty())
                    stackOut.add(stackIn.pop());
            }
            if(stackOut.isEmpty())
                return -1;
            else
                return stackOut.pop();
        }
    }

面试题07. 重建二叉树

输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。

public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        TreeNode(int x) {
            val = x;
        }
    }

    public TreeNode buildTree(int[] preorder, int[] inorder) {

        if(preorder.length==0 || preorder==null)
            return null;

        TreeNode node = new TreeNode(preorder[0]);

        int index = 0;
        for( ; inorder[index]!=preorder[0]; index++);


        node.left = buildTree(Arrays.copyOfRange(preorder,1,index+1),Arrays.copyOfRange(inorder,0,index));
        node.right = buildTree(Arrays.copyOfRange(preorder,index+1,preorder.length),Arrays.copyOfRange(inorder,index+1,inorder.length));

        return node;
    }

public class ListNode {
        int val;
        ListNode next;

        ListNode(int x) {
            val = x;
        }
    }
//006
    public int[] reversePrint(ListNode head) {

        Stack<Integer> stack = new Stack<>();
        while (head != null) {
            stack.add(head.val);
            head = head.next;
        }
        int[] arr = new int[stack.size()];
        int i = 0;
        while (!stack.empty()) {
            arr[i++] = stack.pop();
        }
        return arr;
    }

    public String replaceSpace(String s) {
        return s.replace(" ", "%20");
    }

//005
    public boolean findNumberIn2DArray(int[][] matrix, int target) {
        if (matrix.length == 0)
            return false;
        for (int i = 0; i < matrix.length && target >= matrix[i][0]; i++) {
            int l = 0, r = matrix[i].length - 1;
            while (l <= r) {
                int mid = (l + r) / 2;
                if (matrix[i][mid] == target)
                    return true;
                else if (target < matrix[i][mid])
                    r = mid - 1;
                else
                    l = mid + 1;
            }
        }
        return false;
    }

//004
    public int findRepeatNumber(int[] nums) {
        HashMap<Integer, Integer> hashMap = new HashMap<>();

        for (int i = 0; i < nums.length; i++) {
            if (hashMap.containsKey(nums[i]))
                return nums[i];
            else
                hashMap.put(nums[i], null);
        }
        return -1;
    }