Greedy on Hang Zhang

Transform Array to All Equal Elements

Wed, 11 Jun 2025 00:00:00 +0000

3576. 数组元素相等转换

算法

每次操作可以翻转一对相邻元素的符号
为使所有元素相等，最终需要所有元素都是 1 或 -1
从左往右遍历数组，维护一个全局的乘积影响变量 mul（表示前面的操作对当前元素造成的正负反转）
遇到第 i 个元素与目标不符时（考虑乘积影响），对 i + 1 执行一次操作（乘以 -1）
统计所需的操作次数，若超过 k 或无法继续（要翻转的下一个元素不存在），则返回 false

复杂度分析

时间复杂度：O(n)
空间复杂度：O(1)

C++ 代码

class Solution {
public:
    // 尝试将所有元素变为 target（1 或 -1）
    bool checkTransform(std::vector<int>& nums, int k, int target) {
        int mul = 1;  // 表示之前操作对当前位置的影响（1为不变，-1为取反）
        for (int i = 0; i < nums.size(); ++ i) {
            if (nums[i] * mul == target) {
                mul = 1;  // 当前符合目标，不需要额外操作
                continue;
            }
            if (k == 0 || i == nums.size() - 1) {
                return false;  // 无法再操作，失败
            }
            -- k;       // 执行一次操作
            mul = -1;  // 接下来的元素将受到影响
        }
        return true;
    }

    bool canMakeEqual(vector<int>& nums, int k) {
        // 尝试变成全为 1 或全为 -1，两种都尝试
        return checkTransform(nums, k, 1) || checkTransform(nums, k, -1);
    }
};

Python 代码

class Solution:
    def checkTransform(self, nums, k, target):
        mul = 1
        for i in range(len(nums)):
            if nums[i] * mul == target:
                mul = 1
                continue
            if k == 0 or i == len(nums) - 1:
                return False
            k -= 1
            mul = -1
        return True

    def canMakeEqual(self, nums, k):
        return self.checkTransform(nums, k, 1) or self.checkTransform(nums, k, -1)

Go 代码

func checkTransform(nums []int, k int, target int) bool {
    mul := 1
    for i := 0; i < len(nums); i ++ {
        if nums[i] * mul == target {
            mul = 1
            continue
        }
        if k == 0 || i == len(nums) - 1 {
            return false
        }
        k --
        mul = -1
    }
    return true
}

func canMakeEqual(nums []int, k int) bool {
    return checkTransform(nums, k, 1) || checkTransform(nums, k, -1)
}

JavaScript 代码

var canMakeEqual = function (nums, k) {
  function checkTransform(nums, k, target) {
    let mul = 1;
    for (let i = 0; i < nums.length; ++i) {
      if (nums[i] * mul == target) {
        mul = 1;
        continue;
      }
      if (k == 0 || i == nums.length - 1) {
        return false;
      }
      k--;
      mul = -1;
    }
    return true;
  }

  return checkTransform(nums, k, 1) || checkTransform(nums, k, -1);
};

Minimum Subsequence in Non Increasing Order

Sat, 26 Apr 2025 00:00:00 +0000

1403. 非递增顺序的最小子序列

分析

元素大的更容易让子序列之和更快超过剩余元素之和，将数组降序排序
贪心策略：从大到小依次取元素，直到当前子序列的和严格超过剩余元素的和
由于优先取大的元素，自然能保证子序列长度最小、元素和最大，且结果是非递增排序的

时间复杂度

时间复杂度 O(nlogn)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    vector<int> minSubsequence(vector<int>& nums)
    {
        std::vector<int> res;
        std::sort(nums.begin(), nums.end(), std::greater()); // 1. 降序排序

        int sum = 0;
        for (int x : nums)
            sum += x; // 2. 计算总和

        int cur = 0;
        for (int x : nums)
        {
            cur += x;             // 当前子序列的和
            res.push_back(x);      // 加入子序列
            if (cur + cur > sum)   // 当前子序列和 > 剩余元素和
                break;
        }
        return res;
    }
};

Monotone Increasing Digits

Sat, 26 Apr 2025 00:00:00 +0000

738. 单调递增的数字

分析

将 n 转换为字符串 s
找到 第一个下降的位置，即前一位大于后一位
为了让整体数值最大:
- 将下降点前一个位置的数减 1
  - 注意：如果前面有连续相同的数字，需要往前找到第一个不同的数字再减 1
- 后面的所有位数填成 '9'

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度 O(n)

C++代码

