月度归档: 2021年9月

LeetCode刷题【1221】分割平衡字符串

今天每日一题。最近题目感觉都有点水啊

在一个 平衡字符串 中,'L''R' 字符的数量是相同的。

给你一个平衡字符串 s,请你将它分割成尽可能多的平衡字符串。

注意:分割得到的每个字符串都必须是平衡字符串。

返回可以通过分割得到的平衡字符串的 最大数量

 

示例 1:

输入:s = "RLRRLLRLRL"
输出:4
解释:s 可以分割为 "RL"、"RRLL"、"RL"、"RL" ,每个子字符串中都包含相同数量的 'L' 和 'R' 。

示例 2:

输入:s = "RLLLLRRRLR"
输出:3
解释:s 可以分割为 "RL"、"LLLRRR"、"LR" ,每个子字符串中都包含相同数量的 'L' 和 'R' 。

示例 3:

输入:s = "LLLLRRRR"
输出:1
解释:s 只能保持原样 "LLLLRRRR".

示例 4:

输入:s = "RLRRRLLRLL"
输出:2
解释:s 可以分割为 "RL"、"RRRLLRLL" ,每个子字符串中都包含相同数量的 'L' 和 'R' 。

 

提示:

  • 1 <= s.length <= 1000
  • s[i] = 'L' 或 'R'
  • s 是一个 平衡 字符串
