贪心样例

2022-03-20 10:33:32 作者：互联网

贪心算法的实例练习

贪心算法与枚举法的不同之处在于每个子问题都选择最优的情况，然后向下继续进行，且不能回溯，枚举法是将所有情况都考虑，然后选出最优的情况。
贪心算法，在对问题求解时，不从整体考虑，而是采用一叶障目的选择方式，只选择某种意义上的局部最优解。并且，贪心算法是没有固定的模板可以遵循的，每个题目都有不同的贪心策略，所以算法设计的关键就是贪心策略的选择。
贪心算法对于问题的要求是，所有的选择必须是无后效性的，即当前的选择，不能影响后续选择对于结果的影响。

1. 找零问题

题目如下：
假设商店老板需要找零 n 元钱。
钱币的面额有：100 元、50 元、20 元、5 元、1 元、如何找零使得所需钱币的数量最少？（注意：n 可能为 0，也能为几百元）
输入:
在第一行给出测试例个数 N，代表需要找零的钱数。
输入样例：
365
输出：
输出样例
有 5 行输出数据，每一行输出数据输出找零的金额与数量，详情看样例。
100:3
50:1
20:0
5:3
1:0

package 贪心样例;

import java.util.Scanner;

//找零问题：从大的钱开始找钱。这就是一种贪心的思想，将大问题转化为一个个小的子问题，每次选择最大的钱数使得总量最小
public class ZhaoLing {

	static int[] value = {100,50,20,5,1};//存放钱币的面值
	static int[] count = new int[value.length];//存放各个面值所对应的纸币个数
	
	//求得各个面值的张数，实现总张数最小的目的
	static void change(int n) {
	      for (int i = 0; i < value.length; i++) {
	          count[i] = n / value[i];
	          n = n % value[i];
	      }
/*n=365 
 *count[0] = 365 / value[0]=365/100=3 就是100的有3张
 *n = n % value[0]=365%100=65  就是更新n,得到剩余钱数*/
	}
	public static void main(String[] args) {
		  int N;//要找零的总钱数
		  Scanner scanner = new Scanner(System.in);
		  N = scanner.nextInt();
		  
		  change(N);
		  for (int i = 0; i < value.length; i++) {
			System.out.printf("%d:%d",value[i], count[i]);//格式化 用printf
			System.out.println();//换行
			
		}
	}
/*365
100:3
50:1
20:0
5:3
1:0*/
}

2. 活动选择型问题

题目描述：
小B的宿舍楼沿着走廊南北向的两边各有 200 个房间，如下所示：

[房间1][房间3][房间5][房间7][房间9 ]...[房间399]
----------------------------------------------
走廊
----------------------------------------------
[房间2][房间4][房间6][房间8][房间10]...[房间400]

宿舍将迎来新的调整，以便组成新的班级后方便管理。

但是由于走廊狭窄，走廊里只能通过两个搬运的物品（可以同向也可以反向），因此必须指定高效的搬运计划。

老师给了每位同学下达了以下要求: 给每位同学 10 分钟的时间搬运。

当从房间 i 搬运行李到 j 时，i 与 j 之间的走廊都会被占用，但是可以容纳两个不同同学同时搬运。所以，10 分钟之内同一段走廊最多两个人同时搬运，不重叠的走廊也可以同时搬运。

小B的老师是个数学老师，经过运筹学一通计算他得到了最优的搬运计划。

虽然计划不唯一，但是最优值唯一，请问这个最短时间是多少？

输入描述
**输入数据有 T 组测试例，在第一行给出测试例个数 T **

每个测试例的第一行是一个整数 N （1<= N ≤200)，表示要搬运行李的人数。

接下来 N 行，每行两个正整数 s 和 t ，表示一个人，要将行李是从房间 s 移到到房间 t 。

输出描述
每组输入都有一行输出数据，为一整数 Time ，表示完成任务所花费的最小时间。

示例
输入

3
4
10 20
30 40
50 60
70 80
2
1 3
2 200
3
10 100
20 80
30 50
输出

10
10
20

分析：

