1450.在既定时间做作业的学生人数

目标

给你两个整数数组 startTime(开始时间)和 endTime(结束时间),并指定一个整数 queryTime 作为查询时间。

已知,第 i 名学生在 startTime[i] 时开始写作业并于 endTime[i] 时完成作业。

请返回在查询时间 queryTime 时正在做作业的学生人数。形式上,返回能够使 queryTime 处于区间 [startTime[i], endTime[i]](含)的学生人数。

示例 1:

输入:startTime = [1,2,3], endTime = [3,2,7], queryTime = 4
输出:1
解释:一共有 3 名学生。
第一名学生在时间 1 开始写作业,并于时间 3 完成作业,在时间 4 没有处于做作业的状态。
第二名学生在时间 2 开始写作业,并于时间 2 完成作业,在时间 4 没有处于做作业的状态。
第三名学生在时间 3 开始写作业,预计于时间 7 完成作业,这是是唯一一名在时间 4 时正在做作业的学生。

示例 2:

输入:startTime = [4], endTime = [4], queryTime = 4
输出:1
解释:在查询时间只有一名学生在做作业。

示例 3:

输入:startTime = [4], endTime = [4], queryTime = 5
输出:0

示例 4:

输入:startTime = [1,1,1,1], endTime = [1,3,2,4], queryTime = 7
输出:0

示例 5:

输入:startTime = [9,8,7,6,5,4,3,2,1], endTime = [10,10,10,10,10,10,10,10,10], queryTime = 5
输出:5

说明:

  • startTime.length == endTime.length
  • 1 <= startTime.length <= 100
  • 1 <= startTime[i] <= endTime[i] <= 1000
  • 1 <= queryTime <= 1000

思路

当满足 startTime[i] <= queryTime && endTime[i] >= queryTime 时计数即可。

当 queryTime 是一个数组时,可以使用差分数组或者二分查找来解,具体参考官网题解。

代码


/**
 * @date 2024-09-01 14:35
 */
public class BusyStudent1450 {

    public int busyStudent(int[] startTime, int[] endTime, int queryTime) {
        int n = startTime.length;
        int res = 0;
        for (int i = 0; i < n; i++) {
            if (startTime[i] <= queryTime && endTime[i] >= queryTime) {
                res++;
            }
        }
        return res;
    }
}

性能

3127.构造相同颜色的正方形

目标

给你一个二维 3 x 3 的矩阵 grid ,每个格子都是一个字符,要么是 'B' ,要么是 'W' 。字符 'W' 表示白色,字符 'B' 表示黑色。

你的任务是改变 至多一个 格子的颜色,使得矩阵中存在一个 2 x 2 颜色完全相同的正方形。

如果可以得到一个相同颜色的 2 x 2 正方形,那么返回 true ,否则返回 false 。

示例 1:

输入:grid = [["B","W","B"],["B","W","W"],["B","W","B"]]
输出:true
解释:
修改 grid[0][2] 的颜色,可以满足要求。

示例 2:

输入:grid = [["B","W","B"],["W","B","W"],["B","W","B"]]
输出:false
解释:
只改变一个格子颜色无法满足要求。

示例 3:

输入:grid = [["B","W","B"],["B","W","W"],["B","W","W"]]
输出:true
解释:
grid 已经包含一个 2 x 2 颜色相同的正方形了。

说明:

  • grid.length == 3
  • grid[i].length == 3
  • grid[i][j] 要么是 'W' ,要么是 'B' 。

思路

有一个 3 x 3 矩阵,每一个格子有黑白两色,分别用 B W 表示。问能否修改至多一个格子的颜色使矩阵中存在一个 2 x 2 的纯色(颜色相同)矩阵。

可能的 2 x 2 矩阵只有4个,它们有一个公共格子,以它为中心向左上、右上、左下、右下方向判断即可。可以分情况讨论,修改颜色的格子是中间的格子,那么要求其余的三个格子颜色相同。否则,其余格子与中间格子颜色不同的个数最多只能有一个。综上,与中心格子不同的颜色数只能为0、1、3,只需判断不等于2即可。

