LeetCode 1609. 奇偶树 / 1078. Bigram 分词 / 825. 适龄的朋友（计数排序）

最新推荐文章于 2022-04-11 10:41:43 发布

Zephyr丶J

最新推荐文章于 2022-04-11 10:41:43 发布

阅读量432

点赞数

分类专栏： LeetCode 文章标签： leetcode java

本文链接：https://blog.csdn.net/windyjcy/article/details/122139683

版权

LeetCode 专栏收录该内容

198 篇文章 1 订阅

订阅专栏

1609. 奇偶树

2021.12.25 每日一题，圣诞快乐，考研顺利，今天没有圣诞树，但是有奇偶树

题目描述

如果一棵二叉树满足下述几个条件，则可以称为奇偶树：

二叉树根节点所在层下标为 0 ，根的子节点所在层下标为 1 ，根的孙节点所在层下标为 2 ，依此类推。
偶数下标层上的所有节点的值都是奇整数，从左到右按顺序严格递增
奇数下标层上的所有节点的值都是偶整数，从左到右按顺序严格递减
给你二叉树的根节点，如果二叉树为奇偶树，则返回 true ，否则返回 false 。

示例 1：

输入：root = [1,10,4,3,null,7,9,12,8,6,null,null,2]
输出：true
解释：每一层的节点值分别是：
0 层：[1]
1 层：[10,4]
2 层：[3,7,9]
3 层：[12,8,6,2]
由于 0 层和 2 层上的节点值都是奇数且严格递增，而 1 层和 3 层上的节点值都是偶数且严格递减，因此这是一棵奇偶树。

示例 2：

输入：root = [5,4,2,3,3,7]
输出：false
解释：每一层的节点值分别是：
0 层：[5]
1 层：[4,2]
2 层：[3,3,7]
2 层上的节点值不满足严格递增的条件，所以这不是一棵奇偶树。

示例 3：

输入：root = [5,9,1,3,5,7]
输出：false
解释：1 层上的节点值应为偶数。

示例 4：

输入：root = [1]
输出：true

示例 5：

输入：root = [11,8,6,1,3,9,11,30,20,18,16,12,10,4,2,17]
输出：true

提示：

树中节点数在范围 [1, 10^5] 内
1 <= Node.val <= 10^6

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/even-odd-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

层序遍历就行了

