贪心算法：洛谷P1803凌乱的yyy解析(java)

题目描述

相关链接：https://www.luogu.com.cn/problem/P1803

解析

这道题对于java来说，第一思路应该是贪心算法，创建一个二维数组(或者创建两个数组)，然后对结束时间进行排序(这种情况一般用冒泡排序)，所以我刚开始是这么做的，附上代码：

import java.util.Scanner;

/**
 * @author ：Zeeland
 * @date ：Created in 2021/4/5 12:58
 * @version: 1.0$
 */

public class P1803 {
    public static void main(String[] args) {
        Scanner s =new Scanner(System.in);
        while(s.hasNext()){
            int n =s.nextInt();
            int arr[][] =new int[2][n];
            //initialize
            for (int i = 0; i < n; i++) {
                arr[0][i]= s.nextInt();
                arr[1][i]= s.nextInt();
            }
            //sort arr[1][i]
            int temp =0;
            for(int i =arr[0].length-1;i>=0;i--){
                for(int j=0;j<i;j++){
                    if(arr[1][j]>arr[1][j+1]){
                        temp = arr[1][j];
                        arr[1][j] =arr[1][j+1];
                        arr[1][j+1] = temp;
                        temp = arr[0][j];
                        arr[0][j] =arr[0][j+1];
                        arr[0][j+1] = temp;
                    }
                }
            }
            int count =1;
//            for (int i = 0; i < arr[0].length; i++) {
//                System.out.println(arr[0][i]+" "+arr[1][i]);
//            }
            int mid = arr[1][0];
            for(int i=0;i<arr[0].length;i++){
                //结束时间小于开始时间
                if(i<(arr[0].length-1)&& mid<=arr[0][i+1]){
                    count ++;
                    mid = arr[1][i+1];
                }
            }
            System.out.println(count);
        }
    }
}

然后就…

因为冒泡排序的时间复杂度为O(n^2)，所以10e6数量级的冒泡排序对于java来说还是太难承受了，难免会超时。

这个时候我想到了用树来排序，TreeSet的底层数据结构就是红黑树，时间复杂度O(logn)，对于O(n^2)的时间复杂度来说，已经是一个很大的进步了，因此这一次，我选择将beginTime和endTime放在一个node里面，然后treeSet，通过重写比较器或者实现comparable接口来自定义比较的功能。

代码如下：

import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;

/**
 * @author ：Zeeland
 * @date ：Created in 2021/4/5 14:29
 * @version: 1.0$
 */

public class P1803_2 {
    public static void main(String[] args) {
        Scanner s =new Scanner(System.in);
        while(s.hasNext()){
            int n=s.nextInt();
            TreeSet<P1803_node> set =new TreeSet<>();
            for (int i = 0; i < n; i++) {
                set.add(new P1803_node(s.nextInt(),s.nextInt()));
            }
            int count =0;
            int end =-1;
            for (P1803_node p1803_node : set) {
                //如果A结束的时间小于等于B开始的时间
                if(end <= p1803_node.beginTime){
                    count++;
                    end = p1803_node.endTime;
                }
            }
            System.out.println(count);
        }
    }
}


class P1803_node implements Comparable<P1803_node>{
    int beginTime;
    int endTime;
    public P1803_node(int beginTime,int endTime){
        this.beginTime = beginTime;
        this.endTime = endTime;
    }
    //重写toString用于调试
    @Override
    public String toString() {
        return beginTime+" "+endTime;
    }

    @Override
    public int compareTo(P1803_node o) {
        if(o.endTime==this.endTime){
            //如果结束时间相等，则比较开始时间，谁小谁在前
            return this.beginTime- o.beginTime;
        }else{
            return this.endTime - o.endTime;
        }
    }
}

最后…


虽然全部AC了，但是当我看到有人用java跑出700ms的时候，我就知道还有优化的方法，因此我尝试实现comparator接口比较一下两个比较器之间的运行速度。
代码如下：

import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;

/**
 * @author ：Zeeland
 * @date ：Created in 2021/4/5 14:29
 * @version: 1.0$
 */

public class P1803_2 {
    public static void main(String[] args) {
        Scanner s =new Scanner(System.in);
        while(s.hasNext()){
            int n=s.nextInt();
            TreeSet<P1803_node> set =new TreeSet<>(new P1803_comparator());
            for (int i = 0; i < n; i++) {
                set.add(new P1803_node(s.nextInt(),s.nextInt()));
            }
            int count =0;
            int end =-1;
            for (P1803_node p1803_node : set) {
                //如果A结束的时间小于等于B开始的时间
                if(end <= p1803_node.beginTime){
                    count++;
                    end = p1803_node.endTime;
                }
            }
            System.out.println(count);
        }
    }
}


class P1803_node{
    int beginTime;
    int endTime;
    public P1803_node(int beginTime,int endTime){
        this.beginTime = beginTime;
        this.endTime = endTime;
    }
    //重写toString用于调试
    @Override
    public String toString() {
        return beginTime+" "+endTime;
    }
}
class P1803_comparator implements Comparator<P1803_node> {

    @Override
    public int compare(P1803_node o1, P1803_node o2)
    {
        if(o1.endTime==o2.endTime)
        {
            return o1.beginTime-o2.beginTime;
        }
        return o1.endTime-o2.endTime;
    }
}

最后发现，两者时间差不多，并不是比较器的问题。

那么就只有将Scanner转换为缓冲输入流来实现更加快速地读取了。

代码如下：

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.TreeSet;
import java.util.Comparator;
/**
 * @author ：Zeeland
 * @date ：Created in 2021/4/5 19:24
 * @version: 1.0$
 */

public class Main {
    public static void main(String[] args) throws Exception {
        BufferedReader bufferedReader =new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(bufferedReader.readLine());
        TreeSet<P1803_node> set =new TreeSet<>(new P1803_comparator());
        for (int i = 0; i < n; i++) {
            String arr[] =bufferedReader.readLine().split(" ");
            set.add(new P1803_node(Integer.parseInt(arr[0]),Integer.parseInt(arr[1])));
        }
        int count =0;
        int end =-1;
        for (P1803_node p1803_node : set) {
            //如果A结束的时间小于等于B开始的时间
            if(end <= p1803_node.beginTime){
                count++;
                end = p1803_node.endTime;
            }
        }
        System.out.println(count);
    }
}
class P1803_node{
    int beginTime;
    int endTime;
    public P1803_node(int beginTime,int endTime){
        this.beginTime = beginTime;
        this.endTime = endTime;
    }
    //重写toString用于调试
    @Override
    public String toString() {
        return beginTime+" "+endTime;
    }
}
class P1803_comparator implements Comparator<P1803_node> {

    @Override
    public int compare(P1803_node o1, P1803_node o2)
    {
        if(o1.endTime==o2.endTime)
        {
            return o1.beginTime-o2.beginTime;
        }
        return o1.endTime-o2.endTime;
    }
}

最后…

芜湖~

总结

（1）在排序的时候，有三个考虑的方向：Arrays.sort方法，常见的几种排序算法、用TreeSet实现Comparable。
（2）如果有大规模数据输入的时候，用缓冲流输入，会减少很多时间。

关于贪心算法相关的例题：
1.https://www.luogu.com.cn/problem/P1223
2.http://acm.hdu.edu.cn/showproblem.php?pid=2037

整理不易，如果你认为我写的还不错，点赞评论转发收藏~