题解

难度：简单

知识点：数学问题

分析：

在本题中，踢赢比赛得一分，输了不等分也不见分，
那么(1)总分一定等于n；同时要想是平局n%3=0；(2)还没有踢的比赛（n-k），要能弥补（d1+d2）的分数差，即n-k≥d1+d2；(3)满足以上两点的情况时，根据差值情况，有4种情况，如下：
“1队>2队或1队<2队“ 与 “2队>3队或2队<3队”组合，假设1队的得分情况是m。
① 当1队>2队，2队>3队时，3支队伍的得分情况是：
m（max）
m-d1
m-d1-d2（min）  k=3m-2d1-d2
在该情况下，1队得分最多，3队得分最少。
要想达到平局，必须追上1队的成绩，至少还需要进行“2d1+d2”场比赛，所以剩下的场次(n-k)≤(2d1+d2)，并且剩下的场次仍能被3平分才能继续保持平局。

② 当1队>2队，2队<3队时，3支队伍的得分情况是：
m
m-d1（min）
m-d1+d2  k=3m-2d1+d2
在该情况下，1队3队得分最多的要看d1d2的大小，2队得分最少。
当d1≥d2时，1队的得分最多；此时要想追上1队的成绩需要“2d1-d2”场，则(n-k)≤(2d1-d2)
否则3队得分最多, 此时要想追上3队的成绩需要“2d2-d1”场，则(n-k)≤(2d2-d1)

③ 当1队<2队，2队>3队时，3支队伍的得分情况是：
m
m+d1（max）
m+d1-d2  k=3m+2d1-d2
在该情况下，2队得分最多，1队3队得分最少要看d1d2的大小。
当d1≥d2时，1队的得分最少；否则3队得分最少。
要想达到平局，必须追上2队的成绩，至少还需要进行“d1+d2”场比赛，所以剩下的场次(n-k)≤(d1+d2)。

④ 当1队>2队，2队<3队时，3支队伍的得分情况是：
m(min)
m+d1
m+d1+d2(max)  k=3m+2d1+d2
在该情况下，1队得分最少，3队得分最多。
要想达到平局，必须追上3队的成绩，至少还需要进行“d1+2d2”场比赛，所以剩下的场次(n-k)≤(d1+2d2)。
不管在哪种情况下，要想达到平局，最后任意一个队伍的得分一定不能超过n/3。
通过上面的分析，可以有2种解题方法：利用剩余场次，以及利用最高队伍的得分情况，而这两种方法的大前提都是第一队m（基础）有解才可以。

方法1：利用最高得分列关系式

import java.util.Scanner;

public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
            int t = Integer.parseInt(sc.nextLine());

            for(int i=0;i<t;i++){
                String s = sc.nextLine();
                String[] ss = s.split(" ");
                long n = Long.parseLong(ss[0]);
                long k = Long.parseLong(ss[1]);
                long d1 = Long.parseLong(ss[2]);
                long d2 = Long.parseLong(ss[3]);

                // 利用最高分解决
                String res = solve(n,k,d1,d2);

                System.out.println(res);
            }

    }


    private static String solve(long n, long k, long d1, long d2) {

                if(n%3!=0 || n-k < d1+d2 ){
                    return "no";
                }

                // 因为是以第一队为基础，所以第一队有解是大前提。
           // 第1种情况下的1队得分最多,
           long m1 = k + 2*d1 + d2;


           // 第2种情况下的最多得分队伍
           long m2 = 0;
           if (d1>=d2){
               m2 = k+2*d1-d2; //1队大
           }else{
               m2 = k-d1+2*d2;  //3队大
           }
           long m2m = k+2*d1-d2; // 此时1队得分

           //第3种情况下，2队得分最多
           long m3 = k+d1+d2;
           long m3m = k-2*d1+d2;  // 此时1队得分

           //第4种情况下3队得分最多
           long m4 = k+d1+2*d2;
           long m4m = k-2*d1-d2;  //此时1队得分


           if((m1>=0 && m1%3==0 && m1/3<=n/3) 
                   || (m2>=0 && m2%3==0 && m2/3<=n/3 && m2m>=0 && m2m%3==0) 
                   || (m3>=0 && m3%3==0 && m3/3<=n/3 && m3m>=0 && m3m%3==0) 
                   || (m4>=0 && m4%3==0 && m4/3<=n/3 && m4m>=0 && m4m%3==0)){
               return "yes";
           }

            return "no";
    }
}

方法2：利用利用剩余场次列关系式

import java.util.Scanner;
public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
            int t = Integer.parseInt(sc.nextLine());

            for(int i=0;i<t;i++){
                String s = sc.nextLine();
                String[] ss = s.split(" ");
                long n = Long.parseLong(ss[0]);
                long k = Long.parseLong(ss[1]);
                long d1 = Long.parseLong(ss[2]);
                long d2 = Long.parseLong(ss[3]);

                // 利用剩余比赛场次解决
            String res = solve2(n,k,d1,d2);

                System.out.println(res);
            }

    }

    private static String solve2(long n, long k, long d1, long d2) {
            long m1 = k + 2*d1 + d2;  //情况1
            if(m1 >= 0 && m1 % 3 == 0){ //m有解是大前提
                long left = (n - k) - (2*d1  + d2);  //需要2d1+d2才能让两个较低的追上最高的达到平局，
                if(left >= 0 && left % 3 == 0){ //那么剩下的场次要继续能被3整除才能继续保持平局。
                    return "yes";

                }
            }

            long m2 = k + 2*d1 - d2;//情况2
            if(m2 >= 0 && m2 % 3 == 0){
            long left;
                if(d1 >= d2){
                    left = (n - k) - (2*d1 - d2);
                }else{
                    left = (n - k) - (2*d2 - d1);
                }

                if(left >= 0 && left % 3 == 0){
                    return "yes";
                }
            }

            long m3 = k - 2*d1  + d2; //情况3
            if(m3 >= 0 && m3 % 3 == 0){
                long left = (n - k) - (d1 + d2);
                if(left >= 0 && left % 3 == 0){
                    return "yes";
                }
            }

            long m4 = k - 2* d1 - d2; //情况4    
            if(m4 >= 0 && m4 % 3 == 0){ 
                long left = (n - k) - (d1 + 2*d2 );
                if(left >= 0 && left % 3 == 0){  
                    return "yes";
                }
            }

        return "no";
    }

}