/**
 * 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 boolean isEvenOddTree(TreeNode root) {
        //就是一个简单的层序遍历吧，想想
        //层序遍历，因为每一层都是从左到右记录的，所以直接看是否递增递减和奇偶性就可以了
        
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        int level = 0;
        while(!queue.isEmpty()){
            int size = queue.size();
            int last = -1;
            while(size-- > 0){
                TreeNode node = queue.poll();
                int val = node.val;
                //如果是奇数层
                if((level & 1) == 1){
                    if((val & 1) == 1)
                        return false;
                    if(last != -1 && val >= last)
                        return false;
                }else{
                    if((val & 1) == 0)
                        return false;
                    if(last != -1 && val <= last)
                        return false;
                }
                if(node.left != null)
                    queue.offer(node.left);
                if(node.right != null)
                    queue.offer(node.right);
                    
                last = node.val;
            }
            level++;
        }
        return true;
    }
}

1078. Bigram 分词

2021.12.26 每日一题

题目描述

给出第一个词 first 和第二个词 second，考虑在某些文本 text 中可能以 “first second third” 形式出现的情况，其中 second 紧随 first 出现，third 紧随 second 出现。

对于每种这样的情况，将第三个词 “third” 添加到答案中，并返回答案。

示例 1：

输入：text = “alice is a good girl she is a good student”, first = “a”, second = “good”
输出：[“girl”,“student”]

示例 2：

输入：text = “we will we will rock you”, first = “we”, second = “will”
输出：[“we”,“rock”]

提示：

1 <= text.length <= 1000
text 由小写英文字母和空格组成
text 中的所有单词之间都由单个空格字符分隔
1 <= first.length, second.length <= 10
first 和 second 由小写英文字母组成

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/occurrences-after-bigram
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

注意toArray()的用法

class Solution {
    public String[] findOcurrences(String text, String first, String second) {
        String[] txt = text.split(" ");
        List<String> list = new ArrayList<>();
        for(int i = 2; i < txt.length; i++){
            if(txt[i - 2].equals(first) && txt[i - 1].equals(second))
                list.add(txt[i]);
        }
        return list.toArray(new String[]{});
    }
}

825. 适龄的朋友

2021.12.27 每日一题

题目描述

在社交媒体网站上有 n 个用户。给你一个整数数组 ages ，其中 ages[i] 是第 i 个用户的年龄。

如果下述任意一个条件为真，那么用户 x 将不会向用户 y（x != y）发送好友请求：

age[y] <= 0.5 * age[x] + 7
age[y] > age[x]
age[y] > 100 && age[x] < 100
否则，x 将会向 y 发送一条好友请求。

注意，如果 x 向 y 发送一条好友请求，y 不必也向 x 发送一条好友请求。另外，用户不会向自己发送好友请求。

返回在该社交媒体网站上产生的好友请求总数。

示例 1：

输入：ages = [16,16]
输出：2
解释：2 人互发好友请求。

示例 2：

输入：ages = [16,17,18]
输出：2
解释：产生的好友请求为 17 -> 16 ，18 -> 17 。

示例 3：

输入：ages = [20,30,100,110,120]
输出：3
解释：产生的好友请求为 110 -> 100 ，120 -> 110 ，120 -> 100 。

提示：

n == ages.length
1 <= n <= 2 * 10^4
1 <= ages[i] <= 120

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/friends-of-appropriate-ages
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

第一时间被第三个条件给迷惑了，导致问题出了一大堆
发现问题后，又自然而然的认为两个相同的值是肯定要交流的，所以一直没发现错误
最终debug终于发现了问题，好不容易过了
其实应该写个双指针的
双指针更简单

class Solution {
    
    public int numFriendRequests(int[] ages) {
        //首先看条件，发现100以上和100以下是不会进行交流的，所以可以把年龄段分为100以上和100以下两个部分，且都包含100
        //0.5 * age[x] + 7 < age[y] <= age[x]
        //年龄大的给年龄小的发请求，小的不会给大的发
        //想到一个思路，先排序，然后对于每一个年龄，查找可以发送请求的范围，找到这个值以后，通过下标来计算个数

        //错了，第三个条件只是说小于100的不给大于100的发消息，但是大于100的可以给小于100的发
        //然后再看第三个条件，x小于100，y大于100，第二个条件就给出不成立了，所以相当于恒成立............
        //搞的我处理了半天这个条件

        int n = ages.length;
        Arrays.sort(ages);
        int res = 0;
        for(int i = 0; i < n;){
            int left = 0;
            int right = i - 1;
            double range = 0.5 * ages[i] + 7;
            
            while(left < right){
                int mid = (right - left + 1) / 2 + left;
                //如果满足条件的，那么就再往左边找第一个满足条件的
                if((double)ages[mid] > range){
                    right = mid - 1;
                }else{
                    left = mid;
                }
            }

            //找相同值
            int t = i + 1;
            while(t < n && ages[t] == ages[i]){
                t++;
            }

            //如果left位置处的值满足条件
            if((double)ages[left] > range){
                int add = t - 1 - left;
                res += (t - i) * add;

            //如果不满足条件，那么只计算相同的
            }else{
                int add = t - left - 2;
                if(add > 0 && (double)ages[i] > range)
                    res += (t - i) * add;
            }
            i = t;
        }
        return res;
    }
}

双指针，但是竟然比二分要慢

class Solution {
    public int numFriendRequests(int[] ages) {
        //双指针果然更简单
        
        int n = ages.length;
        Arrays.sort(ages);
        int left = 0, right = 0, ans = 0;
        for (int age : ages) {
            if (age < 15) {
                continue;
            }
            while (ages[left] <= 0.5 * age + 7) {
                ++left;
            }
            while (right + 1 < n && ages[right + 1] <= age) {
                ++right;
            }
            ans += right - left;
        }
        return ans;
    }
}

计数排序，统计每个年龄的人数，然后对于每一个年龄，计算满足条件的人的个数
用前缀和优化这个过程

class Solution {
    public int numFriendRequests(int[] ages) {
        //计数排序
        //统计每个年龄的人数，然后对于每一个年龄，计算符合要求的人数
        int[] num = new int[121];
        for(int age : ages){
            num[age]++;
        }
        int[] pre = new int[121];
        for(int i = 1; i < 121; i++){
            pre[i] = pre[i - 1] + num[i];
        }
        int ans = 0;
        for(int i = 15; i < 121; i++){
            int range = (int)(0.5 * i) + 7;
            if(num[i] > 0){
                ans += num[i] * (pre[i] - pre[range] - 1);
            }
        }
        return ans;
    }
}

Zephyr丶J

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
LeetCode 1609. 奇偶树 / 1078. Bigram 分词 / 825. 适龄的朋友（计数排序）

1609. 奇偶树2021.12.25 每日一题，圣诞快乐，考研顺利，今天没有圣诞树，但是有奇偶树题目描述如果一棵二叉树满足下述几个条件，则可以称为奇偶树：二叉树根节点所在层下标为 0 ，根的子节点所在层下标为 1 ，根的孙节点所在层下标为 2 ，依此类推。偶数下标层上的所有节点的值都是奇整数，从左到右按顺序严格递增奇数下标层上的所有节点的值都是偶整数，从左到右按顺序严格递减给你二叉树的根节点，如果二叉树为奇偶树，则返回 true ，否则返回 false 。示例 1：
复制链接

扫一扫