代码

/**
 * @date 2024-08-31 21:28
 */
public class CanMakeSquare3127 {
    static private final int[][][] directions = new int[][][]
    {
            {{-1, 0}, {-1, -1}, {0, -1}},
            {{1, 0}, {1, -1}, {0, -1}},
            {{-1, 0}, {-1, 1}, {0, 1}},
            {{1, 0}, {1, 1}, {0, 1}}
    };

    public boolean canMakeSquare(char[][] grid) {
        char mid = grid[1][1];
        for (int[][] direction : directions) {
            int cnt = 0;
            for (int[] cor : direction) {
                if (mid != grid[1 + cor[0]][1 + cor[1]]) {
                    cnt++;
                }
            }
            if (cnt != 2) {
                return true;
            }
        }
        return false;
    }

}

性能

3142.判断矩阵是否满足条件

目标

给你一个大小为 m x n 的二维矩阵 grid 。你需要判断每一个格子 grid[i][j] 是否满足:

  • 如果它下面的格子存在,那么它需要等于它下面的格子,也就是 grid[i][j] == grid[i + 1][j]
  • 如果它右边的格子存在,那么它需要不等于它右边的格子,也就是 grid[i][j] != grid[i][j + 1]

如果 所有 格子都满足以上条件,那么返回 true ,否则返回 false 。

示例 1:

输入:grid = [[1,0,2],[1,0,2]]
输出:true
解释:
网格图中所有格子都符合条件。

示例 2:

输入:grid = [[1,1,1],[0,0,0]]
输出:false
解释:
同一行中的格子值都相等。

示例 3:

输入:grid = [[1],[2],[3]]
输出:false
解释:
同一列中的格子值不相等。

说明:

  • 1 <= n, m <= 10
  • 0 <= grid[i][j] <= 9

思路

判断矩阵是否满足纵向元素都相等,横向相邻元素各不同。

代码


/**
 * @date 2024-08-29 0:07
 */
public class SatisfiesConditions3142 {

    public boolean satisfiesConditions(int[][] grid) {
        int m = grid.length;
        int n = grid[0].length;
        for (int i = 1; i < m; i++) {
            if (grid[i][0] != grid[i - 1][0]) {
                return false;
            }
        }
        for (int j = 1; j < n; j++) {
            if (grid[0][j] == grid[0][j - 1]) {
                return false;
            }
        }
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (grid[i][j] == grid[i][j - 1] || grid[i][j] != grid[i - 1][j]) {
                    return false;
                }
            }
        }
        return true;
    }
}

性能

3146.两个字符串的排列差

目标

给你两个字符串 s 和 t,每个字符串中的字符都不重复,且 t 是 s 的一个排列。

排列差 定义为 s 和 t 中每个字符在两个字符串中位置的绝对差值之和。

返回 s 和 t 之间的 排列差 。

示例 1:

输入:s = "abc", t = "bac"
输出:2
解释:
对于 s = "abc" 和 t = "bac",排列差是:
"a" 在 s 中的位置与在 t 中的位置之差的绝对值。
"b" 在 s 中的位置与在 t 中的位置之差的绝对值。
"c" 在 s 中的位置与在 t 中的位置之差的绝对值。
即,s 和 t 的排列差等于 |0 - 1| + |2 - 2| + |1 - 0| = 2。

示例 2:

输入:s = "abcde", t = "edbac"
输出:12
解释: s 和 t 的排列差等于 |0 - 3| + |1 - 2| + |2 - 4| + |3 - 1| + |4 - 0| = 12。

说明:

  • 1 <= s.length <= 26
  • 每个字符在 s 中最多出现一次。
  • t 是 s 的一个排列。
  • s 仅由小写英文字母组成。

思路

有两个仅由小写英文字母组成的字符串,同一字符串中的字母各不相同,并且组成两个字符串所用的字母相同,只是排列可能不同。求这两个字符串中相同字母位置之差的绝对值之和。

