目录
452. 用最少数量的箭引爆气球
435. 无重叠区间
763. 划分字母区间
56. 合并区间
738. 单调递增的数字
968. 监控二叉树
刷题顺序及思路来源于代码随想录，网站地址：https://programmercarl.com
452. 用最少数量的箭引爆气球
有一些球形气球贴在一堵用 XY 平面表示的墙面上。墙面上的气球记录在整数数组 points ，其中points[i] = [xstart, xend] 表示水平直径在 xstart 和 xend之间的气球。你不知道气球的确切 y 坐标。
一支弓箭可以沿着 x 轴从不同点 完全垂直 地射出。在坐标 x 处射出一支箭，若有一个气球的直径的开始和结束坐标为 xstart，xend， 且满足 xstart ≤ x ≤ xend，则该气球会被 引爆 。可以射出的弓箭的数量 没有限制 。 弓箭一旦被射出之后，可以无限地前进。
给你一个数组 points ，返回引爆所有气球所必须射出的 最小 弓箭数 。
输入：points = [[10,16],[2,8],[1,6],[7,12]]
输出：2
解释：气球可以用2支箭来爆破:
-在x = 6处射出箭，击破气球[2,8]和[1,6]。
-在x = 11处发射箭，击破气球[10,16]和[7,12]。import java.util.Arrays;
import java.util.Comparator;
/**
* @author light
* @Description 452. 用最少数量的箭引爆气球
*
*
* （思路：重叠在一起的气球用一只箭射出，
* 但要注意重叠的右区间：如果下一个气球的左边界小于上一个重叠区间最小的右边界，则这个气球可以被同一只箭引爆
* @create 2023-09-09 8:25
*/
public class FindMinArrowShotsTest {
public static void main(String[] args) {
int[][] points={{10,6},{2,8},{1,6},{7,12}};
System.out.println(findMinArrowShots(points));
}
public static int findMinArrowShots(int[][] points) {
//先将气球按最左区间从小到大排序
//int 范围为-2147483648——2147483647，测试案例中会溢出
Arrays.sort(points, new Comparator<int[]>() {
@Override
public int compare(int[] o1, int[] o2) {
//return o1[0]-o2[0];
return Integer.compare(o1[0],o2[0]); //采用Integer.compare()不会溢出
}
});
int count=1; //气球不为空则至少需要一只箭
for (int i = 1; i < points.length; i++) {
if(points[i][0]>points[i-1][1]){
count++;
}else {
points[i][1]=Math.min(points[i][1],points[i-1][1]);
}
}
return count;
}
}
435. 无重叠区间
给定一个区间的集合 intervals ，其中 intervals[i] = [starti, endi] 。返回 需要移除区间的最小数量，使剩余区间互不重叠 。
输入: intervals = [[1,2],[2,3],[3,4],[1,3]]
输出: 1
解释: 移除 [1,3] 后，剩下的区间没有重叠。import java.util.Arrays;
import java.util.Comparator;
/**
* @author light
* @Description 无重叠区间
*
*
* @create 2023-09-10 10:41
*/
public class EraseOverlapIntervalsTest {
public static void main(String[] args) {
int[][] intervals={{1,2},{2,3},{3,4},{1,3}};
System.out.println(eraseOverlapIntervals(intervals));
}
public static int eraseOverlapIntervals(int[][] intervals) {
//先将数组按左边界排序
Arrays.sort(intervals, new Comparator<int[]>() {
@Override
public int compare(int[] o1, int[] o2) {
return Integer.compare(o1[0],o2[0]);
}
});
int count=0;//记录重叠区间数
for (int i = 1; i < intervals.length; i++) {
if(intervals[i][0]<intervals[i-1][1]){ //判断重叠情况
count++;
intervals[i][1]=Math.min(intervals[i][1],intervals[i-1][1]);
}
}
return count;
}
}
763. 划分字母区间
给你一个字符串 s 。我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。
注意，划分结果需要满足：将所有划分结果按顺序连接，得到的字符串仍然是 s 。
返回一个表示每个字符串片段的长度的列表。
输入：s = "ababcbacadefegdehijhklij"
输出：[9,7,8]
解释：
划分结果为 "ababcbaca"、"defegde"、"hijhklij" 。
每个字母最多出现在一个片段中。
像 "ababcbacadefegde", "hijhklij" 这样的划分是错误的，因为划分的片段数较少。import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
/**
* @author light
* @Description 划分字母区间
*
* (思路:遍历字符串，找到每个字符的最远下标
* @create 2023-09-10 11:07
*/
public class PartitionLabelsTest {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
String s=input.next();
System.out.println(partitionLabels(s));
}
public static List<Integer> partitionLabels(String s) {
List<Integer> list=new ArrayList<>(); //定义结果集
int[] edge=new int[27]; //存放元素最远下标
char[] arr=s.toCharArray();
for (int i = 0; i < arr.length; i++) {
edge[arr[i]-'a']=i;
}
int idx=0;
int end=0;
for (int i = 0; i < arr.length; i++) {
idx=Math.max(idx,edge[arr[i]-'a']); //找到最远下标
if(i==idx){
list.add(idx-end+1); //将长度加入集合中
end=i+1;
}
}
return list;
}
}
56. 合并区间
以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间 。
输入：intervals = [[1,3],[2,6],[8,10],[15,18]]
输出：[[1,6],[8,10],[15,18]]
解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].public static int[][] merge(int[][] intervals) {
List<int[]> list=new ArrayList<>();
//将数组按左边界排序
Arrays.sort(intervals, new Comparator<int[]>() {
@Override
public int compare(int[] o1, int[] o2) {
return Integer.compare(o1[0],o2[0]);
}
});
for (int i = 1; i < intervals.length; i++) {
if(intervals[i][0]<=intervals[i-1][1]){
//有重叠，合并区间---求右边界最大值,左区间最小值
intervals[i][1]=Math.max(intervals[i-1][1],intervals[i][1]);
intervals[i][0]=Math.min(intervals[i-1][0],intervals[i][0]);
}else {
list.add(intervals[i-1]);
}
}
list.add(intervals[intervals.length-1]);
return list.toArray(new int[list.size()][]);
}738. 单调递增的数字
当且仅当每个相邻位数上的数字 x 和 y 满足 x <= y 时，我们称这个整数是单调递增的。
给定一个整数 n ，返回 小于或等于 n 的最大数字，且数字呈 单调递增 。
输入: n = 10
输出: 9
import java.util.Scanner;
/**
* @author light
* @Description 单调递增的数字
。
*
* (思路：从后向前遍历数字，当遇到Num[i]<Num[i-1]时,只需要令Num[i]=9，Num[i-1]--即可,
* @create 2023-09-10 13:40
*/
public class MonotoneIncreasingDigitsTest {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
int n=input.nextInt();
System.out.println(monotoneIncreasingDigits(n));
}
public static int monotoneIncreasingDigits(int n) {
String s=String.valueOf(n);
char[] arr=s.toCharArray();
int flag=arr.length;
for (int i =arr.length-1; i >0; i--) {
if(arr[i-1]>arr[i]){
arr[i-1]--;
flag=i; //记录要变为9的下标起始位置
}
}
for (int i = flag; i < arr.length; i++) {
arr[i]='9';
}
return Integer.parseInt(String.valueOf(arr));
}
}
968. 监控二叉树
给定一个二叉树，我们在树的节点上安装摄像头。
节点上的每个摄影头都可以监视其父对象、自身及其直接子对象。
计算监控树的所有节点所需的最小摄像头数量。
int count=0;
public int minCameraCover(TreeNode root) {
if(minCamera(root)==0){ //对根节点进行校验，防止根节点无覆盖
count++;
}
return count;
}
private int minCamera(TreeNode root) {
if(root==null){
return 2; //空节点---有覆盖
}
//左
int left=minCamera(root.left);
//右
int right=minCamera(root.right);
//中
//1.左右孩子都有覆盖---中间父节点无覆盖
if(left==2&&right==2){
return 0;
}else if(left==0||right==0){
// 2.左右孩子至少一个无覆盖---中间结点父放摄像头
count++;
return 1;
} else {
// 3.左右孩子有一个有摄像头---中间父节点有覆盖
return 2;
}
}
