题目链接: https://ac.nowcoder.com/acm/contest/21791/E

题意:

岛上有三种颜色的岛屿，分别是红色、蓝色和紫色。岛群分别由 a, b 和 c 个分别为红色, 蓝色和紫色的岛组成

在一些 (可能全部或没有) 岛屿之间建立了桥梁。一座桥双向连接两个不同的岛，长度为1。对于任意两个相同颜色的岛，要么不能通过桥相互到达，要么它们之间的最短距离至少为 3

思路: 由题意可知, 同一个岛群的岛屿不能建立桥, 两个相同颜色的岛屿不能连接到一个颜色不同的岛屿, 两个岛想要连边, 那么连边数最大为min(a, b), 桥的个数为0, 1, 2…, min(a, b)都是合法的, 每次从两个岛中分别取 i 个点, 取法共 C a i ∗ C b i C_a^i * C_b^i Cai​∗Cbi​ , 这些点连接方式数为 i ! i! i!, 两个岛的方案书就是 C a i ∗ C b i ∗ i ! C_a^i * C_b^i * i! Cai​∗Cbi​∗i!

对于 bc 和 ac 是同理的, 因为三个岛的连线是互不干扰的

最后就是 逆元求组合数

AC代码

public class Main {
    public static int mod = 998244353;
    public static long[] invFact = new long[5005];
    public static long[] fact = new long[5005];

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int a, b, c;
        getInvArray();
        a = in.nextInt();
        b = in.nextInt();
        c = in.nextInt();
        int mi = Math.min(a, b);
        long ans1 = 1, ans2 = 1, ans3 = 1;
        // 处理ab岛屿的方案数
        for(int i = 1; i <= mi; i++) {
            // 注意这里 tmp 和 ans1 是相加操作
            long tmp = 1;
            tmp *= (fact[a] * invFact[i] % mod * invFact[a - i] % mod);
            tmp %= mod;
            tmp *= (fact[b] * invFact[i] % mod * invFact[b - i] % mod);
            tmp %= mod;
            tmp *= fact[i];
            tmp %= mod;
            ans1 += tmp;
            ans1 %= mod;
        }
        mi = Math.min(c, b);
        for(int i = 1; i <= mi; i++) {
            long tmp = 1;
            tmp *= (fact[c] * invFact[i] % mod * invFact[c - i] % mod);
            tmp %= mod;
            tmp *= (fact[b] * invFact[i] % mod * invFact[b - i] % mod);
            tmp %= mod;
            tmp *= fact[i];
            tmp %= mod;
            ans2 += tmp;
            ans2 %= mod;
        }
        mi = Math.min(c, a);
        for(int i = 1; i <= mi; i++) {
            long tmp = 1;
            tmp *= (fact[c] * invFact[i] % mod * invFact[c - i] % mod);
            tmp %= mod;
            tmp *= (fact[a] * invFact[i] % mod * invFact[a - i] % mod);
            tmp %= mod;
            tmp *= fact[i];
            tmp %= mod;
            ans3 += tmp;
            ans3 %= mod;
        }
        System.out.println((ans1 * ans2 % mod * ans3 % mod) % mod);

        in.close();
    }

    public static Long ksm(Long n, Long m) {
        Long ans = 1L;
        while(m > 0) {
            if((m & 1) == 1) {
                ans *= n;
                ans %= mod;
            }
            n = n * n % mod;
            n %= mod;
            m >>= 1;
        }
        return ans % mod;
    }

    public static Long getInv(Long x) {
        return ksm(x, (mod - 2) * 1L);
    }

    public static void getInvArray() {
        fact[0] = 1L;
        invFact[1] = invFact[0] = 1L;
        for(int i = 1; i < 5005; i++) {
            fact[i] = i * fact[i - 1] % mod;
        }
        for(int i = 2; i < 5005; i++) {
            invFact[i] = invFact[i - 1] * getInv(i * 1L) % mod; // 阶乘逆元
        }
    }

}