使用长度为26的数组记录每个字母在字符串s中的位置,然后遍历字符串t,计算位置之差的绝对值并累加求和即可。

代码


/**
 * @date 2024-08-24 15:01
 */
public class FindPermutationDifference3146 {
    public int findPermutationDifference(String s, String t) {
        int res = 0;
        int[] pos = new int[26];
        int n = s.length();
        for (int i = 0; i < n; i++) {
            pos[s.charAt(i) - 'a'] = i;
        }
        for (int i = 0; i < n; i++) {
            res += Math.abs(pos[t.charAt(i) - 'a'] - i);
        }
        return res;
    }
}

性能

551.学生出勤记录I

目标

给你一个字符串 s 表示一个学生的出勤记录,其中的每个字符用来标记当天的出勤情况(缺勤、迟到、到场)。记录中只含下面三种字符:

  • 'A':Absent,缺勤
  • 'L':Late,迟到
  • 'P':Present,到场

如果学生能够 同时 满足下面两个条件,则可以获得出勤奖励:

  • 按 总出勤 计,学生缺勤('A')严格 少于两天。
  • 学生 不会 存在 连续 3 天或 连续 3 天以上的迟到('L')记录。

如果学生可以获得出勤奖励,返回 true ;否则,返回 false 。

示例 1:

输入:s = "PPALLP"
输出:true
解释:学生缺勤次数少于 2 次,且不存在 3 天或以上的连续迟到记录。

示例 2:

输入:s = "PPALLL"
输出:false
解释:学生最后三天连续迟到,所以不满足出勤奖励的条件。

说明:

  • 1 <= s.length <= 1000
  • s[i] 为 'A'、'L' 或 'P'

思路

记录缺勤总次数,判断连续迟到天数即可。

代码


/**
 * @date 2024-08-18 19:52
 */
public class CheckRecord551 {

    public boolean checkRecord(String s) {
        int n = s.length();
        int absent = 0;
        int late = 0;
        for (int i = 0; i < n; i++) {
            char c = s.charAt(i);
            if (c == 'A') {
                absent++;
                if (absent == 2) {
                    return false;
                }
            } else if (c == 'L') {
                late++;
                if (late == 3) {
                    return false;
                }
                continue;
            }
            late = 0;
        }
        return true;
    }
}

性能

3151.特殊数组I

目标

如果数组的每一对相邻元素都是两个奇偶性不同的数字,则该数组被认为是一个 特殊数组 。

Aging 有一个整数数组 nums。如果 nums 是一个 特殊数组 ,返回 true,否则返回 false。

示例 1:

输入:nums = [1]
输出:true
解释:只有一个元素,所以答案为 true。

示例 2:

输入:nums = [2,1,4]
输出:true
解释:只有两对相邻元素: (2,1) 和 (1,4),它们都包含了奇偶性不同的数字,因此答案为 true。

示例 3:

输入:nums = [4,3,1,6]
输出:false
解释:nums[1] 和 nums[2] 都是奇数。因此答案为 false。

说明:

  • 1 <= nums.length <= 100
  • 1 <= nums[i] <= 100

思路

判断数组是否是特殊数组,所谓特殊数组指其每一对相邻元素的奇偶性不同。

依题意判断即可。

代码

/**
 * @date 2024-08-13 8:56
 */
public class IsArraySpecial3135 {
    public boolean isArraySpecial(int[] nums) {
        for (int i = 1; i < nums.length; i++) {
            if (nums[i] % 2 == nums[i - 1] % 2) {
                return false;
            }
        }
        return true;
    }
}

性能

3131.找出与数组相加的整数 I

目标

给你两个长度相等的数组 nums1 和 nums2。

数组 nums1 中的每个元素都与变量 x 所表示的整数相加。如果 x 为负数,则表现为元素值的减少。

在与 x 相加后,nums1 和 nums2 相等 。当两个数组中包含相同的整数,并且这些整数出现的频次相同时,两个数组 相等 。

