竞赛算法--贪心算法 及例题详解

动态规划（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.5： 题目描述+题目分析+题解代码

例题1.6 ： 部分背包问题

点击查看：例题1.6 ：题目描述+题目分析+题解代码

例题1.7 ： 乘船问题

点击查看：例题1.7 ：题目描述+题目分析+题解代码