2023年第十四届蓝桥杯JAVA B组 数组分割解题思路

试题 C: 数组分割

    问题描述
    小蓝有一个长度为 N 的数组 A = [A0, A1, . . .，AN−1]。现在小蓝想要从 A 对应的数组下标所构成的集合 I = {0, 1, 2, . . . , N − 1} 中找出一个子集 R1，那么 R1在 I 中的补集为 R2。记 S1 = ∑ r ∈ R1 Ar，S2 = ∑ r ∈ R2 Ar，我们要求 S1 和 S2 均为偶数，请问在这种情况下共有多少种不同的 R1。当 R1 或 R2 为空集时我们将S 1 或 S 2 视为 0。
    输入格式
    第一行一个整数 T，表示有 T 组数据。
    接下来输入 T 组数据，每组数据包含两行：第一行一个整数 N，表示数组A 的长度；第二行输入 N 个整数从左至右依次为 A0, A1, . . . , AN−1，相邻元素之间用空格分隔。
    输出格式
    对于每组数据，输出一行，包含一个整数表示答案，答案可能会很大，你需要将答案对 1000000007 进行取模后输出。
    样例输入
    2
    2
    6 6
    2
    1 6
    样例输出
    4
    0
    样例说明
    对于第一组数据，答案为 4。（注意：大括号内的数字表示元素在数组中的下标。）
    R1 = {0}, R2 = {1}；此时 S 1 = A0 = 6 为偶数, S 2 = A1 = 6 为偶数。
    R1 = {1}, R2 = {0}；此时 S 1 = A1 = 6 为偶数, S 2 = A0 = 6 为偶数。
    R1 = {0, 1}, R2 = {}；此时 S 1 = A0 + A1 = 12 为偶数, S 2 = 0 为偶数。
    R1 = {}, R2 = {0, 1}；此时 S 1 = 0 为偶数, S 2 = A0 + A1 = 12 为偶数。
    对于第二组数据，无论怎么选择，都不满足条件，所以答案为 0。
    评测用例规模与约定
    对于 20% 的评测用例，1 ≤ N ≤ 10。
    对于 40% 的评测用例，1 ≤ N ≤ 102。
    对于 100% 的评测用例，1 ≤ T ≤ 10, 1 ≤ N ≤ 103, 0 ≤ Ai ≤ 109。
 

   对于 100% 的评测用例，1 ≤ T ≤ 10, 1 ≤ N ≤ 103, 0 ≤ Ai ≤ 109。

对于此题思路如下(非官方题解）：        

        对于时间要求复杂度为O（n^3）；

        ①每组数据，都为整数，所以输入的数据不是奇数就是偶数，这样子奇数就能用1来表示，偶数就能用0来表示，因为奇数个1相加，和为奇数，偶数个1相加，和为偶数，而对于0来说无论多少个0相加，和均为0（即偶数）。用两个变量num1,num0记录1和0的数量。

        

Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int num1=0,num0=0;
for (int i=0;i<n;i++){
    int temp=0;
    if ((temp=sc.nextInt()) %2 ==0){
        num0++;
    }else{
        num1++;
    }
}

        ②接下来讨论数组分割：数组分割成A1和A2两部分，因为A1与A2互为补集，所以得出A1便得出A2，全集S为整个数组。通俗地讲A2=S-A1。题目要求A1中的和与A2中的和均为偶数。

        ③当得知以上条件后，我们只需要：

                1.枚举A1集合中元素的个数i，n-i 就是 A2的元素个数;

                2.枚举A1中奇数的个数（即1的个数）j，num1-j便是A2中奇数的个数。对于偶数来说，但是因为无论多少个偶数相加均为偶数，所以当A1中的1的个数（即奇数的个数）j为偶数，并且num1-j为偶数时，就是一种答案。

                3.满足第一步和第二步之后，只需要知道A1在元素个数为i,其中的奇数个数为j时，有多少种组合，便可求解答案。

                这是一个排列组合的问题。

      代码：         

long ans=0;
//枚举A1集合中的个数i
for (int i=0;i<=n;i++){
//枚举A1集合中奇数的个数，其中奇数个数j要同时小于A1集合元素个数i和奇数的总数nums1
    for (int j=0;j<=num1 && j<=i;j+=2){
//num1-j表示A2中奇数的个数，i-j表示A1中偶数的个数，i-j必须小于等于偶数个数的总数
        if ((num1-j) % 2==0 && (i-j)<=num0){
            ans+=combination(num1,j)*combination(num0,i-j);
            ans %= 1000000007;
        }
    }
}
System.out.println(ans);

//求排列组合，表示从down个数中选up个数有多少种组合，即： up
//                                               C 
//                                                down                
private static long combination(int down,int up){
    if (up>down/2){
        up=down-up;
    }
    int fenzi=1;
    int fenmu=1;
    for (int i=0;i<up;i++){
        fenzi*=down;    
        down--;
    }
    for (int i=1;i<=up;i++){
        fenmu*=i;    
    }
    
    return (fenzi/fenmu)%1000000007;
}

完整代码

import java.util.Scanner;

public class Main{
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int t=sc.nextInt();
        for (int z=0;z<t;z++){
            int n=sc.nextInt();
            int num1=0,num0=0;
            for (int i=0;i<n;i++){
                int temp=0;
                if ((temp=sc.nextInt()) %2 ==0){
                    num0++;
                }else{
                    num1++;
                }
            }
            long ans=0;
            for (int i=0;i<=n;i++){
                for (int j=0;j<=num1 && j<=i;j+=2){
                    if ((num1-j) % 2==0 && (i-j)<=num0){
                        ans+=combination(num1,j)*combination(num0,i-j);
                        ans %= 1000000007;
                    }
                }
            }
            System.out.println(ans);
        }


    }
    private static long combination(int down,int up){
        if (up>down/2){
            up=down-up;
        }
        int fenzi=1;
        int fenmu=1;
        for (int i=0;i<up;i++){
            fenzi*=down;
            down--;
        }
        for (int i=1;i<=up;i++){
            fenmu*=i;
        }

        return (fenzi/fenmu)%1000000007;
    }
}

算法缺陷：

                计算排列组合时，计算分子的阶乘时，有可能导致long型范围溢出。

优化：

        利用空间换时间。

              计算阶乘时，有可能重复计算，可以用一个二维数组，存储已经算过的排列组合，即缓存思想。

private static int[][] cache=new int[110][110];
    private static long combination(int down,int up){
        if (cache[down][up]!=0) return cache[down][up];
        int x=down,y=up;
        if (up>down/2){
            up=down-up;
        }
        int fenzi=1;
        int fenmu=1;
        for (int i=0;i<up;i++){
            fenzi*=down;
            down--;
        }
        for (int i=1;i<=up;i++){
            fenmu*=i;
        }
        cache[x][y]=(fenzi/fenmu)%1000000007;
        return cache[x][y];
    }