貪心算法經典題目：https://blog.csdn.net/qq_42820853/article/details/106788590
給定一個非負整數數組，你最初位於數組的第一個位置。
數組中的每個元素代表你在該位置可以跳躍的最大長度。
判斷你是否能夠到達最后一個位置。
示例 1:
輸入: [2,3,1,1,4] 輸出: true 解釋: 我們可以先跳 1 步，從位置 0 到達 位置 1, 然后再從位置 1 跳 3 步到達最后一個位置。
示例 2:
輸入: [3,2,1,0,4] 輸出: false 解釋: 無論怎樣，你總會到達索引為 3 的位置。但該位置的最大跳躍長度是 0 ， 所以你永遠不可能到達最后一個位置。
思路：通過題目中的跳躍規則，最多能跳多遠?如果能夠越過最后一格，返回 true，否則返回 false。
class Solution {
public:
bool canJump(vector<int>& nums) {
int len = nums.size();
int dis = 0;
for(int i=0;i<len-1;i++){
dis = max(dis,nums[i]+i);
if(dis<=i){
return false;
}
}
return dis>=len-1;
}
};
給定一個非負整數數組，你最初位於數組的第一個位置。
數組中的每個元素代表你在該位置可以跳躍的最大長度。
你的目標是使用最少的跳躍次數到達數組的最后一個位置。
示例:
輸入: [2,3,1,1,4] 輸出: 2 解釋: 跳到最后一個位置的最小跳躍數是2。 從下標為 0 跳到下標為 1 的位置，跳1步，然后跳3步到達數組的最后一個位置。
說明:
假設你總是可以到達數組的最后一個位置。
class Solution {
public:
int jump(vector<int>& nums) {
int len = nums.size();
int dis = 0;
int end = 0;
int step = 0;
for(int i=0;i<len-1;i++){
dis = max(dis,nums[i]+i);
if(end==i){
step++;
end = dis;
}
}
return step;
}
};
假設你是一位很棒的家長，想要給你的孩子們一些小餅干。但是，每個孩子最多只能給一塊餅干。對每個孩子 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) {
int num = 0;
sort(g.begin(),g.end());
sort(s.begin(),s.end());
int j = 0;
int i = 0;
for(;i<s.size()&&j<g.size();i++){
if(s[i]>=g[j]){
num++;
j++;
}
}
return num;
}
};
135. 分發糖果
老師想給孩子們分發糖果，有 N 個孩子站成了一條直線，老師會根據每個孩子的表現，預先給他們評分。
你需要按照以下要求，幫助老師給這些孩子分發糖果：
每個孩子至少分配到 1 個糖果。
相鄰的孩子中，評分高的孩子必須獲得更多的糖果。
那么這樣下來，老師至少需要准備多少顆糖果呢？
示例 1:
輸入: [1,0,2]
輸出: 5
解釋: 你可以分別給這三個孩子分發 2、1、2 顆糖果。
示例 2:
輸入: [1,2,2]
輸出: 4
解釋: 你可以分別給這三個孩子分發 1、2、1 顆糖果。
第三個孩子只得到 1 顆糖果，這已滿足上述兩個條件。
思路：
在處理這道題的時候，不能只單純的判斷數字是否有遞增；
在評分處於遞增，但中間有遞減，再次遞增的情況時，要注意再次遞減時候糖果的分配
評分: 1 2 3 3 4 5 4 3 4 5 6 7 6 5
糖果: 1 1 1 1 1 1 1 1 1 1 1 1 1 1 //每個小孩最少要拿到一個糖果
過程: 1 2 3 1 2 3 1 1 2 3 4 5 1 1 //后一個小朋友大於前一個時，要多拿一個糖果
———— ————
//5 4 //6 5 糖果分配不合理
//所以要從后向前再進行一次遍歷，保證處於遞減情況時，糖果分配的合理性
//糖果分配的第一個過程：if(ratings[i] > ratings[i-1]) 糖果比前一個多拿一個
//從后向前再次進行遍歷時: nums[i] = max(nums[i],nums[i+1]+1);
//i的評分高於i+1，所以糖果一定要取最多的
class Solution {
public:
int candy(vector<int>& ratings) {
int len = ratings.size();
if(len == 0 || len == 1) return len;
int candy = 0;
vector<int> nums(len,1);
for(int i = 1;i < len;++i)
{
if(ratings[i] > ratings[i-1]) //比前一個評分高的情況
{
nums[i] = nums[i-1] + 1;
}
}
for(int i = len-2;i >= 0;--i) //比后一個評分高，但是分的糖果少的情況
{
if(ratings[i] > ratings[i+1])
{
nums[i] = max(nums[i],nums[i+1]+1);
}
}
for(int i = 0;i < nums.size();++i)
{
candy += nums[i];
}
return candy;
}
};
134. 加油站
在一條環路上有 N 個加油站，其中第 i 個加油站有汽油 gas[i] 升。
你有一輛油箱容量無限的的汽車，從第 i 個加油站開往第 i+1 個加油站需要消耗汽油 cost[i] 升。你從其中的一個加油站出發，開始時油箱為空。
如果你可以繞環路行駛一周，則返回出發時加油站的編號，否則返回 -1。
說明:
如果題目有解，該答案即為唯一答案。
輸入數組均為非空數組，且長度相同。
輸入數組中的元素均為非負數。
示例 1:
輸入:
gas = [1,2,3,4,5]
cost = [3,4,5,1,2]
輸出: 3
解釋:
從 3 號加油站(索引為 3 處)出發，可獲得 4 升汽油。此時油箱有 = 0 + 4 = 4 升汽油
開往 4 號加油站，此時油箱有 4 - 1 + 5 = 8 升汽油
開往 0 號加油站，此時油箱有 8 - 2 + 1 = 7 升汽油
開往 1 號加油站，此時油箱有 7 - 3 + 2 = 6 升汽油
開往 2 號加油站，此時油箱有 6 - 4 + 3 = 5 升汽油
開往 3 號加油站，你需要消耗 5 升汽油，正好足夠你返回到 3 號加油站。
因此，3 可為起始索引。
示例 2:
輸入:
gas = [2,3,4]
cost = [3,4,3]
輸出: -1
解釋:
你不能從 0 號或 1 號加油站出發，因為沒有足夠的汽油可以讓你行駛到下一個加油站。
我們從 2 號加油站出發，可以獲得 4 升汽油。 此時油箱有 = 0 + 4 = 4 升汽油
開往 0 號加油站，此時油箱有 4 - 3 + 2 = 3 升汽油
開往 1 號加油站，此時油箱有 3 - 3 + 3 = 3 升汽油
你無法返回 2 號加油站，因為返程需要消耗 4 升汽油，但是你的油箱只有 3 升汽油。
因此，無論怎樣，你都不可能繞環路行駛一周。
思路1:暴力解法，兩層循環判斷，第一層選擇初始站點，第二層判斷是不是滿足
時間復雜度 (N^2)
class Solution {
public:
int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
//看輸入數據是否合理，邊界情況判定
if(gas.size()==0||gas.size()!=cost.size())return -1;
//計算消耗的油和能提供的油
int temp1 = accumulate(gas.begin(), gas.end(), 0);
int temp2 = accumulate(cost.begin(), cost.end(), 0);
//若消耗的小於或等於提供的，那么一定有一個起點可以，否則輸出-1
if (temp1 < temp2) return -1;
int l= gas.size();
if (l == 1) return 0;
//初始化，從第一個站點開始遍歷看是否滿足
int start = 0;
int cur = 1;
int oil = gas[0] - cost[0];
//因為已經證明了肯定有一個加油站可以作為起點
//依次遍歷每個加油站，找到滿足條件的那個
while (cur != start&&start<l) {
if (oil >=0) {
oil += gas[cur] - cost[cur];
cur = (cur + 1) % l;
} else {
start++;
cur=start+1;
cur=cur%l;
oil= gas[start] - cost[start];
}
}
return start;
}
};
思路2: 從i到j位置,有 sum(gas) < sum(cost),說明i到不了j,並且i到j之間任何一個位置都到不了j
時間復雜度：O(N) ， 這是因為只有一個遍歷了所有加油站一次的循環。
空間復雜度： O(1) ，因為此算法只使用了常數個變量。
官方解法：
class Solution {
public:
int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
int n = gas.size();
int total_tank = 0;
int curr_tank = 0;
int starting_station = 0;
for (int i = 0; i < n; ++i) {
total_tank += gas[i] - cost[i];
curr_tank += gas[i] - cost[i];
// If one couldn't get here,
if (curr_tank < 0) {
// Pick up the next station as the starting one.
starting_station = i + 1;
// Start with an empty tank.
curr_tank = 0;
}
}
return total_tank >= 0 ? starting_station : -1;
}
};
給定一個以字符串表示的非負整數 num，移除這個數中的 k 位數字，使得剩下的數字最小。
注意:
- num 的長度小於 10002 且 ≥ k。
- num 不會包含任何前導零。
示例 1 :
輸入: num = "1432219", k = 3 輸出: "1219" 解釋: 移除掉三個數字 4, 3, 和 2 形成一個新的最小的數字 1219。
示例 2 :
輸入: num = "10200", k = 1 輸出: "200" 解釋: 移掉首位的 1 剩下的數字為 200. 注意輸出不能有任何前導零。
示例 3 :
輸入: num = "10", k = 2 輸出: "0" 解釋: 從原數字移除所有的數字，剩余為空就是0。
思路：兩個相同位數的數字大小關系取決於第一個不同的數的大小。
遍歷字符串，如果發現前一個數字大於后一個數字，則將前一個數字刪除，使得高位數字盡可能小。
class Solution {
public:
string removeKdigits(string num, int k) {
if (k == num.size())
return "0";
while (k){
int i;
bool flag = false;
//遍歷查找有沒有前一個數大於后一個數的情況
for (i = 0; i < num.size() - 1; i++){
if (num[i] > num[i+1]){
num.erase(num.begin() + i);
flag = true;
k--;
break;
}
}
//遍歷完數組，而沒有刪除元素，說明字符串有序，直接刪除后K個
if (i == num.size() - 1 && !flag){
num.erase(num.end()-k,num.end());
break;
}
}
while (num[0] == '0' && num.size() > 1)
num.erase(num.begin());
if (num.empty())
return "0";
return num;
}
};
316. 去除重復字母
給你一個字符串 s ，請你去除字符串中重復的字母，使得每個字母只出現一次。需保證 返回結果的字典序最小（要求不能打亂其他字符的相對位置）。
注意：該題與 1081 https://leetcode-cn.com/problems/smallest-subsequence-of-distinct-characters 相同
示例 1：
輸入：s = "bcabc"
輸出："abc"
示例 2：
輸入：s = "cbacdcbc"
輸出："acdb"
思路：
貪心思路：如果當前字符的左邊字符比當前字符大，而且左邊字符在當前字符的右邊還會出現，那就先舍棄掉左邊字符。
class Solution {
public:
string res = "0";//先加一個0是為了方便判斷，類似鏈表的啞節點
string removeDuplicateLetters(string s) {
int count[26] = {0};//計數器，記錄每個字母出現的次數
int visited[26] = {0};//用來記錄結果數組里面是否已經包含某個字符，避免重復
for(int i = 0; i < s.size(); ++i) ++count[s[i] - 'a'];
for(const auto &c : s){
--count[c - 'a'];
if(visited[c - 'a'] == 1) continue;//已經包含了
//關鍵代碼：如果當前字符的左邊字符比當前字符大，而且左邊字符在當前字符的右邊還會出現，那就先舍棄掉左邊字符
while(c < res.back() && count[res.back() - 'a']){
visited[res.back() - 'a'] = 0;//pop出去就不再包含了
res.pop_back();
}
res += c;
visited[c - 'a'] = 1;//包含了該字符
}
return res.substr(1);
}
};
不加0其實也差不多：
class Solution {
public:
string res;
string removeDuplicateLetters(string s) {
int count[26] = {0};//計數器，記錄每個字母出現的次數
int visited[26] = {0};//用來記錄結果數組里面是否已經包含某個字符，避免重復
for(int i = 0; i < s.size(); ++i) ++count[s[i] - 'a'];
for(const auto &c : s){
--count[c - 'a'];
if(visited[c - 'a'] == 1) continue;//已經包含了
while(!res.empty() && c < res.back() && count[res.back() - 'a']){
visited[res.back() - 'a'] = 0;//pop出去就不再包含了
res.pop_back();
}
res += c;
visited[c - 'a'] = 1;//包含了該字符
}
return res;
}
};