因为它尽可能使搬运行李同时进行，以便使单独安排的搬运次数最少。这样用的时间最少，即所用最少时间为不能同时搬运行李的次数，进而转化为寻找某一段走廊使用次数最多（贪心标准），由于走廊可以同行 2 人，所以除 2，有余数再加 1 即可，即使最多的搬运次数，再乘以 10，即为最少搬运时间。

package 贪心样例;

import java.util.Scanner;
import static java.lang.Integer.max;

public class HuoDongSelect {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		// 要搬运行李的人数,即搬运总次数
		int N;

		// 每次搬运的起点和终点
		int from, to;
		// 走廊使用的最多次数
		int maxAns = 0;
		// 总的输入数据 T 组测试样例
		int T;
		T = in.nextInt();

		while (T > 0) {
			T--;

			N = in.nextInt();
			int[] move = new int[205];
			
			// 接下来是每组测试
			for (int i = 0; i < N; i++) {
				from = in.nextInt();
				to = in.nextInt();
				// 将房间号映射为走廊号
				from = (from - 1) / 2;
				to = (to - 1) / 2;
				// 确保from<to
				if (from > to) {
					int temp = from;
					from = to;
					to = temp;
				}
				// 统计占用走廊情况，并统计最大值
				for (int j = from; j <= to; j++) {
					move[j]++;// 每段走廊的使用次数
					maxAns = max(maxAns, move[j]);//对于每种从走廊号from到to，每段走廊move[j]，使用一次就move[j]++，当然每次与当前的最多使用次数比较，来更新
				}//导入java.lang.Integer.max，进行比较

			}
			if (maxAns % 2 == 1)//因为每段走廊只允许有2个人通过 
				maxAns = maxAns / 2 + 1;
			else
				maxAns /= 2;  

			System.out.println(maxAns * 10);
		}
	}

}
/*对于java.lang.Integer.max;的源码：
 *  public static int max(int a, int b) {
        return Math.max(a, b);
    }*/

3. 可拆分背包问题之贪心的自助餐

题目描述

小B同学想去吃自助餐，但是他是那种比较节俭的的人，既不想浪费食物，又想尽可能吃的贵一点，他于是私下里做了调查。

小蓝餐厅的 自助餐有 n种食材，每种食材都有它的价格。

而且也能估计出每一份的重量，所以他列了一个表格：(还有很多未列出来)

菜品	价格（元）	重量（g）
红烧牛肉	30	300
油闷大虾	8	5
四喜丸子	4	8
三文鱼	5	3
排骨	18	200
麻辣兔头	20	120
高汤海参	40	70
扇贝粉丝	8	32
牛排	79	240

小B 的饭量为 C(g)，他想知道在不超过饭量的情况下他最多能吃多少钱的菜品。

请你设计一个程序帮助小B 计算他的最多吃了多少钱。（假设自助餐厅的菜品供应同样的菜品每个人只能取一份。）

输入描述

第一行输入两个整数 n, C（ 0≤n≤1000, 0≤C≤10000），其中 n 为菜品数量，C 为小B 的肚子容量。

接下来 n 行每行输入两个数 v[i],w[i] , v[i] 是第 i个菜品的价值，w[i] 表示第 i 个菜品的重量（ 0≤v[i],w[i]≤10000 ）。

输出描述

输出一行数据，表示最大的价值，保留小数点后三位数。

示例

输入

输出

1204.114

题目解析：

可拆分背包的一般解法为：

这里有 n 种不同值 v[i] 和权重 w[i] 的对象（如果选择该对象的 w[i] 可以获得值 v[i]）。

你有一个容器来挑选它们。你可以根据自己的需要把它们分成任意大小的碎片。可以拾取的对象的最大重量给定为 w。请计算您能得到对应权重w的最大值。

这个题目，要想吃回本就要捡着贵的吃，但是贵只是一方面，人会饱，所以用价格除以质量所获的价格商才是贪心准则，应按照价格商优先进行选取。

这个题，因为要整体按照价格商进行排序，所以要自定义比较类，此类要实现Comparator接口，在此接口中的compare方法中自定义比较规则，也就是按照食物的价格商，当然食物要定义一个类，比较食物类的价格商的属性值，最后再使用 sort 排序。

