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.42.0) (judge verdict: Accepted)

use proconio::input;
use std::collections::HashMap;

fn get_count_map(arr: &Vec<i64>) -> HashMap<i64, i64> {
    let mut hm: HashMap<i64, i64> = HashMap::new();

    for val_ref in arr.iter() {
        let val = *val_ref;
        match hm.get(val_ref) {
            Some(cnt_ref) => {
                let cnt: i64 = *cnt_ref + 1;
                hm.insert(val, cnt);
            }
            None => {
                hm.insert(val, 1);
            }
        }
    }

    hm
}

#[allow(non_snake_case)]
fn main() {
    input! {
        N: i64,
        Ds: [i64; N],
    }

    let MOD: i64 = 998244353;
    let hm = get_count_map(&Ds);

    if Ds[0] != 0 {
        println!("0");
        return;
    }

    if *hm.get(&0).unwrap() != 1 {
        println!("0");
        return;
    }

    // 距離0は自動的に決まるから除外
    let mut distances: Vec<i64> = Vec::new();

    for disntace_ref in hm.keys() {
        let distance = *disntace_ref;
        if distance != 0 {
            distances.push(distance);
        }
    }
    distances.sort();

    // 1から順に見ていこう
    let mut ans = 1;
    for distance_ref in distances.iter() {
        let distance = *distance_ref;

        match (hm.get(&distance), hm.get(&(distance-1))){
            (None, _) | (_, None) => {
                println!("0");
                return;
            }

            (Some(current), Some(last)) => {
                // eprintln!("{} {} {} {}", distance, last, current, ans);
                let mut po = 1;
                for _ in 0..*current {
                    po = (po * last) % MOD;
                }

                ans = (ans * po) % MOD;
            }
        }
    }

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