LeetCode2

栈/链表/矩阵 ... 动态规划/(分治法)

20. 有效的括号

输入：s = "()"
输出：true

输入：s = "(]"
输出：false

输入：s = "([)]"
输出：false

输入：s = "{[]}"
输出：true

栈

21. 合并两个有序链表

输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {

    }
}

链表

240. 搜索二维矩阵 II

矩阵的左到右为升序，上到下也是升序
输入：matrix = [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]], target = 5
输出：true

矩阵

125. 验证回文串

只考虑字母与数字，忽略大小写
输入: "A man, a plan, a canal: Panama"
输出: true

输入: "race a car"
输出: false

class Solution {
    public boolean isPalindrome(String s) {
        int left = 0;
        int right = s.length() - 1;

        while(left < right){
            while(!Character.isLetterOrDigit(s.charAt(left)) && left<right){
                left++;
            }
            while(!Character.isLetterOrDigit(s.charAt(right)) && left<right){
                right--;
            }
            if(Character.toLowerCase(s.charAt(left))!=Character.toLowerCase(s.charAt(right))){
                return false;
            }else{
                left++;
                right--;
            }
        }
        return true;
    }
}

醉了, 自己写了两种正则表达式的方法, 结果耗时是上述方法的几十倍...
算了, 还是Character方法好用

860. 柠檬水找零

柠檬水5元，只有面值为5 10 20的钞票，全能找零则为true

输入：[5,5,5,10,20]
输出：true
解释：
前 3 位顾客那里，我们按顺序收取 3 张 5 美元的钞票。
第 4 位顾客那里，我们收取一张 10 美元的钞票，并返还 5 美元。
第 5 位顾客那里，我们找还一张 10 美元的钞票和一张 5 美元的钞票。
由于所有客户都得到了正确的找零，所以我们输出 true。

class Solution {
    public boolean lemonadeChange(int[] bills) {
        int five = 0;
        int ten = 0;
        for(int i: bills){
            if(i == 5) five++;
            else if(i == 10) {five--; ten++;}
            else if(ten > 0) {ten--; five--;}
            else five -= 3;
            if(five < 0) return false;
        }
        return true;
    }
}

70. 爬楼梯

每次走1步或者2步，有几种走法

输入： 3
输出： 3
解释： 有三种方法可以爬到楼顶。
1.  1 阶 + 1 阶 + 1 阶
2.  1 阶 + 2 阶
3.  2 阶 + 1 阶

class Solution {
    public int climbStairs(int n) {
        if(n == 1)
            return 1;
        if(n == 2)
            return 2;

        int a = 1;
        int b = 2;
        int temp = 3;
        for(int i=3; i<=n; i++){
            temp = a + b;
            a = b;
            b = temp;
        }

        return temp;
    }
}

动态规划

53. 最大子序和

输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

public int maxSubArray(int[] nums) {
    int pre = 0, max = nums[0];
    for (int x : nums) {
        // 先比较出pre+x 和 x,
        pre = Math.max(pre + x, x);// 不应该也比较一下pre吗? 明白了,如果比较pre的话,就不是连续的了
        // 再拿最大的与历代的max比较
        max = Math.max(max, pre);
    }
    return max;
}

动态规划