返回整数 x 。

示例 1:

输入:nums1 = [2,6,4], nums2 = [9,7,5]
输出:3
解释:与 3 相加后,nums1 和 nums2 相等。

示例 2:

输入:nums1 = [10], nums2 = [5]
输出:-5
解释:与 -5 相加后,nums1 和 nums2 相等。

示例 3:

输入:nums1 = [1,1,1,1], nums2 = [1,1,1,1]
输出:0
解释:与 0 相加后,nums1 和 nums2 相等。

说明:

  • 1 <= nums1.length == nums2.length <= 100
  • 0 <= nums1[i], nums2[i] <= 1000
  • 测试用例以这样的方式生成:存在一个整数 x,使得 nums1 中的每个元素都与 x 相加后,nums1 与 nums2 相等。

思路

有两个整数数组 nums1nums2nums1 中的每个元素加上 x 之后可以通过调整元素位置得到 nums2,求 x

nums1nums2 的映射为双射,即单射和满射。为了求 x 我们只需要找到 nums1nums2 的最大值或最小值即可。

还有网友对两个数组求和,相减后再除以数组长度,不过需要注意数据溢出、数据类型的问题。

代码


/**
 * @date 2024-08-08 9:11
 */
public class AddedInteger3131 {

    public int addedInteger(int[] nums1, int[] nums2) {
        int n = nums1.length;
        int max1 = nums1[0];
        int max2 = nums2[0];
        for (int i = 1; i < n; i++) {
            if (max1 < nums1[i]) {
                max1 = nums1[i];
            }
            if (max2 < nums2[i]) {
                max2 = nums2[i];
            }
        }
        return max2 - max1;
    }
}

性能

572.另一棵树的子树

目标

给你两棵二叉树 root 和 subRoot 。检验 root 中是否包含和 subRoot 具有相同结构和节点值的子树。如果存在,返回 true ;否则,返回 false 。

二叉树 tree 的一棵子树包括 tree 的某个节点和这个节点的所有后代节点。tree 也可以看做它自身的一棵子树。

示例 1:

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

示例 2:

输入:root = [3,4,5,1,2,null,null,null,null,0], subRoot = [4,1,2]
输出:false

说明:

  • root 树上的节点数量范围是 [1, 2000]
  • subRoot 树上的节点数量范围是 [1, 1000]
  • -10^4 <= root.val <= 10^4
  • -10^4 <= subRoot.val <= 10^4

思路

判断给定的树是否是另一颗树的子树。

刚开始想以某种顺序(先/中/后)遍历给定的树并记录访问节点,然后遍历另一棵树,如果节点值等于给定树的根节点则以同样的顺序记录其子树,再比较记录是否相同。但是这并不能保证结构是相同的。

只能逐个节点比较。进一步优化可以计算树的高度,只比较高度相同的。//todo

看了官网题解可以引入两个null值,进行串匹配的时候可以使用 KMP 或者 Rabin-Karp 算法。//todo

也提供了将树映射为hash值来比较的思路。//todo

代码

/**
 * @date 2024-08-04 15:36
 */
public class IsSubtree572 {

    public boolean isSubtree(TreeNode root, TreeNode subRoot) {
        if (root == null) {
            return false;
        }
        if (root.val == subRoot.val) {
            if (compare(root, subRoot)) {
                return true;
            }
        }
        return isSubtree(root.left, subRoot) || isSubtree(root.right, subRoot);
    }

    public boolean compare(TreeNode root, TreeNode subRoot) {
        if (root.val != subRoot.val) {
            return false;
        }
        boolean res = false;
        if (root.left != null && subRoot.left != null) {
            res = compare(root.left, subRoot.left);
        } else if (root.left == null && subRoot.left == null){
            res = true;
        }
        if (root.right != null && subRoot.right != null) {
            res = compare(root.right, subRoot.right) && res;
        } else if (root.right == null && subRoot.right == null) {
        } else {
            res = false;
        }
        return res;
    }

}

性能