class Solution
{
public:
    int monotoneIncreasingDigits(int n)
    {
        std::string s = std::to_string(n);
        int k = 0;

        // 先找到第一个下降的位置
        while (k + 1 < s.size() && s[k] <= s[k + 1])
            ++ k;

        // 如果本身已经是单调递增，直接返回 n
        if (k == s.size() - 1)
            return n;

        // 否则，需要回退到第一个不同的位置
        while (k && s[k] == s[k - 1])
            -- k;

        // 将第 k 位减 1
        s[k] -= 1;

        // 将 k+1 及之后的位置全部置为 '9'
        for (int i = k + 1; i < s.size(); ++ i)
            s[i] = '9';

        return std::stoi(s);
    }
};

IPO

Tue, 25 Feb 2025 00:00:00 +0000

502.IPO

分析

项目排序
- 将每个项目的启动资本和利润配对，并按照启动资本排序
动态选择
- 将当前资本 w 可以启动的所有项目的利润放入最大堆
- 从堆中选择一个利润最大的项目并完成，更新当前资本
退出条件
- 如果没有可以选择的项目（即堆为空），或者已经完成了 k 个项目，就可以退出

时间复杂度

排序项目数组：O(nlogn)
每次操作通过堆插入或弹出元素，最多需要 O(logn) 时间，因此 k 次操作的复杂度是 O(klogn)

总时间复杂度 O(nlogn)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    int findMaximizedCapital(int k, int w, vector<int>& profits, vector<int>& capital)
    {
        int n = profits.size();
        std::vector<std::pair<int, int>> projects;

        // 将项目的启动资本和利润配对，并按启动资本排序
        for (int i = 0; i < n; ++i)
            projects.push_back({capital[i], profits[i]});
        std::sort(projects.begin(), projects.end());

        // 最大堆，用来存放前资本 w 可以启动的所有项目的利润
        std::priority_queue<int> heap;
        int i = 0;

        // 完成最多 k 个项目
        while (k--)
        {
            // 将所有可以启动的项目的利润加入堆
            while (i < n && projects[i].first <= w)
                heap.push(projects[i++].second);

            // 如果堆为空，表示没有可用的项目，退出
            if (heap.empty())
                break;

            // 从堆中选择利润最大的项目并完成
            w += heap.top();
            heap.pop();
        }

        return w;
    }
};

Text Justification

Sun, 12 Jan 2025 00:00:00 +0000

68. 文本左右对齐

分析

分组单词（贪心）：
- 用指针 i 表示当前行的起始单词，j 表示下一个单词
- 不断尝试加入下一个单词，直到超出 maxWidth
构建每一行：
- 左对齐（最后一行或只有一个单词）：单词之间加 1 个空格，末尾补空格
- 普通行：
  - 空格平均分配：空格总数 = maxWidth - 总单词长度
  - 多余空格优先分配到左侧。
  - 使用 std::string(n, ' ') 插入空格
更新索引：处理完当前行后，将 i 移动到下一行的起始单词

时间复杂度

遍历所有单词，每个单词最多被遍历两次（分组和拼接），时间复杂度 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    vector<string> fullJustify(vector<string>& words, int maxWidth)
    {
        std::vector<std::string> res;  // 存储结果
        for (int i = 0; i < words.size(); ++i)
        {
            int j = i + 1;  // 下一个单词的索引
            int len = words[i].size();  // 当前行的总长度

            // 将尽可能多的单词放入当前行
            while (j < words.size() && len + 1 + words[j].size() <= maxWidth)
            {
                len += 1 + words[j].size();  // 单词加空格
                ++j;
            }

            std::string line;  // 构建当前行内容

            // 情况1：最后一行或当前行只有一个单词，左对齐
            if (j == i + 1 || j == words.size())
            {
                line += words[i];  // 加入第一个单词
                for (int k = i + 1; k < j; ++k)  // 后续单词前加空格
                    line += ' ' + words[k];

                // 补齐剩余空格
                while (line.size() < maxWidth)
                    line += ' ';
            }
            else
            {
                // 情况2：普通行（多单词，需均匀分配空格）
                int count = j - i - 1;  // 单词间隔数
                int space = maxWidth - len + count;  // 总空格数

                line += words[i];  // 加入第一个单词
                int k = 0;

                // 多余空格优先分配到左侧
                while (k < (space % count))
                {
                    line += std::string(space / count + 1, ' ') + words[i + k + 1];
                    ++k;
                }

                // 均匀分配剩余空格
                while (k < count)
                {
                    line += std::string(space / count, ' ') + words[i + k + 1];
                    ++k;
                }
            }

            res.push_back(line);  // 保存当前行
            i = j - 1;  // 更新索引，处理下一行
        }

        return res;
    }
};

