Problem:
Score : 600 points

Problem Statement

You are given N integers. The i-th integer is a_i.
Find the number, modulo 998244353, of ways to paint each of the integers red, green or blue so that the following condition is satisfied:

Let R, G and B be the sums of the integers painted red, green and blue, respectively. There exists a triangle with positive area whose sides have lengths R, G and B.

Constraints

3 \leq N \leq 300

1 \leq a_i \leq 300(1\leq i\leq N)

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
a_1
:
a_N

Output

Print the number, modulo 998244353, of ways to paint each of the integers red, green or blue so that the condition is satisfied.

Sample Input 1

4
1
1
1
2

Sample Output 1

18

We can only paint the integers so that the lengths of the sides of the triangle will be 1, 2 and 2, and there are 18 such ways.

Sample Input 2

6
1
3
2
3
5
2

Sample Output 2

150

Sample Input 3

20
3
1
4
1
5
9
2
6
5
3
5
8
9
7
9
3
2
3
8
4

Sample Output 3

563038556

Solution in Rust (1.15.1) (judge verdict: Time Limit Exceeded)

use std::collections::BTreeMap;

const MOD: u32 = 998244353;

fn main() {
    let s = std::io::stdin();
    let mut sc = Scanner { stdin: s.lock() };

    let n = sc.read();
    let a: Vec<u32> = sc.vec(n);
    let sum: u32 = a.iter().sum::<u32>();
    let upper_bound = sum / 2 + 1;

    let mut map: BTreeMap<(u32, u32), u32> = BTreeMap::new();
    map.insert((0, 0), 1);
    let mut cur = 0;
    for a in a.into_iter() {
        let mut next = BTreeMap::new();
        for ((r, g), c) in map.into_iter() {
            let b = cur - r - g;

            if r + a < upper_bound {
                let x: &mut u32 = next.entry((r + a, g)).or_insert(0);
                *x += c;
                if *x >= MOD {
                    *x -= MOD;
                }
            }
            if g + a < upper_bound {
                let x: &mut u32 = next.entry((r, g + a)).or_insert(0);
                *x += c;
                if *x >= MOD {
                    *x -= MOD;
                }
            }
            if b + a < upper_bound {
                let x: &mut u32 = next.entry((r, g)).or_insert(0);
                *x += c;
                if *x >= MOD {
                    *x -= MOD;
                }
            }
        }
        map = next;
        cur += a;
    }

    let mut ans = 0;
    for ((r, g), c) in map.into_iter() {
        let b = sum - r - g;
        if r + g > b && r + b > g && b + g > r {
            ans += c;
            if ans >= MOD {
                ans -= MOD;
            }
        }
    }
    println!("{}", ans);
}

pub struct Scanner<R> {
    stdin: R,
}

impl<R: std::io::Read> Scanner<R> {
    pub fn read<T: std::str::FromStr>(&mut self) -> T {
        use std::io::Read;
        let buf = self
            .stdin
            .by_ref()
            .bytes()
            .map(|b| b.unwrap())
            .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r')
            .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r')
            .collect::<Vec<_>>();
        unsafe { std::str::from_utf8_unchecked(&buf) }
            .parse()
            .ok()
            .expect("Parse error.")
    }
    pub fn vec<T: std::str::FromStr>(&mut self, n: usize) -> Vec<T> {
        (0..n).map(|_| self.read()).collect()
    }
    pub fn chars(&mut self) -> Vec<char> {
        self.read::<String>().chars().collect()
    }
}