算法-贪心算法思想

Posted 2021-10-09 渣渣辉

贪心算法

是什么

1. 期盼通过每个阶段的局部最优选择，从而达到全局的最优
2. 结果并不一定是最优

leetcode

455

思路

1. 对饼干数组和胃口数组升序排序
2. 遍历饼干数组，找到能满足第一个孩子的饼干

3. 然后继续遍历饼干数组，找到满足第二，三...孩子的饼干

   代码

   // g:孩子
   // s:饼干
   var findContentChildren = function(g, s) {
     var funcSort = function(a,b){
    return a-b
     }
     g.sort(funcSort)
     s.sort(funcSort)
     let i =0; //代表第1个孩子
     s.forEach(n => {
    if(n >= g[i]){ 代表第i个孩子
      i++
    }
     })
     return i;
   };

复杂度分析

1. 时间复杂度：O(mlogm + nlogn)O(mlogm+nlogn)，其中 mm 和 nn 分别是数组 gg 和 ss 的长度。对两个数组排序的时间复杂度是 O(mlogm + nlogn)O(mlogm+nlogn)，遍历数组的时间复杂度是 O(m+n)O(m+n)，因此总时间复杂度是 O(mlogm + nlogn)O(mlogm+nlogn)。
2. 空间复杂度：O(log m + log n)O(logm+logn)，其中 mm 和 nn 分别是数组 gg 和 ss 的长度。空间复杂度主要是排序的额外空间开销。

122

思路

1. 新建一个变量，用来统计总利润
2. 遍历价格数组，如果当前价格比昨天高，就在昨天买，今天卖，否则就不交易
3. 遍历结束后，返回所有利润之和

代码

var maxProfit = function(prices) {
  let priceO = 0;
  for(let i =1;i<prices.length;i++){
    if(prices[i] > prices[i-1]){
      priceO += prices[i]-prices[i-1]
    }
  }
  return priceO
};

例子 [1,2,3,4,5]，数组的长度 n=5，由于对所有的i < n1≤i<n 都有 a[i]>a[i-1]，因此答案为
(2-1)+(3-2)+(4-3)+(5-4) = (5-1)

但是实际的交易过程并不是进行 4 次买入和 4 次卖出，而是在第 1 天买入，第 5 天卖出

复杂度分析

• 时间复杂度：O(n)，其中 n 为数组的长度。我们只需要遍历一次数组即可。
• 空间复杂度：O(1)。只需要常数空间存放若干变量。

56 合并区间

问题

以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间。

 

示例 1：
输入：intervals = [[1,3],[2,6],[8,10],[15,18]] 输出：[[1,6],[8,10],[15,18]] 解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6]. 

示例 2：

输入：intervals = [[1,4],[4,5]] 输出：[[1,5]] 解释：区间 [1,4] 和 [4,5] 可被视为重叠区间。

思路

并区间后左边界和右边界，作为一个新的区间，加入到result数组里就可以了。如果没有合并就把原区间加入到result数组。

代码

        function merge(intervals) {
            const res = []
            intervals.sort((a, b) => a[0] - b[0])
            let prev = intervals[0]
            for (let i = 0; i < intervals.length; i++) {
                let cur = intervals[i]
                if (cur[0] > prev[1]) {
                    res.push(prev)
                    prev = cur
                } else {
                    prev[1] = Math.max(cur[1], prev[1])
                }
            }
            res.push(prev)
            return res;
        }

示例详解

        intervals = [[1, 3], [2, 6], [8, 10], [15, 18]];
        prev = [1, 3]
        cur[0] = 2, prev[1] = 6 //[1, 3], [2, 6]能连起来
        则走:prev[1] = Math.max(cur[1], prev[1])
        prev = [1,6]
        for循环走到一下层
        cur[0] = 8, prev[1] = 6 //[2, 6], [8, 10]连不起来
        则走:res.push(prev) prev = cur
        res= [[1,6]] prev = [8,10]
        for循环走到一下层

        intervals = [[1, 4], [4, 5]]
        prev = [1,4]
        cur[0] = 4, prev[1] = 4 //[1, 4], [4, 5]能连起来
        则走:prev[1] = Math.max(cur[1], prev[1])
        prev = [1,5]
        for循环走到一下层