Problem:
Score : 300 points

Problem Statement

Given is an integer sequence D_1,...,D_N of N elements. Find the number, modulo 998244353, of trees with N vertices numbered 1 to N that satisfy the following condition:

For every integer i from 1 to N, the distance between Vertex 1 and Vertex i is D_i.

Notes

A tree of N vertices is a connected undirected graph with N vertices and N-1 edges, and the distance between two vertices are the number of edges in the shortest path between them.

Two trees are considered different if and only if there are two vertices x and y such that there is an edge between x and y in one of those trees and not in the other.

Constraints

1 \leq N \leq 10^5

0 \leq D_i \leq N-1

Input

Input is given from Standard Input in the following format:

N
D_1 D_2 ... D_N

Output

Print the answer.

Sample Input 1

4
0 1 1 2

Sample Output 1

2

For example, a tree with edges (1,2), (1,3), and (2,4) satisfies the condition.

Sample Input 2

4
1 1 1 1

Sample Output 2

0

Sample Input 3

7
0 3 2 1 2 2 1

Sample Output 3

24

Solution in Rust (1.15.1) (judge verdict: Accepted)

#![allow(non_snake_case)]

use std::io::Read;

const MOD: i64 = 998244353;

fn main() {
    let mut buf = String::new();
    std::io::stdin().read_to_string(&mut buf).unwrap();
    let mut iter = buf.split_whitespace();
    let n: usize = iter.next().unwrap().parse().unwrap();
    let mut ds: Vec<usize> = (0..n)
        .map(|_| iter.next().unwrap().parse().unwrap())
        .collect();

    let mut invalid = ds[0] != 0;
    for i in 1..n {
        if ds[i] == 0 {
            invalid = true;
        }
    }

    if invalid {
        println!("0");
    } else {
        ds.sort();
        let mut max = 0;
        let mut count: Vec<i64> = vec![0; n];
        for i in 0..n {
            max = std::cmp::max(max, ds[i]);
            count[ds[i]] += 1;
        }

        let mut res = 1;
        for i in 1..max + 1 {
            if count[i] == 0 {
                res = 0;
                break;
            }
            for _ in 0..count[i] {
                res *= count[i - 1];
                res %= MOD;
            }
        }

        println!("{}", res);
    }
}