贪心算法
贪心算法
贪心算法的解释就是局部最优,进而全局最优,说白了,使用一种方法达到局部最优,然后接着使用这种方法到全局。
贪心常见的题型是两种:分配和区间
区间问题如:376、655、435、452、763
分配问题如:455、股票买卖相关题型
贪心算法相关题型
LeetCode 376 摆动序列
- 题目:上 下 交替出现的次数
- 思路:双指针法,up=down+1,down=up+1
- 代码:
public int wiggleMaxLength(int[] nums) {
int up =1;
int down =1;
for (int i = 1; i < nums.length; i++) {
if (nums[i]==nums[i-1])
continue;
if (nums[i]>nums[i-1]){
up =down+1;
}else {
down=up+1;
}
}
return Math.max(up,down);
};
LeetCode 665 非递减数列
- 题目:非递减数列
- 思路:保证后一个数大于等于前一个数,当出现后一个数小于前一个数的时候就需要判断了,不能直接让后一个数等于前一个数,可以参考例子(2 4 3 4)。需要判断前一个数的前一个数,和后一个数的比较。这个看代码吧,一看就明白
- 代码:
public boolean checkPossibility(int[] nums) {
int cnt =0;
for (int i = 1; i < nums.length ; i++) {
if (nums[i]>=nums[i-1])
continue;
if (i-2>=0&&nums[i-2]>nums[i]){//这是最核心的
nums[i]=nums[i-1];
}else {
nums[i-1]=nums[i];
}
cnt++;
}
return cnt<=1;
}
LeetCode 435 不重叠的区间个数
- 不重叠的区间个数
- 思路:二维数组的排序,按照区间的最后一个排序。然后去遍历求最长的不重叠区间数,可以参考LeetCode 646 最长数对链
- 代码:
public int eraseOverlapIntervals(int[][] intervals) {
Arrays.sort(intervals, new Comparator<int[]>() {
@Override
public int compare(int[] o1, int[] o2) {
return o1[1]-o2[1];
}
});
int m=intervals.length;
int cnt =1;
int end =intervals[0][1];
for (int i = 1; i < m; i++) {
if (intervals[i][0]>=end){
cnt++;
end=intervals[i][1];
}
}
return intervals.length-cnt;
}
LeetCode 455 分饼干
略
LeetCode 452 投飞镖刺破气球
- 题目:求重合的区间数
- 思路:二维数组的排序,按照区间的后一个排序,求最长的不重叠区间。
LeetCode 121 股票买卖
略,双指针。
LeetCode 122 股票买卖II
略:累加法即可
LeetCode 605 种植花朵
- 题目:种下花的条件是,当前值为0 且前一个和后一个都为0,注意边界问题
- 思路:双指针的方法,注意边界问题。易错点在于,种上花了以后,需要置为1。
- 代码:
public boolean canPlaceFlowers(int[] flowerbed, int n) {
if (flowerbed==null||flowerbed.length==0)
return false;
int cnt=0;
int len=flowerbed.length;
for(int i=0;i<len&&cnt<n;i++){
if (flowerbed[i]==1)
continue;
int pre=i==0?0:flowerbed[i-1];
int next=i==len-1?0:flowerbed[i+1];
if (pre == 0 && next == 0) {
cnt++;
flowerbed[i] = 1;
}
}
return cnt>=n;
}
LeetCode 763 分隔字符串使同种字符出现在一起
- 题目:重合区间的个数
- 思路:双指针+滑动窗口(集合)。数组去定位字符出现的最后一个位置。然后去遍历
- 代码:
public List<Integer> partitionLabels(String S) {
int len =S.length();
List<Integer> list = new ArrayList<>();
if (S==null)
return list;
int[] lastIndexChar = new int[26];
for (int i = 0; i < len ; i++) {
lastIndexChar[S.charAt(i)-'a']=i;
}
int firstIndex =0;
int lastIndex=0;
while (firstIndex<len){
lastIndex=firstIndex;
for (int i = firstIndex; i <len&&i<=lastIndex ; i++) {
int index=lastIndexChar[S.charAt(i)-'a'];
if (index>lastIndex){
lastIndex=index;
}
}
list.add(lastIndex-firstIndex+1);
firstIndex=lastIndex+1;
}
return list;
}
LeetCode 646 最长数对链
- 题目:最多的不连续区间
- 思路:二维数组的排序,按照区间第一个排序,还是按照区间最后一个排序呢?如果按照区间第一个排序,那么排序出的序列,可以合并区间使用。如果按照最后一个排序,那么可以比较第一个最前一个区间的最后一个,就可以得出不连续的区间。
- 代码:
public int findLongestChain(int[][] pairs) {
if (pairs==null)
return 0;
Arrays.sort(pairs, new Comparator<int[]>() {
@Override
public int compare(int[] o1, int[] o2) {
return o1[1]-o2[1];
}
});
int m=pairs.length;
int cnt =1;
int end =pairs[0][1];
for (int i = 1; i < m ; i++) {
if (pairs[i][0]>end){
end=pairs[i][1];
cnt++;
}
}
return cnt;
}
LeetCode 316 去除重复字母
- 题目: 去除字符串中重复的字母,同时保持去重后是字典序
- 思路:两个数组,一个用来表明当前元素是否已经加入去重后的字符,另外一个用来表示当前元素的数量。巧妙的来了,每当加入一个新元素的时候,首先在去重后的字符串的最后一位是否大于当前元素,如果大于,然后判断最后一位是否是否还有重复,如果有重复则将最后一位删除,循环。直到可以加入当前元素。思路属于单调栈。
- 代码:
public String removeDuplicateLetters(String s) {
//表示某个字符是否已经收入囊中
boolean[] via =new boolean[26];
//每个字符出现的次数
int[] num = new int[26];
for (int i = 0; i < s.length(); i++) {
num[s.charAt(i)-'a']++;
}
StringBuffer sb =new StringBuffer();
for (int i = 0; i < s.length() ; i++) {
char ch =s.charAt(i);
//判断这个元素是否收入sb
if (!via[ch-'a']){
//如果没有
//则取sb的最后一位和当前元素比大小,如果大于一直循环
while (sb.length()>0&&sb.charAt(sb.length()-1)>ch){
//判断sb中最后一个元素是否存在重复,重复则删除当前sb,同时via置位false。这里要理解何时减去‘a’
if (num[sb.charAt(sb.length()-1)-'a']>0){
via[sb.charAt(sb.length()-1)-'a']=false;
sb.deleteCharAt(sb.length()-1);
}else {
//如果sb中最后一个元素不存在重复,直接跳出循环
break;
}
}
//将当前元素收入囊中,via置位true
sb.append(ch);
via[ch-'a']=true;
}
num[ch-'a']--;
}
return sb.toString();
}