贪心算法概述
活动安排问题
- 问题描述：
- 设有
n个活动的集合E={1,2,…,n}，其中，每个活动都要求使用同一资源，如演讲会场等，而在同一时间内只有一个活动能使用这一资源。 - 每个活动
i都有一个要求使用该资源的起始时间si和一个结束时间fi，且si<fi。如果选择了活动i，则它在半开区间[si, fi)内占用资源。 - 若区间[si, fi)与区间[sj, fj)不相交，则称活动i与活动j是相容的。
即：当si≥fj或sj≥fi时，活动i与活动j相容。 - 活动安排问题：在所给的活动集合中选出最大的相容活动子集。
- 解决思路：
- 按结束时间的非减序对活动进行排列
- 选择一个结束时间最早的活动
- 依次检查后续活动是否与当前已选择的所有活动相容，若相容则将该活动加入已选择活动集合中，再继续检查下一活动，否则直接检查下一活动
- 直到所有活动全部检查完毕
- 代码实现思路：
- 给所有活动按照结束时间升序排列。
- 排在第一个的活动安排在内，以第一个为基准，然后往后找后面活动开始时间大于上一个活动结束时间，安排进来…
- 代码实现：
public class Main2 {
//测试
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while (true){
int n = scanner.nextInt();
//输入0 结束测试
if (n == 0){
break;
}else {
//输入 n 个节目的 开始时间 和 结束时间
Program[] programs = new Program[n];
for (int i = 0; i < n; i++) {
programs[i] = new Program();
programs[i].start = scanner.nextInt();
programs[i].end = scanner.nextInt();
}
System.out.println(activity(n, programs));
}
}
}
public static int activity(int n,Program[] programs){
//结束时间排序
for (int i = 0; i < n; i++) {
int min = programs[i].end;
int index = i;
for (int j = i+1; j < n; j++) {
if (programs[j].end < min){
min = programs[j].end;
index = j;
}
}
swap(programs,i,index);
}
// 以第1个节目开始，sum为计算，最多可以看几个节目
int sum = 1;
//下标：第1个节目开始，下标为0 ，记录安排进来的节目下标
int m = 0;
for (int i = 1; i < n; i++) {
//后面的节目 开始时间 大于 上一个安排节目的结束时间 ，安排进来
if (programs[i].start >= programs[m].end){
sum++;
m = i;
}
}
return sum;
}
/**
* 交换
* @param programs
* @param i,j
*/
public static void swap(Program[] programs,int i,int j){
Program p = programs[i];
programs[i] = programs[j];
programs[j] = p;
}
}
class Program{
int start;
int end;
}
最优装载
- 问题描述
- 有一批集装箱要装上一艘载重量为
c的轮船，其中集装箱i的重量为wi。 - 最优装载问题要求在装载体积不受限制的情况下，将尽可能多的集装箱装上轮船。
- 变量
xi=0表示不装入集装箱i，xi=1表示装入集装箱i
- 贪心策略：采用重量最轻者先装的贪心选择策略，可产生最优装载问题的最优解。
- 每次选择时，从剩下的集装箱中，选择重量最小的集装箱
- 可以保证已经选出来的集装箱总重量最小，装载的集装箱数量最多，直到轮船不能再继续装载为止
- 步骤：排序==》装载
- 代码实现：
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
//多组测试：
while(scanner.hasNextInt()){
//集装箱的种类
int n = scanner.nextInt();
//船能装载的重量
int c = scanner.nextInt();
// map集合中存放集装箱 编号和重量
HashMap<String, Integer> maps = new HashMap<>();
for (int i = 0; i < n; i++) {
String id = scanner.next();
int w = scanner.nextInt();
maps.put(id,w);
}
List<String> load = load(c, maps);
//输出船的装载数量
System.out.println(load.size());
//输出集装箱装载的顺序
for (String integer : load) {
System.out.print(integer+" ");
}
System.out.println();
}
}
/**
*
* @param c 船装载的重量
* @param maps 每个集装箱对应的编号及其重量
* @return list集合，船最多装载的集装箱编号
*/
public static List<String> load(int c, Map<String,Integer> maps){
//Map集合根据value排序
ArrayList<Map.Entry<String, Integer>> list = new ArrayList<>(maps.entrySet());
Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {
@Override
public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
//升序排列
return o1.getValue() - o2.getValue();
}
});
ArrayList<String> arrayList = new ArrayList<>();
//遍历排好序的Map集合
Iterator<Map.Entry<String, Integer>> iterator = list.iterator();
while (iterator.hasNext()){
Map.Entry<String, Integer> entry = iterator.next();
if (entry.getValue() <= c){
c -= entry.getValue();
arrayList.add(entry.getKey());
}else {
break;
}
}
return arrayList;
}
}
- 除了用Map集合，还可以定义一个集装箱的类，保存编号和重量两个属性。
Prim算法
-
Prim算法是用来解决最小生成树Minimal Spanning Trees (MST)问题
-
任何只由图G的边构成，并包含G的所有顶点的树称为G的生成树
-
加权无向图G的生成树的权重是该生成树的所有边的权重之和
-
最小生成树是其所有生成树中权重最小的生成树
-
N个顶点，选取N-1条边，构建一个连通图，且这N-1条边的权重之和最小
-
实例演示Prim算法构造最小生成树：
-
实现思路：
(1) 任意选定一点s，设集合S={s}
(2) 从不在集合S的点中选出一个点j使得其与S内的某点i的距离最短，则(i，j)就是生成树上的一条边，同时将j点加入S
(3) 转到(2)继续进行，直至所有点都己加入S集合 -
代码实现：
public class Prim {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = 7;
int[][] g = new int[7][7];
//初始 默认无穷远
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
g[i][j] = 1000;
}
}
while (scanner.hasNextInt()){
int i = scanner.nextInt();
int j = scanner.nextInt();
int w = scanner.nextInt();
g[i][j] = w;
}
prim(n,g);
}
/**
*
* @param n 点数
* @param g 存储图
*/
public static void prim(int n,int[][] g){
//记录不在S中的顶点在S中的最近邻接点
int[] closeset = new int[n];
//记录不在S中的顶点到S的最短距离，即到最近邻接点的权值
int[] lowcost = new int[n];
//标记顶点是否被访问，访问过的顶点标记为1
int[] used = new int[n];
//初始化上面3个数组
for (int i = 0; i < n; i++) {
//初始化，S中只有第1个点(0)
// 获取其他顶点到第1个点(0)的距离，不直接相邻的顶点距离为无穷大
lowcost[i] = g[0][i];
//初始情况下所有点的最近邻接点都为第1个点(0)
closeset[i] = 0;
//初始情况下所有点都没有被访问过
used[i] = 0;
}
//访问第1个点(0)，将第1个点加到S中
used[0] = 1;
//每一次循环找出一个到S距离最近的顶点
for (int i = 1; i < n; i++) {
int j = 0;
//每一次循环计算所有没有使用的顶点到当前S的距离，得到在没有使用的顶点中到S的最短距离以及顶点号
for (int k = 0; k < n; k++) {
//如果顶点k没有被使用，且到S的距离小于j到S的距离，将k赋给j
if (used[k]==0 && lowcost[k] < lowcost[j]){
j = k;
}
}
//输出S中与j最近邻点，j，以及它们之间的距离
System.out.println(closeset[j]+" "+j+" "+lowcost[j]);
//将j增加到S中
used[j] = 1;
for (int k = 0; k < n; k++) {
//松弛操作，如果k没有被使用，且k到j的距离比原来k到S的距离小
if (used[k]==0 && g[j][k] < lowcost[k]){
//将k到j的距离作为新的k到S之间的距离
lowcost[k] = g[j][k];
//将j作为k在S中的最近邻点
closeset[k] = j;
}
}
}
}
}
# 输入
0 1 28
0 5 10
5 4 25
4 3 22
3 2 12
2 1 16
1 6 14
6 4 24
6 3 18
aa #结束输入
#输出
0 5 10
5 4 25
4 3 22
3 2 12
2 1 16
1 6 14
8万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
