leetcode 随笔16

突然发现原来我已经那么久没有更新leeetcode了。
确实有段时间没有好好的刷leetcode了。先更一下前段时间做的题目吧。

7.18

牛客上的面试高频题

最大数

难度入门

题目描述

给定一个包含大写英文字母和数字的句子，找出这个句子所包含的最大的十六进制整数，返回这个整数的值。数据保证该整数在int表示范围内。

连续字符串的最大值。

import java.util.*;


public class Solution {
    /**
     * 
     * @param s string字符串 
     * @return int整型
     */
    public int solve (String s) {
        // write code here
        int ans = 0;
        char[] arr = s.toCharArray();
        int temp = 0;
        for(int i = 0;i < arr.length;i++){
            if(arr[i] >= '0' && arr[i] <= '9'){
                temp *= 16;
                temp += (arr[i] - '0');
            }else if(arr[i] >= 'A' && arr[i] <= 'F'){
                temp *= 16;
                temp += (arr[i] - 'A' + 10);
            }else{
                ans = Math.max(ans, temp);
                temp = 0;
            }
        }
        return ans;
    }
}

牛牛的和平年代

题目描述

题目背景：

数轴世界建立之初，还没有任何的生机。直到有一天，在数轴的整点上，慢慢诞生了一个一个新兴的文明。如果两个文明相邻，也就是在他们之间不存在其他的整点，他们就会慢慢受到彼此的影响，逐渐融为一个整体。而当所有的文明大一统，全部融为一个整体的时候，这个数轴世界才会重归和平。为了能够让自己的文明发展壮大，牛牛决定根据每个文明诞生的年代表，计算出什么时候才是和平的黄金时代。

简明题意：

我们定义一个整数可重集合是好的，当且仅当对于集合中任意两个元素 a, b (a \leq ba≤b) ，所有满足 a\leq c\leq ba≤c≤b 的元素 c 都在集合中出现过。

现在，给你一个数组 mSet，你需要做的是，对于这个数组的每一个前缀，判断这个前缀是不是一个好的集合。所以，你将计算出的是一个数组，为布尔类型。

用一个TreeSet来帮助排序，之后去遍历其中的是否满足要求即可。

import java.util.*;


public class Solution {
    /**
     * 检查数组的每个前缀是不是一个好的集合
     * @param mSet int整型一维数组 
     * @return bool布尔型一维数组
     */
    public boolean[] continuousSet (int[] mSet) {
        // write code here
        boolean[] ans = new boolean[mSet.length];
        if(mSet.length == 0){
            return ans;
        }
        
        TreeSet<Integer> set = new TreeSet<>();
        for(int i = 0;i < mSet.length;i++){
            set.add(mSet[i]);
            if(core(set)){
                ans[i] = true;
            }
        }
        return ans;
    }
    
    public boolean core(TreeSet<Integer> set){
        List<Integer> list = new ArrayList<>(set);
        for(int m = 1;m < list.size();m++){
            if(list.get(m) - list.get(m - 1) != 1){
                return false;
            }
        }
        return true;
    }
}

204. 计数质数

难度简单

暴力解法，效率很低。

class Solution {
    public int countPrimes(int n) {
        if(n <= 1){
            return 0;
        }
        int ans = 0;
        for(int i = 2;i < n;i++){
            if(i % 2 == 0 && i != 2){
                continue;
            }
            if(judge(i)){
                set.add(i);
                ans++;
            }
        }
        return ans;
    }

    public boolean judge(int num){
        for(int i = 2;i * i <= num;i++){
            if(num % i == 0){
                return false;
            }
        }
        return true;
    }
}

看了题解发现有其它更快速的方法。

class Solution {
    public int countPrimes(int n) {
        int result = 0;
        boolean[] b = new boolean[n];   // 初始化默认值都为 false，为质数标记
        if(2 < n) result++; // 如果大于 2 则一定拥有 2 这个质数
        
        for(int i = 3; i < n; i += 2){  // 从 3 开始遍历，且只遍历奇数
            if(!b[i]){  // 是质数
                for(int j = 3; i * j < n; j += 2){
                    b[i * j] = true;    // 将当前质数的奇数倍都设置成非质数标记 true
                }
                result++;   // 质数个数 +1
            }
        }
        return result;
    }
}

97. 交错字符串

难度困难

自己尝试写了动态规划，但是里面的状态转移总是写不对。参照了题解才想通。