Related Topics
  • 贪心
  • 字符串
  • 计数

  • 👍 123
  • 👎 0
  • 题解

    题目中已经说明了“给你一个平衡字符串”,说明给出的一定是平衡字符串,那么很容易的有人最容易有疑问的,比如“RRLLLRLR”为啥不能是“RRLLLR”+“LR”,很明显题目要求“分割成尽可能多的平衡字符串”,简单点直接上代码

    class Solution {
        public int balancedStringSplit(String s) {
            int count = 0;
            int num = 0;
            for (int i = 0; i < s.length(); i++) {
                if (s.charAt(i) == 'L'){
                    num++;
                }else{
                    num--;
                }
                if (num == 0){
                    count++;
                }
            }
            return count;
        }
    }

    LeetCode刷题【470】用 Rand7() 实现 Rand10()

    昨天的每日一题

    已有方法 rand7 可生成 1 到 7 范围内的均匀随机整数,试写一个方法 rand10 生成 1 到 10 范围内的均匀随机整数。

    不要使用系统的 Math.random() 方法。

     

    示例 1:

    输入: 1
    输出: [7]
    

    示例 2:

    输入: 2
    输出: [8,4]
    

    示例 3:

    输入: 3
    输出: [8,1,10]
    

     

    提示:

    1. rand7 已定义。
    2. 传入参数: n 表示 rand10 的调用次数。

     

    进阶:

    1. rand7()调用次数的 期望值 是多少 ?
    2. 你能否尽量少调用 rand7() ?
    Related Topics
  • 数学
  • 拒绝采样
  • 概率与统计
  • 随机化

  • 👍 317
  • 👎 0
  • 简单版

    public int rand10() {
            int randA = rand7();
            int randB = rand7();
            if (randA >= 5 && randB <=3){
                return rand10();
            }
            return (randA+randB)%10 + 1;
        }

    分析过程如下,和上次求质数LeetCode刷题【204】计数质数分析过程类似,先把结果都求出来,然后像是敲冰块游戏一样敲掉不需要的结果,剩下的就是我们需要的结果了。

    第一步,rand7只能取到1-7的值,要求到1-10的话,那么至少也要两个rand7来相加的情况处理,那么对求和情况分析

    图中数值为求和的结果

    那么可以看到,结果为8的概率最大,有7种可能,即7/49的概率。对图中结果再用10取余可以得到如下

    如图中锁标示出来的那样,如果把右上角,或者右下角的情况扣掉的话,那么结果所有数值的概率都是4/40的概率。所以显而易见的代码就如上那样出来了。

    另一个解法

    class Solution extends SolBase {
    
        public int rand10() {
            int num = rand7();
            while (true) {
                num = (num-1) * 7 + rand7();
                if(num <= 40){
                    return num % 10 +1;
                }
                return rand10();
            }
        }
    }

    LeetCode刷题【剑指 Offer 10- I】斐波那契数列

    写一个函数,输入 n ,求斐波那契(Fibonacci)数列的第 n 项(即 F(N))。斐波那契数列的定义如下:

    F(0) = 0,   F(1) = 1
    F(N) = F(N - 1) + F(N - 2), 其中 N > 1.

    斐波那契数列由 0 和 1 开始,之后的斐波那契数就是由之前的两数相加而得出。

    答案需要取模 1e9+7(1000000007),如计算初始结果为:1000000008,请返回 1。

     

    示例 1:

    输入:n = 2
    输出:1
    

    示例 2:

    输入:n = 5
    输出:5
    

     

    提示:

    • 0 <= n <= 100
    Related Topics
  • 记忆化搜索
  • 数学
  • 动态规划

  • 👍 230
  • 👎 0
  • 题解

    9月4日的每日一题,周末没写,

    接单题目,但是不简单其实

    根据题意可以直接知道,用下面这个递归就可以实现。但是实际按照这个直接递归了来写的话会直接超时。

    F(N) = F(N - 1) + F(N - 2)

    那么就有了以下这段代码

    class Solution {
        public int fib(int n) {
            if (n==0){
                return 0;
            }
            if (n==1){
                return 1;
            }
            int[] res = new int[n+1];
            res[0] = 0;
            res[1] = 1;
            int i = 2;
            while ( i <= n ){
                res[i] = (res[i-1] + res[i-2]) % 1000000007;
                i++;
            }
            return res[n];
        }
    }

    emmm、直观来说就是改递归为while遍历,但是这个res数组已经有一点滚动数组的味道了。但是这边我们其实可以看到,当到达i的时候 i-2之前的所有值都已经没有存在的意义了,所以还可以再优化下内存使用率的情况。如下:

    class Solution {
        public int fib(int n) {
            if (n==0){
                return 0;
            }
            if (n==1){
                return 1;
            }
            int a = 0;
            int b = 1;
            int i = 2;
            while ( i <= n ){
                if (i%2==0){
                    a = (a+b) % 1000000007;
                }else{
                    b = (a+b) % 1000000007;
                }
                i++;
            }
            return n%2==0?a:b;
        }
    }

    LeetCode刷题【704】二分查找

    今天每日一题,简单,最近几天每日一题题目好像都挺水的…….

    给定一个 n 个元素有序的(升序)整型数组 nums 和一个目标值 target  ,写一个函数搜索 nums 中的 target,如果目标值存在返回下标,否则返回 -1


    示例 1:

    输入: nums = [-1,0,3,5,9,12], target = 9
    输出: 4
    解释: 9 出现在 nums 中并且下标为 4
    

    示例 2:

    输入: nums = [-1,0,3,5,9,12], target = 2
    输出: -1
    解释: 2 不存在 nums 中因此返回 -1
    

     

    提示:

    1. 你可以假设 nums 中的所有元素是不重复的。
    2. n 将在 [1, 10000]之间。
    3. nums 的每个元素都将在 [-9999, 9999]之间。
    Related Topics
  • 数组
  • 二分查找

  • 👍 360
  • 👎 0
  • 没啥太多解释的,就:二分

    class Solution {
        public int search(int[] nums, int target) {
            int left = 0;
            int right = nums.length-1;
            while (left <= right){
                int mid = left + ((right-left) >> 1);
                if (nums[mid] == target){
                    return mid;
                }
                if (nums[mid] < target){
                    left = mid+1;
                }else{
                    right = mid-1;
                }
            }
            return -1;
        }
    }

    二分的时候取中间值有个小技巧

    int mid = left + ((right-left) >> 1);

    这个应该成为所有类型解题过程中常规需要考虑到的问题,而不是直接的加起来除以2。

    LeetCode刷题【204】计数质数

    统计所有小于非负整数 n 的质数的数量。

     

    示例 1:

    输入:n = 10
    输出:4
    解释:小于 10 的质数一共有 4 个, 它们是 2, 3, 5, 7 。
    

    示例 2:

    输入:n = 0
    输出:0
    

    示例 3:

    输入:n = 1
    输出:0
    

     

    提示:

    • 0 <= n <= 5 * 106
    Related Topics
  • 数组
  • 数学
  • 枚举
  • 数论

  • 👍 738
  • 👎 0
  • 题解,求小于n的质数,一上来一看好像挺简单,还简单题。

    挨个算嘛,暴力求解

    class Solution {
        public int countPrimes(int n) {
            if (n<2){
                return 0;
            }
            if (n==2){
                return 0;
            }
            List<Integer> list = new ArrayList<>();
            list.add(2);
            boolean isPrimes = true;
            for (int i = 3; i < n ; i++) {
                isPrimes = true;
                for(int num : list){
                    if (i % num == 0){
                        isPrimes = false;
                        break;
                    }
                }
                if (isPrimes){
                    list.add(i);
                }
            }
            return list.size();
        }
    }

    结果直接超时,心想不至于吧。。还能超时。然后找了张纸画了个矩阵图看了看。

    如下

    图中是乘积关系

    于是萌生了一个想法,我只要把小于n的数去掉了这些能用乘积法求出来的数,剩下的数字不就是质数了么。这过程中还有一个细节点,比如2×6=12,3×4=12,这俩是重复的,需要判断处理下。于是得到了代码如下:

    class Solution {
        public int countPrimes(int n) {
            if (n<=2){
                return 0;
            }
            int count = 0;
            int tmp = 0;
            int[] res = new int[n];
            for (int i = 2; i*i < n; i++) {
                for (int j = i; j*i < n; j++) {
                    tmp = i*j;
                    if (res[tmp] == 0){
                        res[tmp] = 1;
                        count++;
                    }
                }
            }
    
            return n - count - 2;
        }
    }

    最终结果需要额外减去2是因为前面1、2的结果都为0,需要额外减去。

    解答成功:
    执行耗时:139 ms,击败了8.31% 的Java用户
    内存消耗:56.4 MB,击败了17.00% 的Java用户

    结果好像不太理想,还能再优化?

    class Solution {
        public int countPrimes(int n) {
            if (n == 0 || n == 1) return 0;
            int[] arr = new int[n];
            arr[0] = 1;
            arr[1] = 1;
            int count = 0;
            for (int i = 2; i * i < n; i++) {
                if (arr[i] == 1) continue;
                for (int j = 2 * i; j < n; j += i) {
                    if (arr[j] == 0){
                        arr[j] = 1;
                        count++;
                    }
                }
            }
            return n - count - 2;
        }
    }

    LeetCode刷题【面试题 17.14】最小K个数

    设计一个算法,找出数组中最小的k个数。以任意顺序返回这k个数均可。

    示例:

    输入: arr = [1,3,5,7,2,4,6,8], k = 4
    输出: [1,2,3,4]
    

    提示:

    • 0 <= len(arr) <= 100000
    • 0 <= k <= min(100000, len(arr))
    Related Topics
  • 数组
  • 分治
  • 快速选择
  • 排序
  • 堆(优先队列)

  • 👍 96
  • 👎 0
  • 题解,9月3日的每日一题

    看到题目第一反应,找一组无序数字中的最小,或者最大的几个,典型的用堆来解决的问题,不过在写堆之前,可以尝试自己写一个类似的逻辑的代码。

    维护一个长度为k的有序数组,遍历原数组,挨个将数组中的值加入到维护的k长度数组中,在加入的时候,判断这个值和数组中已有值的大小关系,将这个值插入到k的对应位置,保持数组k的单调性。如果长度k的数组加入值的时候长度将会超过k,则移除掉末尾的最大值。

    class Solution {
        int[] list;
        int listCount = 0;
        public int[] smallestK(int[] arr, int k) {
            if (k == 0){
                return new int[0];
            }
            list = new int[k];
            Arrays.fill(list,Integer.MIN_VALUE);
    
            for (int i = 0; i < arr.length; i++) {
                if (listCount < list.length){
                    //此时list还没满
                    listAdd(arr[i]);
                }else{
                    listInsert(arr[i]);
                }
            }
    
            return list;
    
        }
    
        public void listAdd( int num ){
            if (listCount == 0){
                list[0] = num;
                listCount++;
                return;
            }
            //比如
            //[1,2,4,5,6]找到4比3大
            //[1,2,3,4,5,6]把4、5、6往后挪移一位在4的位置插入
            for (int i = 0; i < list.length; i++) {
                if (list[i] > num){
                    System.arraycopy(list,i,list,i+1,listCount-i);
                    list[i] = num;
                    listCount++;
                    return;
                }
            }
            list[listCount] = num;
            listCount++;
        }
    
        public void listInsert( int num ){
            for (int i = 0; i < list.length; i++) {
                if (list[i] > num){
                    System.arraycopy(list,i,list,i+1,list.length-i-1);
                    list[i] = num;
                    break;
                }
            }
        }
    }

    在这个代码中,比如原数组[1,2,4,5,6],想把[4,5,6]往后移动一位,需要从末位开始往前遍历移动,例如,把6先移动到索引5的位置,再移动5到索引4的位置,再移动3。如果是从前面开始,先移动4,则会覆盖到5的位置,导致后面想移动5的时候,5已经不存在了被4覆盖掉了。这边我原本一开始是这么写的逻辑,不过提交的时候,emmm,超时了…….,这样的有序排列的结果移动复制的方法,可以保证在多出k个的时候能自动将最大值移出数组。

    所以大概回顾了下整个的代码逻辑,最耗时的部分好像在这个复制的地方,那么修改一下,使用System.arraycopy这个native方法来代替原来自己写的for循环。确实可以过了。结果如下,在超时的边缘不断疯狂尝试。

    解答成功:
    执行耗时:1821 ms,击败了5.37% 的Java用户
    内存消耗:47.9 MB,击败了55.67% 的Java用户

    嗯,想一下哪边能有优化的呢,原来的复制部分的问题用System.arraycopy处理了,接下来看起来应该是在数组内查找的地方可以优化。这里可以改成二分,找到第一个比当前值大的值的索引。

    堆实现

    这里我们先直接改成堆试试看

    class Solution {
        public int[] smallestK(int[] arr, int k) {
            if (k == 0){
                return new int[0];
            }
            PriorityQueue<Integer> queue = new PriorityQueue<>(Comparator.comparingInt(o -> o));
            for (int j : arr) {
                queue.add(j);
            }
            int[] list = new int[k];
            int count = 0;
            while (!queue.isEmpty() && count <k){
                list[count] = queue.poll();
                count++;
            }
            return list;
        }
    }
    解答成功:
    执行耗时:19 ms,击败了38.21% 的Java用户
    内存消耗:46.5 MB,击败了87.38% 的Java用

    接下来,另一个思路,先排序,排序后取前面k个结果返回,先撸一版代码,直接先调用API来试试

    class Solution2 {
        public int[] smallestK(int[] arr, int k) {
            if (k == 0){
                return new int[0];
            }
            int[] list = new int[k];
            Arrays.sort(arr);
            System.arraycopy(arr,0,list,0,k);
            return list;
    
        }
    }
    解答成功:
    执行耗时:6 ms,击败了70.64% 的Java用户
    内存消耗:48.2 MB,击败了20.73% 的Java用户

    emmm这速度可以啊

    LeetCode刷题【653】两数之和 IV – 输入 BST

    给定一个二叉搜索树 root 和一个目标结果 k,如果 BST 中存在两个元素且它们的和等于给定的目标结果,则返回 true

     

    示例 1:

    输入: root = [5,3,6,2,4,null,7], k = 9
    输出: true
    

    示例 2:

    输入: root = [5,3,6,2,4,null,7], k = 28
    输出: false
    

    示例 3:

    输入: root = [2,1,3], k = 4
    输出: true
    

    示例 4:

    输入: root = [2,1,3], k = 1
    输出: false
    

    示例 5:

    输入: root = [2,1,3], k = 3
    输出: true
    

     

    提示:

    • 二叉树的节点个数的范围是  [1, 104].
    • -104 <= Node.val <= 104
    • root 为二叉搜索树
    • -105 <= k <= 105
    Related Topics
  • 深度优先搜索
  • 广度优先搜索
  • 二叉搜索树
  • 哈希表
  • 双指针
  • 二叉树

  • 👍 273
  • 👎 0
  • 题解

    继续还是二叉搜索树,牢记特性,左小右大,中序遍历后是一个有序递增数组。

    那么直接一个中序遍历出来,这样题目就转换成在有个有序递增数组中寻找两个数的和能凑成k,是不是有点眼熟,对的,就是LeetCode刷题 【1】两数之和,先不管之前我们是怎么做的。

    那么,按照目前最直观的思路,从数组结尾开始的两个数字尝试相加,假设对应索引为index1,index2,如果这两个位置的值相加比目标值k,大,则尝试将前面一个索引往前移动一位,找一个更小的值相加看是否等于k,一直找到索引为0的位置。如果这两个最大的值相加的合比k小,说明不存在相加了能满足k的情况了。尝试过一轮之后,如果找不到合适的值,则将后一位的索引往前移动一位,继续这个过程。

    举例:【1,2,3,4,5,6,7,8】数组

    先用7+8尝试,如果大于则用6+8、5+8、4+8尝试,直到1+7尝试,如果没有合适的,则进行下一轮用6+7尝试,5+7、4+7依次尝试。

    好了,下面是代码:

    class Solution1 {
        List<Integer> list = new ArrayList<>();
        public boolean findTarget(TreeNode root, int k) {
            dfs(root);
            int index1 = list.size()-1;
            int index2 = index1-1;
    
            while (index2>=0){
                if (list.get(index1)+list.get(index2) < k){
                    return false;
                }
                while (index2 >= 0 && list.get(index1)+list.get(index2) >= k ){
                    if (list.get(index1)+list.get(index2) == k){
                        return true;
                    }
                    index2--;
                }
                index1--;
                index2=index1-1;
            }
            return false;
        }
    
        private void dfs(TreeNode node){
            if (null==node)return;
            dfs(node.left);
            list.add(node.val);
            dfs(node.right);
        }
    
    }

    而执行的结果告诉了我,问题应该不至于这样

    解答成功:
    执行耗时:1138 ms,击败了5.24% 的Java用户
    内存消耗:39.9 MB,击败了20.04% 的Java用户

    所以,回到上面的思路中间的过程看下,两个关键点“有序递增数组”,“在这个有序递增数组中寻找一个特定的值”,是不是很自然的就想到了此处应该可以用二分法来处理,此处后续省略。

    重新再看下整个思考的过程,就是一个求解a+b=k的过程,其中k预先已给出,a、b值在对二叉树遍历的时候能知道一个,就是当前节点的值。此时问题就变成了再二叉树的所有节点中找另一个值是否存在。此时问题就转换成了,在二叉树遍历过程中,已知了a,已知了k,再在二叉搜索树中搜索(k-a)这个值是否存在,可利用二叉树的左小右大的特性查找。

    代码:省略

    接下来再进一步,在a+b=k的求解过程中,查找b能否进一步优化呢?答案是可以的,遍历每个节点的时候把值存储到一个hash表中,这样查找b是否存在就可以从原来的搜索二叉树查找转换成hash查找,时间复杂度直接降为O(1)。

    class Solution {
    HashSet<Integer> hashSet = new HashSet<>();
    boolean result = false;
    public boolean findTarget(TreeNode root, int k) {
    dfs(root,k);
    return result;
    }

    private void dfs(TreeNode node, int k){
    if (null==node || result)return;
    dfs(node.left,k);
    if (!result){
    if (hashSet.contains(k-node.val)){
    result = true;
    }
    }
    hashSet.add(node.val);
    dfs(node.right,k);
    }

    }

    结果

    执行耗时:3 ms,击败了83.09% 的Java用户
    内存消耗:39.2 MB,击败了79.23% 的Java用户

    再看看我们之前第一题是怎么做的,LeetCode刷题 【1】两数之和,是不是回到了一样的解法上了。

    本题难度设定的是简单题,嗯,本质上就是在原来第一题两数之和的基础上嵌套了一个二叉树遍历。

    另外做这题的时候想到的一个点,二叉平衡搜索树的查找搜索过程,和二分法数组查找搜索,这两个算法,本质上是一样的。