LCP40.心算挑战

目标

「力扣挑战赛」心算项目的挑战比赛中,要求选手从 N 张卡牌中选出 cnt 张卡牌,若这 cnt 张卡牌数字总和为偶数,则选手成绩「有效」且得分为 cnt 张卡牌数字总和。 给定数组 cards 和 cnt,其中 cards[i] 表示第 i 张卡牌上的数字。 请帮参赛选手计算最大的有效得分。若不存在获取有效得分的卡牌方案,则返回 0。

示例 1:

输入:cards = [1,2,8,9], cnt = 3
输出:18
解释:选择数字为 1、8、9 的这三张卡牌,此时可获得最大的有效得分 1+8+9=18。

示例 2:

输入:cards = [3,3,1], cnt = 1
输出:0
解释:不存在获取有效得分的卡牌方案。

说明:

  • 1 <= cnt <= cards.length <= 10^5
  • 1 <= cards[i] <= 1000

思路

从数组中选cnt个元素,找出最大的偶数和,如果不存在偶数和返回0。

如果cnt为偶数,那么直接取最大的cnt个即可,如果cnt为奇数,取最大的cnt-1个,然后再从大到小判断和是否为偶数即可。 与cnt的奇偶性无关,它也不能保证cnt个元素相加和为偶数,必须要奇数元素的个数为偶数才行。

应该使用动态规划来做了,O(cnt * n)超出时间限制。

尝试根据数组元素奇偶性分组,然后分情况讨论如何选取。这里的限制条件是必须选取偶数个奇数元素,并且使得和最大。

这道题标成简单真的搞人心态啊,还是做的太少了。

代码

/**
 * @date 2024-08-01 20:24
 */
public class MaxmiumScoreLCP40 {

    public int maxmiumScore_v2(int[] cards, int cnt) {
        int res = 0;
        PriorityQueue<Integer> odd = new PriorityQueue<>((a, b) -> b - a);
        PriorityQueue<Integer> even = new PriorityQueue<>((a, b) -> b - a);
        // 将奇偶元素分组
        for (int card : cards) {
            if (card % 2 == 0) {
                even.offer(card);
            } else {
                odd.offer(card);
            }
        }
        // 如果只能选一个元素,那么直接从偶数队列取,否则返回0
        if (cnt == 1 && even.size() > 0) {
            return even.poll();
        } else if (cnt == 1) {
            return 0;
        }
        int oddCnt = 0;
        int lastOdd = 0;
        int lastEven = 0;
        // 从奇偶队列中,从大到小取cnt-1个,留一个后面分情况讨论
        while (cnt > 1) {
            if (!odd.isEmpty() && !even.isEmpty() && odd.peek() > even.peek()) {
                lastOdd = odd.poll();
                res += lastOdd;
                oddCnt++;
            } else if (!odd.isEmpty() && !even.isEmpty()) {
                lastEven = even.poll();
                res += lastEven;
            } else if (!odd.isEmpty()) {
                lastOdd = odd.poll();
                res += lastOdd;
                oddCnt++;
            } else if (!even.isEmpty()) {
                lastEven = even.poll();
                res += lastEven;
            }
            cnt--;
        }
        if (oddCnt % 2 == 1 && !odd.isEmpty()) {
            // 如果选择了奇数个奇数元素,并且奇数队列还有剩余元素
            if (even.size() >= 2) {
                // 如果偶数队列有超过两个,并且这两个之和大于最近已选的奇数元素+奇数队列的元素
                int tmp = even.poll();
                tmp += even.poll();
                if (tmp > lastOdd + odd.peek()) {
                    // 将上一个奇数选择删除,选两个偶数
                    res += tmp - lastOdd;
                } else {
                    // 否则选一个奇数
                    res += odd.poll();
                }
            } else {
                // 如果没有多余的偶数元素,直接选一个奇数
                res += odd.poll();
            }
        } else if (oddCnt % 2 == 1 && even.size() >= 2) {
            // 如果已经选了奇数个奇数元素,并且没有多余的奇数元素了,那么回退,选两个偶数
            res -= lastOdd;
            res += even.poll();
            res += even.poll();
        } else if (oddCnt % 2 == 0) {
            // 如果奇数元素选了偶数个,那么只需再选一个偶数,或者删掉一个偶数,选两个奇数
            if (odd.size() >= 2 && lastEven != 0) {
                // 如果奇数存在两个,且之前选过偶数
                int tmp = odd.poll();
                tmp += odd.poll();
                if (even.size() == 0 || tmp > lastEven + even.peek()) {
                    // 如果没有多余的偶数,或者两个奇数之和大于之前选择的偶数+偶数队列元素
                    // 选两个奇数
                    res += tmp - lastEven;
                } else {
                    // 选一个偶数
                    res += even.poll();
                }
            } else {
                // 如果没有多余2个的奇数了,只能选一个偶数
                if (even.size() == 0) {
                    return 0;
                } else {
                    res += even.poll();
                }
            }
        } else {
            // 如果已经选了奇数个奇数元素,并且没有多余的奇数元素了,并且偶数个数不足2个,返回0
            res = 0;
        }
        return res;
    }

}

