LeetCode——贪心篇（三）

目录

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;
		}

	}