【算法基础：贪心】6. 贪心

小威W2023-07-30 16:08

文章目录

  • 区间问题
    • [905. 区间选点（排序 + 贪心）](#905. 区间选点（排序 + 贪心）)
    • [908. 最大不相交区间数量（排序 + 贪心）](#908. 最大不相交区间数量（排序 + 贪心）)
    • [906. 区间分组（排序 + 优先队列 + 贪心）⭐](#906. 区间分组（排序 + 优先队列 + 贪心）⭐)
    • [907. 区间覆盖（排序 + 贪心）](#907. 区间覆盖（排序 + 贪心）)
  • Huffman树
    • [148. 合并果子（优先队列 + 贪心）](#148. 合并果子（优先队列 + 贪心）)
  • 排序不等式
    • [913. 排队打水](#913. 排队打水)
  • 绝对值不等式
    • [104. 货仓选址（选中点位置）](#104. 货仓选址（选中点位置）)
  • 推公式
    • [125. 耍杂技的牛⭐⭐⭐](#125. 耍杂技的牛⭐⭐⭐)

区间问题

对于区间问题，通常需要先排序，（一般情况下都是左端点排序）。

相关链接：【算法】区间合并类题目总结

905. 区间选点（排序 + 贪心）

https://www.acwing.com/activity/content/problem/content/1111/

解法可见：【算法】区间合并类题目总结 的问题 ------ 452. 用最少数量的箭引爆气球

可以左边界排序 或 右边界排序。

java 复制代码 
import java.util.*;

public class Main {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[][] r = new int[n][2];
        for (int i = 0; i < n; ++i) {
            r[i][0] = sc.nextInt();
            r[i][1] = sc.nextInt();
        }
        // 按起点升序排序
        Arrays.sort(r, (a, b) -> a[0] - b[0]);
        
        int ans = 0, last = Integer.MIN_VALUE;
        for (int[] cur: r) {
            if (cur[0] <= last) last = Math.min(last, cur[1]);
            else {
                ++ans;
                last = cur[1];
            }
        }
        System.out.println(ans);
    }
}

908. 最大不相交区间数量（排序 + 贪心）

https://www.acwing.com/activity/content/problem/content/1112/

java 复制代码 
import java.io.BufferedInputStream;
import java.io.BufferedWriter;
import java.io.OutputStreamWriter;
import java.util.*;

public class Main {
    public static void main(String[] args){
        Scanner sin = new Scanner(new BufferedInputStream(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        int n = sin.nextInt();
        int[][] r = new int[n][2];
        for (int i = 0; i < n; ++i) {
            r[i][0] = sin.nextInt();
            r[i][1] = sin.nextInt();
        }
        Arrays.sort(r, (a, b) -> a[0] - b[0]);  // 左端点排序
        int ans = 0, last = Integer.MIN_VALUE;
        for (int[] x: r) {
            if (x[0] > last) {
                ++ans;
                last = x[1];
            } else {
                last = Math.min(last, x[1]);
            }
        }
        System.out.println(ans);
    }
}

906. 区间分组（排序 + 优先队列 + 贪心）⭐

https://www.acwing.com/activity/content/problem/content/1113/

贪心思路：

使用优先队列来维护所有组的结束端点位置，这样就可以快速找到当前结束位置最靠前的组。

最后优先队列中有多少元素就表示需要多少组。

java 复制代码 
import java.io.BufferedInputStream;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sin = new Scanner(new BufferedInputStream(System.in));

        int n = sin.nextInt();
        int[][] r = new int[n][2];
        for (int i = 0; i < n; ++i) {
            r[i][0] = sin.nextInt();
            r[i][1] = sin.nextInt();
        }
        Arrays.sort(r, (a, b) -> a[0] - b[0]);  // 左端点排序

        // pq 里存储了各个组的结束位置（从小到大排列）
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        for (int[] x: r) {
            if (!pq.isEmpty() && pq.peek() < x[0]) pq.poll();   // 如果可以加入当前存在的组
            pq.offer(x[1]);
        }
        System.out.println(pq.size());
    }
}

907. 区间覆盖（排序 + 贪心）

https://www.acwing.com/problem/content/description/909/

每次贪心地找出符合左端点 <= start 的区间中右端点最远的那个。

java 复制代码 
import java.io.BufferedInputStream;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sin = new Scanner(new BufferedInputStream(System.in));
        int s = sin.nextInt(), t = sin.nextInt();
        int n = sin.nextInt();
        int[][] r = new int[n][2];
        for (int i = 0; i < n; ++i) {
            r[i][0] = sin.nextInt();
            r[i][1] = sin.nextInt();
        }
        // 左端点升序排序
        Arrays.sort(r, (a, b) -> a[0] - b[0]);

        int ans = 0, last = s - 1;
        for (int i = 0, j; i < n && last < t; ++i) {
            j = i;          // j 从 i 开始枚举
            // 找到左端点<= s的区间中，右端点最大的那个
            while (j < n && r[j][0] <= s) {
                last = Math.max(last, r[j][1]);
                ++j;
            }
            ++ans;
            s = last + 1;   // 更新当前需要的开始端点
            i = Math.max(i, j - 1);
        }
        System.out.println(last >= t? ans: -1);
    }
}

Huffman树

148. 合并果子（优先队列 + 贪心）

https://www.acwing.com/problem/content/150/

贪心得想，每次先合并体力耗费小的。（因为先合并的对答案的贡献次数多）。

java 复制代码 
import java.io.BufferedInputStream;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sin = new Scanner(new BufferedInputStream(System.in));
        int n = sin.nextInt();
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        for (int i = 0; i < n; ++i) pq.offer(sin.nextInt());

        int ans = 0;
        while (pq.size() > 1) {
            int c = pq.poll() + pq.poll();
            pq.offer(c);
            ans += c;
        }
        System.out.println(ans);
    }
}

排序不等式

913. 排队打水

https://www.acwing.com/problem/content/description/915/

先让接的快的人接水。

java 复制代码 
import java.io.BufferedInputStream;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sin = new Scanner(new BufferedInputStream(System.in));
        int n = sin.nextInt();
        long[] times = new long[n];
        for (int i = 0; i < n; ++i) times[i] = sin.nextInt();
        Arrays.sort(times);
        long ans = 0;
        for (int i = 0; i < n; ++i) {
            ans += times[i] * (n - i - 1);
        }
        System.out.println(ans);
    }
}

绝对值不等式

104. 货仓选址（选中点位置）

https://www.acwing.com/problem/content/106/

选择中点位置即可。

具体的操作是找中位数。

java 复制代码 
import java.io.BufferedInputStream;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sin = new Scanner(new BufferedInputStream(System.in));
        int n = sin.nextInt();
        long[] a = new long[n];
        for (int i = 0; i < n; ++i) a[i] = sin.nextLong();
        Arrays.sort(a);
        long pos = a[n / 2], ans = 0;
        for (int i = 0; i < n; ++i) {
            ans += Math.abs(pos - a[i]);
        }
        System.out.println(ans);
    }
}

