Netease 2019 teste escrito Niu Niu encontrar um emprego solução Java

Descrição do título

Para encontrar um emprego satisfatório, Niu Niu coletou a dificuldade e a recompensa de cada trabalho. O critério para escolher um trabalho é escolher o trabalho com a maior remuneração, se a dificuldade não exceder o valor da sua capacidade. Depois que Niu Niu escolheu seu trabalho, os amigos de Niu Niu foram a Niu Niu para ajudá-lo a escolher um emprego.Niu Niu ainda usava seus próprios padrões para ajudar seus amigos. Há muitos amigos de Niu Niu, então ele tem que dar essa tarefa a você.

Digite a descrição

Cada entrada contém um caso de teste. 
A primeira linha de cada caso de teste contém dois números inteiros positivos, representando o número de trabalhos N (N <= 100000) e o número de amigos M (M <= 100000). 
Cada uma das próximas N linhas contém dois números inteiros positivos, indicando a dificuldade Di (Di <= 1000000000) e a recompensa Pi (Pi <= 1000000000) do trabalho. 
A próxima linha contém M inteiros positivos, que representam o valor da capacidade Ai de M pequenos parceiros (Ai <= 1000000000). 
Certifique-se de que não haja dois empregos com a mesma remuneração.

Descrição da saída

Para cada parceiro, imprima um número inteiro positivo em uma linha separada para indicar a maior recompensa que ele pode receber. Um trabalho pode ser selecionado por várias pessoas.

Exemplo de entrada

3 3 
1 100 
10 1000 
1000000000 1001 
9 10 1000000000

Saída de amostra

100 
1000 
1001

Análise

Esta pergunta parece com o problema da mochila 01 no planejamento dinâmico, mas não é. No começo, eu pensei que era um problema de planejamento dinâmico. Escrevi uma mochila 01 diretamente e descobri que a memória java estava cheia. Na verdade, a essência dessa pergunta está na primeira frase. Palavras: O padrão para escolher um trabalho é escolher o trabalho com a maior remuneração quando a dificuldade não exceder o valor da sua capacidade. Ou seja, no trabalho cuja dificuldade no trabalho é menor ou igual à sua própria capacidade, escolha o salário mais alto entre eles, para que não sejam regras dinâmicas, mas classificando e pesquisando.

Solução: Fiz um comentário detalhado no código e sei rapidamente que o executei no Niuke.com e posso copiá-lo diretamente

import java.util.Arrays;
import java.util.Scanner;
import java.util.TreeMap;

public class 牛牛找工作 {
    public static void main(String[] args) {
        //输入流
        Scanner sc = new Scanner(System.in);

        int n = sc.nextInt();//n表示工作的数量
        int m = sc.nextInt();//m表示同学的数量

        // jobs数组 n行2列 n行表示n个工作，第一列表示工作的难度， 第二列表示工作的报酬
        int[][] jobs = new int[n][2];
        for (int i=0;i<n;i++){
            jobs[i][0] = sc.nextInt();//表示工作的难度
            jobs[i][1] = sc.nextInt();//表示工作的报酬
        }

        //jobs数组排序
        Arrays.sort(jobs, ((o1, o2) -> o1[0]-o2[0]));//按照工作难度从小到大排序

        //很重要 我们把每个工作的报酬设置为 难度比他小的这些工作中的最大报酬
        for (int i=1;i<jobs.length; i++){
            jobs[i][1] = Math.max(jobs[i - 1][1], jobs[i][1]);
        }

        //将job数组存储到TreeMap中，其中，key=难度，value=最大报酬
        TreeMap<Integer, Integer> map = new TreeMap<>();
        for (int i=0; i<jobs.length; i++){
            map.put(jobs[i][0], jobs[i][1]);
        }

        //输入每个同学的能力ability
        for (int i=0;i<m;i++){
            int ability = sc.nextInt();
            //返回的是小于等于ability的最大key，其实这里就是在找这个能力下的最大工作难度
            Integer key = map.floorKey(ability);
            if (key != null)
                //找到这个难度对应的最大报酬就是我们想得到的最大报酬
                System.out.println(map.get(key));
            else
                System.out.println(0);
        }



    }
}