Candy

Sat, 11 Jan 2025 00:00:00 +0000

135. 分发糖果

分析

递归+记忆化搜索：
- 使用一个数组 candy 记录每个孩子应该分到的糖果数，初始值全为 1
- 对于每个孩子，递归判断左右相邻的孩子评分关系，更新糖果数量。
记忆化优化：
- 如果某个孩子的糖果数已计算过 candy[i] != 1，直接返回，避免重复计算
左右两侧递归更新：
- 如果左边孩子评分比当前孩子低，则当前孩子糖果数应该比左边多 1
- 如果右边孩子评分比当前孩子低，则当前孩子糖果数应该比右边多 1
累加结果：
- 遍历所有孩子，将糖果总数累加得到最少糖果数

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    int candy(vector<int>& ratings)
    {
        int n = ratings.size();
        std::vector<int> candy(n, 1);  // 初始化每个孩子分 1 个糖果

        int res = 0;
        for (int i = 0; i < n; ++i)
            res += minCandy(ratings, candy, i);  // 递归更新糖果数

        return res;  // 返回总糖果数
    }

    // 递归函数：计算第 child 个孩子最少需要的糖果数
    int minCandy(std::vector<int>& ratings, std::vector<int>& candy, int child)
    {
        if (candy[child] != 1)  // 如果已计算过，直接返回
            return candy[child];

        // 左边孩子评分更低，当前孩子糖果+1
        if (child > 0 && ratings[child - 1] < ratings[child])
            candy[child] = std::max(candy[child], minCandy(ratings, candy, child - 1) + 1);

        // 右边孩子评分更低，当前孩子糖果+1
        if (child + 1 < ratings.size() && ratings[child] > ratings[child + 1])
            candy[child] = std::max(candy[child], minCandy(ratings, candy, child + 1) + 1);

        return candy[child];  // 返回计算结果
    }
};

Gas Station

Sat, 11 Jan 2025 00:00:00 +0000

134. 加油站

分析

模拟遍历：
- 从每个加油站 i 出发，模拟一圈是否能顺利到达终点
剩余油量判断：
- 每经过一个加油站，更新剩余油量 oil = oil + gas[k] - cost[k]
- 如果油量不足 oil < 0，说明从当前起点 i 无法完成一圈
跳过不可行区间：
- 如果从 i 出发失败，则从 i + step + 1 开始继续尝试，因为 i 到 i + step 之间的起点也无法成功
终止条件：
- 如果某次尝试走满了 n 步（即 step == n），说明该起点 i 能绕一圈，返回 i
- 如果所有加油站都尝试失败，则返回 -1

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost)
    {
        int n = gas.size(), step = 0;  // n 为加油站数量

        for (int i = 0; i < n;)  // 遍历每个加油站作为起点
        {
            int oil = 0;  // 当前剩余油量
            for (step = 0; step < n; ++step)
            {
                int k = (i + step) % n;  // 环形遍历加油站
                oil += gas[k] - cost[k];  // 更新剩余油量

                if (oil < 0)  // 如果油量不足，停止尝试
                    break;
            }

            if (step == n)  // 成功绕一圈
                return i;

            i = i + step + 1;  // 跳过失败区间，尝试下一个起点
        }

        return -1;  // 没有找到可行解
    }
};

Best Time to Buy and Sell Stock II

Fri, 10 Jan 2025 00:00:00 +0000

122. 买卖股票的最佳时机II

分析

如果今天的股票价格比昨天高，就可以将这部分差价计入利润。这样相当于在每个上升区间都进行买入和卖出操作。将所有上涨的差价累加，即可获得最大利润

为什么这样是最优的？

股票可以在同一天买入和卖出，相当于在每个上涨区间及时买卖。
比如：[1, 2, 3, 4, 5]，买入 1 卖出 5 的利润和每天买卖 (1→2，2→3，3→4，4→5) 是相等的

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    int maxProfit(vector<int>& prices)
    {
        int res = 0;  // 初始化总利润
        for (int i = 1; i < prices.size(); ++i)  // 遍历价格数组
            if (prices[i] > prices[i - 1])  // 如果今天比昨天贵
                res += prices[i] - prices[i - 1];  // 累加差价利润
        return res;  // 返回总利润
    }
};

