贪心专项——后悔

此类问题都是先假设所有的工作都能完成，然后从头开始检测每一个任务的合法性。

P2949 工作调度 Work Scheduling

https://www.luogu.org/problem/P2949
贪心策略：根据工作的结束时间进行排序（如果结束时间相同，再根据价值排序）。 之后从头开始扫描，判断第 $i$ 个任务能否在截止时间完成，

• 如果能，则直接加入堆中，
• 如果不能，则将堆中的最小值拿出，进行比较，舍弃较小者。

Java 有超时的风险，多交几次就好（毕竟不是ACM主流语言。。）

/**
 *https://www.luogu.org/problem/P2949
 *@author Hongchuan CAO
 */

import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.Scanner;

public class Main{

    public static void solve(){
        Scanner in = new Scanner(System.in);
        int N = in.nextInt();
        Node[] node = new Node[N];
        for(int i=0;i<N;i++){
            node[i] = new Node();
            node[i].d = in.nextInt();
            node[i].p = in.nextInt();
        }

        Arrays.sort(node);
        
        //scan using stack
        PriorityQueue<Long> pq = new PriorityQueue<>();
        long sum = 0;
        for(int i=0;i<N;i++){
            if(pq.size()<node[i].d){
                pq.add(node[i].p);
                sum += node[i].p;
            }else{
                if(pq.element()<node[i].p){
                    sum -= pq.element();
                    sum +=node[i].p;
                    pq.poll();
                    pq.add(node[i].p);
                }
            }
        }
        System.out.println(sum);
    }
    public static void main(String arg[]){
        solve();
    }
}

class Node implements Comparable{
    public long d,p;
    @Override
    public int compareTo(Object obj){
        Node other = (Node) obj;
        if(this.d!=other.d){
            if(this.d<other.d) return -1;
            else if(this.d>other.d) return 1;
            else return 0;
        }else{
            if(this.p<other.p) return -1;
            else if(this.p>other.p) return 1;
            else return 0;
        }
    }
}

UVA1316 Supermarket

https://www.luogu.org/problem/UVA1316

此题和上一道思想相同，代码稍作修改即可。

此代码 runtime error 感觉是结束EOF的问题，留着以后再找。。。

/**
 *https://vjudge.net/problem/UVA-1316
 *@author Hongchuan CAO
 */

package ACM;

import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.Scanner;

public class Main{

    public static void solve(){
        Scanner in = new Scanner(System.in);
        while(in.hasNext()){
            int N = in.nextInt();
            Node[] node = new Node[N];
            for(int i=0;i<N;i++){
                node[i] = new Node();
                node[i].p = in.nextInt();
                node[i].d = in.nextInt();
            }

            Arrays.sort(node);
            //scanner using stack
            PriorityQueue<Long> pq = new PriorityQueue<>();
            long sum = 0;
            for(int i=0;i<N;i++){
                if(pq.size()<node[i].d){
                    pq.add(node[i].p);
                    sum += node[i].p;
                }else{
                    if(pq.element()<node[i].p){
                        sum -= pq.element();
                        sum +=node[i].p;
                        pq.poll();
                        pq.add(node[i].p);
                    }
                }
            }
            System.out.println(sum);
        }
        in.close();
    }
    public static void main(String arg[]){
        solve();
    }
}

class Node implements Comparable{
    public long d,p;
    @Override
    public int compareTo(Object obj){
        Node other = (Node) obj;
        if(this.d!=other.d){
            if(this.d<other.d) return -1;
            else if(this.d>other.d) return 1;
            else return 0;
        }else{
            if(this.p<other.p) return -1;
            else if(this.p>other.p) return 1;
            else return 0;
        }
    }
}