Codeforces #439.Div.2

A - The Artful Expedient

题目大意：

　　一对基友在玩♂游♂戏♂。每个人有一个数列，两个数列中所有的数字都不一样。

　　规则是，在两个数列中各取出一个数（a，b），将所有不同的数对全部取出来。

　　计算 a^b ，如果得到的值在两个数列其中的一个里，那么就加一分。

　　结束后计算得分，如果是奇数，则是Koyomi获胜，偶数则是Karen获胜。

　　输入一行一个整数：代表每个人有n个数。n ∈ [1,2000]。

　　输入一行n 个整数：代表Koyomi的数列。数列中数字的范围是[1,2e6]。

　　输入一行n 个整数：代表Karen的数列。数列中数字的范围是[1,2e6]。

　　输出一个字符串：代表胜利者。

　　样例输入：3　　　　　　5

　　　　　　　1 2 3　　　　2 4 6 8 10

　　　　　　　4 5 6　　　　9 7 5 3 1

　　样例输出：Karen　　　　Karen

解题思路：

　　此题可以用暴力求解，但是却又更加优美的过题方式，利用异或运算的规律即可。

　　在异或运算中，若存在 a ^ b = c 那么也一定存在 a ^ c = b 以及 b ^ c = a。就像是一个环一样。

　　那么假设两个数列为 x，y。若a在x中，b在y中，且a ^ b = c，c在x或y中。

　　那么遍历x时，运算到a的时候，得到一分，运算到c的时候又得到了一分。

　　所以一旦有符合条件的情况出现，那么必定是成对出现的。

　　所以一定有偶数的分数，Karen一定胜利。

A C 代码：

import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            int n = sc.nextInt();
            for(int i = 0;i < n;i ++){
                int t = sc.nextInt();
            }
            for(int i = 0;i < n;i ++){
                int t = sc.nextInt();
            }
            System.out.println("Karen");
        }
    }
}

B - The Eternal Immortality

题目大意：

　　给你两个数a，b（a <= b && a,b ∈ [0，1e18]）。

　　求出（b!/a!）的个位数字。

　　输入一行两个整数：a，b。

　　输出一行一个整数：代表（b!/a!）的个位数字。

　　样例：2 4 --> 2　

　　　　　0 10 --> 0

　　　　　107 109 --> 2

解题思路：

　　明显要进行 %10 的处理。

　　而且结果跟两个数字的差有关。

　　但是部分人可能只想到了如果差大于十，结果都是0。

　　其实仔细想一下，两个数的差只要大于5，个位数就已经一直是0了。

A C 代码：

import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            long x = sc.nextLong();
            long y = sc.nextLong();
            long t = y - x;
            long ans = 1;
            if(t >= 5){System.out.println("0");}
            else{
                while(t > 0){
                    ans = ans * (y % 10);
                    y --;
                    t --;
                }
                System.out.println(ans % 10);
            }
        }
    }
}

C - The Intriguing Obsession

 题目大意：

　　有三个群岛（姑且称为红岛，蓝岛，紫岛），每个群岛有若干个小岛。现在要在小岛之间造桥，每个桥的长度均为1。

　　相同颜色的小岛之间的距离至少为三或不相连。求解方案总数（对998244353取模）。

　　输入一行三个整数：a，b，c（a，b，c ∈ [1,5000]）代表三个群岛（红蓝紫）的小岛数量。

　　输出一行一个整数：代表求解出的方案总数。

　　样例：1 1 1 --> 8

　　　　　1 2 2 --> 63

　　　　　1 3 5 --> 3264

　　　　　6 2 9 --> 813023575

解题思路：

　　本题主要考察对于组合数的计算能力。

　　使用二维数组存放组合数。

　　因为两个群岛之间，能造的桥的数量最多是较少附属岛屿的数量。

　　所以独立求解ab，ac，bc三个方案个数，并将三个数相乘取模即可。

　　易推出任意两个岛屿之间的方案总数公式：

　　　设两个岛屿群岛数量分别为 x，y(y <= x)；

　　　设任选k座桥（k ∈ [0,y]）；

　　　y群岛的方案共有 C(k,y)；

　　　对于x群岛，先拿出一座桥和y连上，有x个方案，再拿出一座桥继续连接，就只剩下(x - 1)个方案......

　　　所以x群岛的所有方案应为(x)*(x - 1)*...*(x - k + 1)，这其实就是A(k,x)种方案啦。

　　　所以在本次条件下，所求的方案数量为：Σ(k ∈ [0,y])(C(k,y) * A(k,x))。

　　由于要求出C(a,b)，C(a,c)，C(b,c)，所以必须满足a，b，c从大到小排列。

　　最后使用以上思路将三组结果求出使用同余模定理乘一下就好啦。

A C 代码：

 

import java.util.*;

public class Main{
    
    static long a = 0L;
    static long b = 0L;
    static long c = 0L;
    static long modulo = 998244353;
    static long C[][] = new long[5005][5005];
    static void init(){
        C[0][0] = 1;
        for (int i = 1;i <= 5000;i ++){
            C[i][0]= 1;
            for (int j = 1;j <= i;j ++){
                C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
                C[i][j] = C[i][j] % modulo;
            }
        }
    }
    public static void main(String[] args){
        init();
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            a = sc.nextLong();
            b = sc.nextLong();
            c = sc.nextLong();
            if(a < b){long t = a;a = b;b = t;}
            if(a < c){long t = a;a = c;c = t;}
            if(b < c){long t = c;c = b;b = t;}
            long tab = 1L;
            long tac = 1L;
            long tbc = 1L;
            long t = 1L;
            for(long i = a;i >= a - b + 1;i --){
                t = t * i;
                t = t % modulo;
                tab = tab + t * C[(int)b][(int)(a - i + 1)];
                //System.out.println("tab = " + tab);
                tab = tab % modulo;
            }
            t = 1L;
            for(long i = a;i >= a - c + 1;i --){
                t = t * i;
                t = t % modulo;
                tac = tac + t * C[(int)c][(int)(a - i + 1)];
                //System.out.println("tac = " + tac);
                tac = tac % modulo;
            }
            t = 1L;
            for(long i = b;i >= b - c + 1;i --){
                t = t * i;
                t = t % modulo;
                tbc = tbc + t * C[(int)c][(int)(b - i + 1)];
                //System.out.println("tbc = " + tbc);
                tbc = tbc % modulo;
            }
            long ans = (((tab * tac) % modulo) * tbc) % modulo;
            System.out.println(ans);
        }
    }
}