Minimum Number Of Arrows To Burst Balloons

Thu, 09 Jan 2025 00:00:00 +0000

452. 用最少数量的箭引爆气球

算法

要保证最少的弓箭数，我们可以采用如下贪心策略：
- 按区间的结束点升序排序：优先处理结束点较小的区间，这样可以最大化覆盖更多的区间
- 每次发射箭时，记录当前箭能够覆盖的结束点 r 。如果后续某个气球的开始点 x_start 大于当前箭的覆盖范围 r，则需要发射一支新的箭

将所有气球的直径区间按照结束点升序排序
初始化箭的数量 res 为 1，并将第一支箭的覆盖范围设为第一个区间的结束点
遍历排序后的区间：
- 如果当前区间的开始点大于箭的覆盖范围，说明需要一支新的箭来覆盖当前气球
- 更新箭的覆盖范围为当前区间的结束点

复杂度分析

排序的时间复杂度为 O(nlogn)，其中 n 是气球的数量；遍历区间的复杂度为 O(n)；总时间复杂度为 O(nlogn)
空间复杂度为 O(1)

C++ 代码

class Solution
{
public:
    int findMinArrowShots(vector<vector<int>>& points)
    {
        // 如果没有气球，返回 0
        if (points.empty())
            return 0;

        // 按区间结束点升序排序
        std::sort(points.begin(), points.end(), [](std::vector<int> a, std::vector<int> b) {
            return a[1] < b[1];
        });

        // 初始化箭的数量和当前箭的覆盖范围
        int res = 1; // 至少需要一支箭
        int r = points[0][1]; // 第一支箭的覆盖范围

        // 遍历剩余的区间
        for (int i = 1; i < points.size(); ++i)
        {
            // 如果当前区间的起始点在当前箭的覆盖范围之外
            if (r < points[i][0])
            {
                ++res; // 增加一支箭
                r = points[i][1]; // 更新箭的覆盖范围
            }
        }

        return res;
    }
};

Python 代码

class Solution:
    def findMinArrowShots(self, points: List[List[int]]) -> int:
      points.sort(key = lambda point: point[1])
      res, r = 1, points[0][1]
      for i in range(1, len(points)):
        if r < points[i][0]:
          r = points[i][1]
          res += 1
      return res

Go 代码

import "sort"

func findMinArrowShots(points [][]int) int {
  sort.Slice(points, func(i, j int) bool {
    return points[i][1] < points[j][1]
  })
  res, r := 1, points[0][1]
  for i := 1; i < len(points); i += 1 {
    if r < points[i][0] {
      r = points[i][1]
      res += 1
    }
  }
  return res
}

Non Overlapping Intervals

Thu, 09 Jan 2025 00:00:00 +0000

435. 无重叠区间

分析

要保证最多的不重叠区间数，可以采用如下贪心策略：
- 按区间的结束点升序排序：结束点越早，剩余空间越多，更容易为后续区间预留空间
- 遍历排序后的区间，选择与前一个区间不重叠的区间，将其加入到保留的集合中

先按结束点排序。
初始化计数变量 count，记录当前不wq重叠区间的数量，初始值为 1
遍历排序后的区间：
- 如果当前区间的起始点 start 不小于上一个保留区间的结束点 cur，说明它与前面的区间不重叠，更新 cur 并增加计数
最后，用总区间数减去 count 即为需要移除的区间数

时间复杂度

排序的时间复杂度为 O(nlogn) ，其中 n 是区间的数量
遍历区间的复杂度为 O(n)

总时间复杂度为 O(nlogn)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    int eraseOverlapIntervals(vector<vector<int>>& intervals)
    {
        // 如果没有区间，直接返回 0
        if (intervals.empty())
            return 0;

        // 按区间的结束点升序排序
        std::sort(intervals.begin(), intervals.end(), [](std::vector<int> a, std::vector<int> b) {
            return a[1] < b[1];
        });

        // 初始化计数器和当前区间结束点
        int count = 1; // 至少有一个区间不重叠
        int cur = intervals[0][1];

        // 遍历剩余的区间
        for (int i = 1; i < intervals.size(); ++i)
        {
            // 如果当前区间不重叠，则更新结束点并增加计数
            if (cur <= intervals[i][0])
            {
                ++count;
                cur = intervals[i][1];
            }
        }

        // 总区间数 - 不重叠区间数 = 需要移除的区间数
        return intervals.size() - count;
    }
};