LeetCode刷题总结：（8）贪心相关问题

贪心算法需要我们针对问题场景设计出合理的贪心选择，贪心的实现代码一般都是不难的，真正难的是如何证明我们的贪心算法是正确的！因为一个贪心算法不一定能解出最优解，往往是次优解，只有证明了贪心算法是正确的，那么解才是最优解。证明贪心算法正确性的方法一般用数学归纳法和反证法。

 

455. 分发饼干

假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。对每个孩子 i ，都有一个胃口值 gi ，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j ，都有一个尺寸 sj 。如果 sj >= gi ，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。

注意：

你可以假设胃口值为正。
一个小朋友最多只能拥有一块饼干。

示例 1:

输入: [1,2,3], [1,1]

输出: 1

解释: 
你有三个孩子和两块小饼干，3个孩子的胃口值分别是：1,2,3。
虽然你有两块小饼干，由于他们的尺寸都是1，你只能让胃口值是1的孩子满足。
所以你应该输出1。

示例 2:

输入: [1,2], [1,2,3]

输出: 2

解释: 
你有两个孩子和三块小饼干，2个孩子的胃口值分别是1,2。
你拥有的饼干数量和尺寸都足以让所有孩子满足。
所以你应该输出2.

// 思路： 贪心分配，即将最大的饼干分配给能得到满足的最贪心的小朋友，第二块饼干也是这样分配
class Solution {
public:
	int findContentChildren(vector<int>& g, vector<int>& s) {

		// 首先将g和s从大到小排序一下
		sort(g.begin(), g.end(), greater<int>());
		sort(s.begin(), s.end(), greater<int>());

		// 用于循环的两个索引
		int sIndex = 0;
		int gIndex = 0;
		int res = 0;

		// 开始分配
		while (sIndex < s.size() && gIndex < g.size()) {

			if (s[sIndex] >= g[gIndex]) {
				sIndex++;
				gIndex++;
				res++;
			}
			else {
				gIndex++;
			}
		}

		return res;
	}
};

 

392. 判断子序列

给定字符串 s 和 t ，判断 s 是否为 t 的子序列。

你可以认为 s 和 t 中仅包含英文小写字母。字符串 t 可能会很长（长度 ~= 500,000），而 s 是个短字符串（长度 <=100）。

字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。

示例 1:
s = "abc", t = "ahbgdc"

返回 true.

示例 2:
s = "axc", t = "ahbgdc"

返回 false.

后续挑战 :

如果有大量输入的 S，称作S1, S2, ... , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？

// 思路： 先找子序列中的第一个的位置，找到后在主序列之后的位置中找第二个对应数据，以此类推
class Solution1 {
public:
	bool isSubsequence(string s, string t) {

		// 如果子串是空，那么总是会true的
		if (s.size() == 0)
			return true;

		int sIndex = 0;
		int tIndex = 0;

		int sn = s.size();
		int tn = t.size();

		while (tIndex < tn && sIndex < sn) {

			if (t[tIndex] == s[sIndex]) {
				tIndex++;
				sIndex++;
			}
			else
				tIndex++;
			if (sIndex == sn)
				return true;
		}

		return false;
	}
};

 

435. 无重叠区间

给定一个区间的集合，找到需要移除区间的最小数量，使剩余区间互不重叠。

注意:

1. 可以认为区间的终点总是大于它的起点。
2. 区间 [1,2] 和 [2,3] 的边界相互“接触”，但没有相互重叠。

示例 1:

输入: [ [1,2], [2,3], [3,4], [1,3] ]

输出: 1

解释: 移除 [1,3] 后，剩下的区间没有重叠。

示例 2:

输入: [ [1,2], [1,2], [1,2] ]

输出: 2

解释: 你需要移除两个 [1,2] 来使剩下的区间没有重叠。

示例 3:

输入: [ [1,2], [2,3] ]

输出: 0

解释: 你不需要移除任何区间，因为它们已经是无重叠的了。

class Solution2 {

private:

	static bool compare(const Interval& a, const Interval& b) {
		if (a.start != b.start)
			return a.start < b.start;

		return a.end < b.end;
	}

	static bool compare1(const Interval& a, const Interval& b) {
		if (a.end != b.end)
			return a.end < b.end;

		return a.start < b.start;
	}

public:

	// 动态规划版思路： 状态：以intervals[j]为最后一个区间的最长不重叠区间的长度 = max(以intervals[i]为最后一个区间的最长不重叠区间的长度,
	// 其中，要求intervals[i].end<=intervals[j].start,遍历一遍所有符合条件的i)
	int eraseOverlapIntervals(vector<Interval>& intervals) {

		if (intervals.size() == 0)
			return 0;

		sort(intervals.begin(), intervals.end(), compare);

		// memo[i] 表示使用intervals[index]作为最后区间的在intervals[0,...,index]的区间能构成的最长不重叠区间序列
		vector<int> memo(intervals.size(), 1);
		int res = 1;
		for (int i = 1; i < intervals.size(); i++) {
			// memo[i]
			for (int j = 0; j < i; j++) {
				if (intervals[i].start >= intervals[j].end)
					memo[i] = max(memo[i], memo[j] + 1);
			}
			res = max(res, memo[i]);
		}

		return intervals.size() - res;
	}


	// 贪心版本：怎么贪？
	// 首先对所有区间排序，end越小的排前面，end相等时，start越小的越前面
	// 区间选取的时候先选取end越小的，相等ens时选取start越小的放进最终的区间
	int eraseOverlapIntervals1(vector<Interval>& intervals) {

		if (intervals.size() == 0)
			return 0;

		sort(intervals.begin(), intervals.end(), compare1);

		// 一开始就选取排好序的第一个区间
		int res = 1;
		int pre = 0;

		for (int i = 1; i < intervals.size(); i++) {
			if (intervals[i].start >= intervals[pre].end) {
				res++;
				pre = i;
			}
		}

		return intervals.size() - res;
	}
};