Leetcode刷题 2021.03.10

Leetcode227 基本计算器 II

给你一个字符串表达式 s ，请你实现一个基本计算器来计算并返回它的值。

整数除法仅保留整数部分。

没有括号的限制，难度系数就直接下降一个档次。看了下题解和自己的思路差不多，由于乘除法的优先级是要高于加减法的。因此可以考虑使用栈优先对乘除法进行运算，最后在把栈里的元素按顺序做加减法就行了。

class Solution {
    public int calculate(String s) {
    	//用两个栈分别存放数据和操作符
        Deque<Long> num = new ArrayDeque<>();
        Deque<Character> opr = new ArrayDeque<>();
        char[] arr = s.toCharArray();
        int i = 0, n = arr.length;
        //首先处理乘除法
        while (i < n){
        	//遇到空字符直接跳过
            if (arr[i] == ' '){
                i++;
                continue;
            }
            //遇到数字，获取数字的数值
            if (Character.isDigit(arr[i])){
                long temp = 0;
                while (i < n && Character.isDigit(arr[i])){
                    temp = temp * 10 + arr[i] - '0';
                    i++;
                }
                num.push(temp);
                //看看操作符栈，如果是乘除法的话就做运算
                if (!opr.isEmpty() && (opr.peek() == '*' || opr.peek() == '/')){
                    long num1 = num.pop();
                    long num2 = num.pop();
                    // System.out.println(num1);
                    // System.out.println(num2);
                    long res = 0;
                    if (opr.peek() == '*'){
                        res = num2 * num1;
                    }else{
                        res = num2 / num1;
                    }
                    num.push(res);
                    opr.pop();
                }
            }else{
            	//如果是运算符的话，就直接入操作符栈
                opr.push(arr[i]);
                i++;
            }
        }
        while (!opr.isEmpty()){
        	//最后按照从左到右的顺序做加减法就行了
        	//注意deque的顺序是不一样的
            char operation = opr.removeLast();
            long num1 = num.removeLast();
            long num2 = num.removeLast();
            if (operation == '+'){
                num.addLast(num1 + num2);
            }else{
                num.addLast(num1 - num2);
            }
        }
        long ans = num.peek();;
        return (int) ans;
    }
}

Leetcode526 优美的排列

假设有从 1 到 N 的 N 个整数，如果从这 N 个数字中成功构造出一个数组，使得数组的第 i 位 (1 <= i <= N) 满足如下两个条件中的一个，我们就称这个数组为一个优美的排列。条件：

第 i 位的数字能被 i 整除
i 能被第 i 位上的数字整除
现在给定一个整数 N，请问可以构造多少个优美的排列？

看到n不会超过十五，那就不用想了，肯定就是回溯了。也比较简单，按照题意来尝试就行了。
有时候在想力扣这样给出的数字范围有点提示的感觉了，如果没有n不大于15的提示，可能会先取想其他的方法在想回溯。

class Solution {
    int[] arr;
    int res = 0;
    boolean[] isUsed;
    public int countArrangement(int n) {
        arr = new int[n];
        isUsed = new boolean[n + 1];
        helper(n, 1);
        return res;
    }

    private void helper(int n, int index){
        if (index > n){
            res++;
            return;
        }
        for(int i = 1; i <= n; i++){
        	//数字只能用一次，并且要满足给定的两个条件中的一个
            if (!isUsed[i] && ( i % index == 0 || index % i == 0)){
                isUsed[i] = true;
                helper(n, index + 1);
                isUsed[i] = false;
            }
        }
    }
}

Leetcode369 给单链表加一

用一个 非空 单链表来表示一个非负整数，然后将这个整数加一。

你可以假设这个整数除了 0 本身，没有任何前导的 0。

这个整数的各个数位按照 高位在链表头部、低位在链表尾部 的顺序排列。

链表题都不太难，看了题解是用。这道题和链表加法差不多，但是因为要从最后一位开始加起。所以考虑使用递归，从后向前加1。最后在头结点的时候判断一下，如果有余数，要在加一个节点。

class Solution {
    public ListNode plusOne(ListNode head) {
        if (head == null) return head;
        int append = helper(head);
        if (append == 0) return head;
        //最后头结点判断一下，是否还有余数
        ListNode dummyHead = new ListNode(1);
        dummyHead.next = head;
        return dummyHead;
    }

    private int helper(ListNode head){
    	//从后向前递归，最后返回1，否则就返回append和head的和域10的商
        if (head == null) return 1;
        int append = helper(head.next);
        int temp = head.val + append;
        head.val = temp % 10;
        return temp / 10;
    }
}