动态规划(dynamic programming)
动态规划和贪心算法都是一种递推算法,均用局部最优解来推导全局最优解
是对遍历解空间的一种优化
当问题具有最优子结构时,可用动态规划,而贪心是动态规划的特例
1.贪心策略简介及硬币支付问题
贪心:
顾眼前
- 遵循某种规则,不断(贪心地)选取当前最优策略,最终找到最优解
- 难点: 当前最优未必是整体最优
例子
- 硬币问题 POJ-1013
- 区间问题及相关问题(区间调度,区间选点 POJ 1201、1328,区间覆盖问题 POJ -3617 )
- 字典序最小问题 (POJ - 3617)
- 背包问题及相关问题(最优装载问题,部分背包问题,乘船问题)
例题1.1 : 硬币支付问题
题目描述:
- 有1 元,5元,10元,50 元,100元的硬币各c1,c5,c10,c50,c100,c500枚。
- 现在要用这些硬币来支付A元,最少需要多少枚硬币?
- 假定本题至少存在一种支付方案
- 0 <= ci <= 10^9
- 0 <= A <= 10^9
- 输入:
- . . 第一行有6个数字,分别代表从小到大6种面值的硬币个数
- . . 第二行为A,代表支付的A元
- 输出:
- . . 最少需要的硬币枚数
- 样例:
- 输入
- . . 3 2 1 3 0 2
- . . 620
- 输出
- . . 6
题目分析+题解代码:
import java.util.Scanner;
public class Mian{
static int [] cnts = new int[6];
static int [] coins = {1,5,10,50,100,500};
public static void main(String [] args){
Scanner in = new Scanner(System.in);
for(int i=0;i<6;i++){
cnts[i] = in.nextInt();
}
int A = in.nextInt();
int res = f(A,5);
System.out.println(res);
}
/**
* 尽量先用大面值,因为不用大面值,将使用更多的小面值硬币,一定得不到最优解 */
static int f(int A , int cur){
if(A<=0) return 0;
if(cur == 0) return A;
int coinValue = coins[cur];
int x = A/coinValue; // 金额有多少coinValue
int cnt = cnts[cur]; // 当前面值的硬币有cnt个
int t = Math.min(x,cnt);
return t+f(A-t*coinValue , cur-1); // 用t个当前面值,剩下的继续处理
}
}
例题1.2 : 快速渡河
题目描述:
题目分析+题解代码:
public class Main{
public static void main(String args[]){
Scanner in = new Scanner(System.in);
int T = in.nextInt();
while(T-->0){
int n = in.nextInt();
int [] speed = new int[n];
for(int j = 0;i < n; j++)
speed[j] = in.nextInt();
// 排序
Arrays.sort(speed);
f(n,speed);
}
}
private static void f(int n ,int[] speed){
int left = n;
int ans = 0;
while(left > 0){
if(left == 1){ // 只有1人
ans += speed[0];
break;
}else if(left == 2){ // 只有2人
ans += speed[1];
break;
}else if(left == 3){ // 只有3人
ans += speed[2]+speed[1]+speed[0];
break;
}else{
// 1,2出发,1返回,最后两名出发,2返回。
int s1 = speed[1] + speed[0] + speed[left-1] + speed[1];
// 1,3出发,1返回,1 ,4出发,1返回 , 1,2过河。
int s2 = speed[left-1] + speed[left-2] + speed[0];
ans+=Math.min(s1,s2);
left -= 2;// 左侧是渡河的起点,left代表左侧剩余人数。
}
}
System.out.println(ans);
}
}
例题1.3 : 区间调度问题
题目描述:
- 有n项工作,每项工作分别在Si时间开始,Ti时间结束。
- 对于每项工作,你可以选择参与与否,如果选择了参与,那么自始至终都必须全程参与。
- 此外,参与工作的时间段不能重复(即使是开始的瞬间和结束瞬间的重叠也是不允许的)。
- 你的目标是参与尽可能多的工作,那么最多能参与多少项工作呢?
- 1 <= n <= 100000
- 1 <= Si <= Ti <=10^9
- 输入:
- 第一行: 整数 n
- 第二行: n个整数空格隔开,代表 n 个工作的开始时间。
- 第三行: n 个整数空格隔开,代表n个工作的结束时间。
- 输出:
- 一个整数 代表
- 样例输入:
- 5
- 1 2 4 6 8
- 3 5 7 9 10
- 样例输出:
- 3
题目分析+题解代码:
import java.util.*;
public class Main{
public static void main(String args[]){
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int[]s = new int[n];
int[]t = new int[n];
Job[] jobs = new Job[n];
for(int i=0;i<n;i++){
s[i] = in.nextInt();
}
for(int i=0;i<n;i++){
t[i] = in.nextInt();
}
for(int i=0;i<n;i++){
jobs[i] = new Job(s[i],t[i]);
}
Arrays.sort(jobs);
int res = f(n,jobs);
System.out.println(res);
}
private static int f(int n , Job[] jobs){
int count = 1;
int y = jobs[0].t;
for(int i=0;i<n;i++){
if(jobs[i].s>y){
count++;
y = jobs[i].t;
}
}
return count;
}
private static class Job implements Comparable<Job>{
int s , t;
public Job(int s,int t){
this.s = s;
this.t = t;
}
@Override
public int compareTo(Job other){
int x = this.t - other.t;
if(x==0)
return this.s-other.s;
else
return x;
}
}
}
例题1.4 : 区间选点问题(POJ1201)
例题1.5 : 字典序最小问题(POJ1201)
例题1.6 : 部分背包问题
例题1.7 : 乘船问题
点击查看:例题1.7 :题目描述+题目分析+题解代码