性能

2956.找到两个数组中的公共元素

目标

给你两个下标从 0 开始的整数数组 nums1 和 nums2 ,它们分别含有 n 和 m 个元素。

请你计算以下两个数值:

  • 统计 0 <= i < n 中的下标 i ,满足 nums1[i] 在 nums2 中 至少 出现了一次。
  • 统计 0 <= i < m 中的下标 i ,满足 nums2[i] 在 nums1 中 至少 出现了一次。

请你返回一个长度为 2 的整数数组 answer ,按顺序 分别为以上两个数值。

示例 1:

输入:nums1 = [4,3,2,3,1], nums2 = [2,2,5,2,3,6]
输出:[3,4]
解释:分别计算两个数值:
- nums1 中下标为 1 ,2 和 3 的元素在 nums2 中至少出现了一次,所以第一个值为 3 。
- nums2 中下标为 0 ,1 ,3 和 4 的元素在 nums1 中至少出现了一次,所以第二个值为 4 。

示例 2:

输入:nums1 = [3,4,2,3], nums2 = [1,5]
输出:[0,0]
解释:两个数组中没有公共元素,所以两个值都为 0 。

说明:

  • n == nums1.length
  • m == nums2.length
  • 1 <= n, m <= 100
  • 1 <= nums1[i], nums2[i] <= 100

思路

有两个数组,统计在当前数组中出现,同时也在另一数组中出现的元素个数,即公共元素个数。数组 [1, 1, 1, 2][1, 2, 3] 的公共元素是 1,2,公共元素个数分别是 4、2

常规的做法是使用HashSet分别保存数组元素,然后再次遍历数组判断是否是公共元素。由于数据范围比较小,可以直接使用数组计数。

代码


/**
 * @date 2024-07-16 0:14
 */
public class FindIntersectionValues2956 {

    /**
     * 改进
     */
    public int[] findIntersectionValues_v1(int[] nums1, int[] nums2) {
        int[] count1 = new int[101];
        for (int i : nums1) {
            count1[i]++;
        }
        int a = 0, b = 0;
        for (int i : nums2) {
            if (count1[i] != 0) {
                b++;
                a += count1[i] == -1 ? 0 : count1[i];
                count1[i] = -1;
            }
        }
        return new int[]{a, b};
    }

    public int[] findIntersectionValues(int[] nums1, int[] nums2) {
        int[] count1 = new int[101];
        int[] count2 = new int[101];
        for (int i : nums1) {
            count1[i]++;
        }
        for (int i : nums2) {
            count2[i]++;
        }
        int a = 0;
        int b = 0;
        for (int i = 0; i < 101; i++) {
            if (count1[i] > 0) {
                b += count2[i];
            }
            if (count2[i] > 0) {
                a += count1[i];
            }
        }
        return new int[]{a, b};
    }
}

性能