package 贪心样例;

import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

/*用价格除以质量所获的价格商才是贪心准则:
 思路：* /
 1. 建立一个食物类，特别是价格商的属性
 2. 自定义比较类，此类要实现Comparator接口，在此接口中的compare方法中自定义比较规则，也就是按照食物的价格商
 3. 输入：
第一行输入两个整数 n, C 
接下来 n 行每行输入两个数 v[i],w[i] , v[i] 是第 i个菜品的价值，w[i] 表示第 i 个菜品的重量 */
public class ZiZhuCan {

	// 静态内部类 食物类
	static class Food {
		public double w;// 质量
		public double v;// 价值
		public double aver;// 价格商
		// 构造器

		Food() {
			w = 0;
			v = 0;
			aver = 0;
		}
	}

	// 静态内部类 比较类要实现Comparator接口
	static class MyCompare implements Comparator<Food> {

		@Override
		public int compare(Food o1, Food o2) {
			if (o1.aver > o2.aver) {
				return -1;
			}
			return 1;
			 
		}
//大于号就是从大到小排序，小于号就是从小到大排序		 
	}

	static Food foods[] = new Food[1005];

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int n; // n 为菜品数量
		double C; // C是肚子容量
		double Value = 0;
		n = in.nextInt();
		C = in.nextDouble();
		// 初始化食物数组
		for (int i = 0; i < n; i++) {
			foods[i] = new Food();
			foods[i].v = in.nextDouble();
			foods[i].w = in.nextDouble();
			// 求性价比（价格商）
			foods[i].aver = foods[i].v / foods[i].w;
		}

		// 按照价格商给食物数组的元素进行排序
		Comparator<Food> myComparator = new MyCompare();
		Arrays.sort(foods, 0, n, myComparator);

		// 1. 当背包（肚子）能装下所有物品（菜）时，直接输出所有的物品（菜品）价值之和
		int sum = 0;
		for (int i = 0; i < n; i++) {
			sum += foods[i].w;
		}
		if (sum < C) {
			for (int j = 0; j < n; j++)
				Value += foods[j].v;
			System.out.print(String.format("%.3f", Value));
			return;
		}

		// 2.当背包（肚子）不能装下所有物品时应该由性价比的顺序，选择装入的物品
		for (int i = 0; i < n; i++) {
			if (foods[i].w <= C) {
				Value = Value + foods[i].v;
				C = C - foods[i].w;
			} else {// 某食物的质量foods[i].w 大于此时的 C,价值= C * foods[i].aver
				Value = Value + C * foods[i].aver;
				C = 0;// 表示没有容量再盛放物品
			}
			if (C == 0)
				break;
		}
//		System.out.print(String.format("%.3f", Value));
		System.out.printf("%.3f", Value);
		return;

	}
}
/*补充知识点：
 * 1.比较器接口：
 * public interface Comparator<T> {
 *      int compare(T o1, T o2);
 * }
 *  单独编写一个比较器类/匿名内部类，实现Comparator接口，并实现其中的方法compare，在其中自定义比较规则；
 *  一种比较函数，它对某些对象集合施加总排序。
 * 可以将比较器传递给排序方法（例如Collections.sort或Arrays.sort），
 * 以便对排序顺序进行精确控制。 根据指定比较器产生的顺序，对指定对象数组的指定范围进行排序。
 *2.   public static <T> void sort(T[] a, int fromIndex, int toIndex,
                                Comparator<T> c) {
      在调用Arrays.sort方法时，传进一个比较器对象， 该范围内的所有元素必须通过指定的比较器相互比较（即，c.compare（e1，e2）
 * 3.输出时，格式化：String.format("%.3f", Value)
 * 源码：
 * public static String format(String format, Object... args) {
        return new Formatter().format(format, args).toString();
    }
    
    用System.out.printf("%.3f", Value); 也可以
 */

标签：int,样例,foods,static,搬运,public,贪心
来源： https://www.cnblogs.com/yang123-456/p/16029133.html