網易2018---牛牛找工作

牛牛找工作

時間限制：2秒

空間限制：65536K

為了找到自己滿意的工作，牛牛收集了每種工作的難度和報酬。牛牛選工作的標准是在難度不超過自身能力值的情況下，牛牛選擇報酬最高的工作。在牛牛選定了自己的工作后，牛牛的小伙伴們來找牛牛幫忙選工作，牛牛依然使用自己的標准來幫助小伙伴們。牛牛的小伙伴太多了，於是他只好把這個任務交給了你。 

輸入描述:

每個輸入包含一個測試用例。
每個測試用例的第一行包含兩個正整數，分別表示工作的數量N(N<=100000)和小伙伴的數量M(M<=100000)。
接下來的N行每行包含兩個正整數，分別表示該項工作的難度Di(Di<=1000000000)和報酬Pi(Pi<=1000000000)。
接下來的一行包含M個正整數，分別表示M個小伙伴的能力值Ai(Ai<=1000000000)。
保證不存在兩項工作的報酬相同。

輸出描述:

對於每個小伙伴，在單獨的一行輸出一個正整數表示他能得到的最高報酬。一個工作可以被多個人選擇。

輸入例子1:

3 3 
1 100 
10 1000 
1000000000 1001 
9 10 1000000000

輸出例子1:

100 
1000 
1001

法一（借鑒）：用map存儲工作能力和報酬的對應關系，不僅存儲所有工作的，而且也存儲每個小伙伴的工作能力和報酬（為0），這樣在后面計算的時候不用兩層for循環，而使用一層for循環就可以搞定，
因為不需要判斷小伙伴的能力值和工作能力值的大小關系，只需要計算，到目前的能力值為止，所能獲得的最大報酬數，有種dp的味道，用ma保存歷史最大報酬數，然后再更新到map中即可。o(nlgn)。代碼如下：

public class MainCorrect {

    public static void main(String[] args) {
        //划重點！！！此題坑點：輸入中間有空行，所以用BuffferedReader會更麻煩，所以選擇用Scanner
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        //保存所有工作的鍵值對，即<工作能力，報酬>，而且也保存每個小伙伴的能力值鍵值對，其報酬為0
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        //保存所有工作的能力值以及要計算的每個小伙伴的能力值
        int[] ai = new int[m + n];
        for(int i = 0; i < n; i++) {
            int di = sc.nextInt();
            ai[i] = di;
            int pi = sc.nextInt();
            map.put(di, pi);
        }
        //保存要計算的每個小伙伴的能力值
        int[] bi = new int[m];
        for(int i = 0; i < m; i++) {
            ai[i + n] = sc.nextInt();
            bi[i] = ai[i + n];
            if(!map.containsKey(ai[i + n])) {
                map.put(ai[i + n], 0);
            }
        }
        //對能力值進行排序
        Arrays.sort(ai);
        //保存到目前的能力值為止，所能獲得的最大報酬，有種dp的味道
        int ma = 0;
        for(int i = 0; i < m + n; i++) {
            //每次都更新當前能力值所對應的最大報酬，由於ma是保存的<=當前能力值所能獲得的最大報酬，所以可行
            ma = Math.max(ma, map.get(ai[i]));
            map.put(ai[i], ma);
        }
        //遍歷每個小伙伴的能力值，從map中獲取到其最大報酬（在上面的for循環中已經更新到了）
        for(int i = 0; i < m; i++) {
            System.out.println(map.get(bi[i]));
        }
    }

}

法二：兩層for循環，先排序，后逐一進行比較判斷。o(n^2)。當然超時，僅通過40%。代碼如下：

public class Main {

    //用一個類來記錄工作能力和報酬的對應關系，其實可以用map實現的
    static class Job implements Comparable<Job>{
        int di, pi;
        public Job(int di, int pi) {
            this.di = di;
            this.pi = pi;
        }
        //按工作能力值進行排序
        public int compareTo(Job job) {
            return this.di - job.di;
        }
    }
    
    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        Job[] jobs = new Job[n];
        for(int i = 0; i < n; i++) {
            int di = sc.nextInt();
            int pi = sc.nextInt();
            jobs[i] = new Job(di, pi);
        }
        //對工作能力進行排序
        Arrays.sort(jobs);
        int[] ai = new int[m];
        for(int i = 0; i < m; i++) {
            ai[i] = sc.nextInt();
        }
        //逐一計算每個小伙伴，在其工作能力之內所能獲得的最大報酬
        for(int i = 0; i < m; i++) {
            int j = 0;
            int cnt = 0;
            while(j < n && jobs[j].di <= ai[i]) {
                if(cnt < jobs[j].pi) {
                    cnt = jobs[j].pi;
                }
                j++;
            }
            System.out.println(cnt);
        }
    }

}