2021-06-29-贪心算法相关题型汇总

贪心算法

贪心算法的解释就是局部最优，进而全局最优，说白了，使用一种方法达到局部最优，然后接着使用这种方法到全局。
贪心常见的题型是两种：分配和区间
区间问题如：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();
    }