推公式

125. 耍杂技的牛⭐⭐⭐

https://www.acwing.com/problem/content/127/

结论：按照 wi + si 从小到大的顺序排，最大的危险系数一定是最优的。

如何证明？------ 反证法
看 i 和 i + 1 交换位置之后会发生什么。

java 复制代码 
import java.io.BufferedInputStream;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sin = new Scanner(new BufferedInputStream(System.in));
        int n = sin.nextInt();
        int[][] cows = new int[n][2];
        for (int i = 0; i < n; ++i) {
            int w = sin.nextInt(), s = sin.nextInt();
            cows[i][0] = w + s;
            cows[i][1] = w;
        }
        Arrays.sort(cows, (a, b) -> a[0] - b[0]);

        int ans = 0, sum = 0;
        for (int i = 0; i < n; ++i) {
            int s = cows[i][0] - cows[i][1], w = cows[i][1];
            ans = Math.max(ans, sum - s);
            sum += w;
        }
        System.out.println(ans);
    }
}
相关推荐
YuTaoShao2 分钟前
【LeetCode 热题 100】142. 环形链表 II——快慢指针
java·算法·leetcode·链表
CCF_NOI.10 分钟前
（普及−）B3629 吃冰棍——二分/模拟
数据结构·c++·算法
找不到、了1 小时前
分布式理论：CAP、Base理论
java·分布式
天天摸鱼的java工程师1 小时前
2025已过半，Java就业大环境究竟咋样了？
java·后端
运器1231 小时前
【一起来学AI大模型】支持向量机（SVM）：核心算法深度解析
大数据·人工智能·算法·机器学习·支持向量机·ai·ai编程
人生在勤，不索何获-白大侠1 小时前
day16——Java集合进阶（Collection、List、Set）
java·开发语言
Zedthm1 小时前
LeetCode1004. 最大连续1的个数 III
java·算法·leetcode
艺杯羹1 小时前
MyBatis之核心对象与工作流程及SqlSession操作
java·mybatis
神的孩子都在歌唱1 小时前
3423. 循环数组中相邻元素的最大差值 — day97
java·数据结构·算法
YuTaoShao1 小时前
【LeetCode 热题 100】73. 矩阵置零——（解法一）空间复杂度 O(M + N)
算法·leetcode·矩阵
热门推荐
01集群聊天服务器---MySQL数据库的建立02Java学习第十五部分——MyBatis03Coze扣子平台完整体验和实践（附国内和国际版对比）04《深入设计模式》模式结构汇总05使用Ruby接入实时行情API教程06扣子（coze）实战|我用扣子搭建了一个自动分析小红薯笔记内容的AI应用|详细步骤拆解07基于odoo17的设计模式详解---单例模式08基于odoo17的设计模式详解---装饰模式09DeepSeek各版本说明与优缺点分析10Java类变量（静态变量）