s1的每个字符都尝试与s2的字符串组合在一起，再配合上辅助数组来帮助确定这个组合是否有效。

class Solution {
    public boolean isInterleave(String s1, String s2, String s3) {
        int len1 = s1.length();
        int len2 = s2.length();
        int len3 = s3.length();
        if(len1 + len2 != len3){
            return false;
        }
        
        boolean[][] f = new boolean[len1 + 1][len2 + 1];

        f[0][0] = true;
        for(int i = 0;i <= len1;i++){
            for(int j = 0;j <= len2;j++){
                int p = i + j - 1;
                 if (i > 0) {
                    f[i][j] = f[i][j] || (f[i - 1][j] && s1.charAt(i - 1) == s3.charAt(p));
                }
                if (j > 0) {
                    f[i][j] = f[i][j] || (f[i][j - 1] && s2.charAt(j - 1) == s3.charAt(p));
                }
            }
        }
        return f[len1][len2];
    }
}

7.21

95. 不同的二叉搜索树 II

难度中等

之前做过1，用动态规划的方式来做。但是如果要把所有结果都展示出来却不知道要怎么下手。看了题解才会做的。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<TreeNode> generateTrees(int n) {
        if(n == 0){
            return new LinkedList<TreeNode>();
        }
        return generateTrees(1,n);
    }

    public List<TreeNode> generateTrees(int begin, int end){
        List<TreeNode> ans = new LinkedList<>();
        if(begin > end){
            ans.add(null);
            return ans;
        }

        for(int i = begin;i <= end;i++){
            List<TreeNode> leftList = generateTrees(begin, i - 1);
            List<TreeNode> rightList = generateTrees(i + 1, end);

            for(TreeNode left : leftList){
                for(TreeNode right : rightList){
                    TreeNode node = new TreeNode(i);
                    node.left = left;
                    node.right = right;
                    ans.add(node);
                }
            }
        }

        return ans;
    }
}

7.22

剑指 Offer 11. 旋转数组的最小数字

难度简单

二分查找

class Solution {
    public int minArray(int[] numbers) {
        int low = 0;
        int high = numbers.length - 1;
        while (low < high) {
            int pivot = low + (high - low) / 2;
            if (numbers[pivot] < numbers[high]) {//后面的序列有序
                high = pivot;
            } else if (numbers[pivot] > numbers[high]) {
                low = pivot + 1;
            } else {
                high -= 1;
            }
        }
        return numbers[low];
    }
}

7.23

239. 滑动窗口最大值

难度困难

利用LinkedList双向链表的性质可以做窗口的问题。自己写了一个方法，不过超时了。

emmm，可能是维护从大到小的链表时花费了太多时间。

class Solution {
    public void updateList(LinkedList<Integer> list, int num){
        while(!list.isEmpty() && num > list.getLast()){
            list.removeLast();
        }
        list.add(num);
    }


    public int[] maxSlidingWindow(int[] nums, int k) {
        LinkedList<Integer> list = new LinkedList<>();//list从左到右，从大到小
        LinkedList<Integer> window = new LinkedList<>();
        LinkedList<Integer> ans = new LinkedList<>();

        for(int i = 0;i < nums.length;i++){
            //首先填充窗口
            if(i < k){
                updateList(list, nums[i]);
                window.add(nums[i]);
                if(i == k - 1){
                    ans.add(list.getFirst());
                }
                continue;
            }
            int temp = window.removeFirst();
            window.add(nums[i]);
            updateList(list, nums[i]);
            if(temp == list.getFirst()){
                list.removeFirst();
            }
            ans.add(list.getFirst());
        }

        int[] res = new int[ans.size()];
        for(int i = 0;i < res.length;i++){
            res[i] = ans.get(i);
        }
        return res;
    }
}

根据题解更改了之前的做法。窗口队列里面放的不是元素，而是索引。利用索引我们可以知道窗口的开始是否已经过时，以及能够知道窗口是否已经填充完成。

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        LinkedList<Integer> list = new LinkedList<>();//list从左到右，从大到小，窗口队列
        int[] result = new int[nums.length - k + 1];
        for(int i = 0;i < nums.length;i++){
            while(!list.isEmpty() && nums[i] >= nums[list.peekLast()]){
                list.pollLast();
            }
            list.addLast(i);
            if(list.peek() <= i - k){
                list.poll();
            }
            if(i + 1 >= k){
                result[i + 1 - k] = nums[list.peek()];
            }
        }
        return result;
    }
}