我的思路是，用排序去做，从大到小排序放在数组里面，那对应的数组下标0-2，就是最大的三个数，这三个数加起来就是编程能力值，下面附代码。

import java.util.Scanner;
public class A{

    public static void main(String[]args){

        Scanner scanner = new Scanner(System.in);
        while(scanner.hasNext())
        {
            int n  = scanner.nextInt(); // 新训队员量
            int m  = scanner.nextInt(); // 能量值
            int sum[] = new int[n];
            for(int i = 0; i < n; i++){
                sum[i] = scanner.nextInt();
            }

            int w = 0; //队友能量和

            for(int i = 0; i < sum.length; i++){
                sort(sum,0,sum.length-1);
            }
            w = sum[0]+sum[1]+sum[2];
            if (w >= m){
                System.out.println(w);
            }
            else{
                System.out.println("Waiver!");
            }
        }
    }

    static int partition(int arr[], int low, int high)
    {
        int pivot = arr[high];
        int i = (low-1); // index of smaller element
        for (int j=low; j<high; j++)
        {
            // If current element is smaller than the pivot
            if (arr[j] > pivot)
            {
                i++;

                // swap arr[i] and arr[j]
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }

        // swap arr[i+1] and arr[high] (or pivot)
        int temp = arr[i+1];
        arr[i+1] = arr[high];
        arr[high] = temp;

        return i+1;
    }


    /* The main function that implements QuickSort()
      arr[] --> Array to be sorted,
      low  --> Starting index,
      high  --> Ending index */
    static void sort(int arr[], int low, int high)
    {
        if (low < high)
        {
            /* pi is partitioning index, arr[pi] is
              now at right place */
            int pi = partition(arr, low, high);

            // Recursively sort elements before
            // partition and after partition
            sort(arr, low, pi-1);
            sort(arr, pi+1, high);
        }
    }
}