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)

use std::io::Read;

const MOD : u64 = 998_244_353;

fn pow(a: u64, p: u64) -> u64 {
    if p == 0 { 1 }
    else {
        let mut res = pow(a, p/2);
        res = (res * res) % MOD;
        if p%2 == 1 { res = (res * a) % MOD; }
        res
    }
}

fn solve(cnt: Vec<u64>, num: u64) -> u64 {
    if cnt[0] != 1 { return 0; }
    if num == 1 { return 1; }
    let mut res = 1;
    let mut sum = 1;
    for i in 1..cnt.len() {
        if cnt[i] == 0 { return 0; }
        res = res * pow(cnt[i-1], cnt[i]) % MOD;
        sum += cnt[i];
        if sum == num { break; }
    }
    res
}

fn main() {
    let mut buf = String::new();
    std::io::stdin().read_to_string(&mut buf).ok();
    let mut it = buf.split_whitespace();
    let n = it.next().unwrap().parse::<usize>().unwrap();
    let mut cnt = vec![0; n];
    let mut valid = true;
    for i in 0..n {
        let idx = it.next().unwrap().parse::<usize>().unwrap();
        if (i == 0)^(idx == 0) { valid = false; }
        cnt[idx] += 1;
    }
    println!("{}", if valid { solve(cnt, n as u64) } else { 0 });
}