Problem:
Score : 600 points

Problem Statement

We have an integer sequence A of length N, where A_1 = X, A_{i+1} = A_i + D (1 \leq i < N ) holds.

Takahashi will take some (possibly all or none) of the elements in this sequence, and Aoki will take all of the others.

Let S and T be the sum of the numbers taken by Takahashi and Aoki, respectively. How many possible values of S - T are there?

Constraints

-10^8 \leq X, D \leq 10^8

1 \leq N \leq 2 \times 10^5

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N X D

Output

Print the number of possible values of S - T.

Sample Input 1

3 4 2

Sample Output 1

8

A is (4, 6, 8).

There are eight ways for (Takahashi, Aoki) to take the elements: ((), (4, 6, 8)), ((4), (6, 8)), ((6), (4, 8)), ((8), (4, 6))), ((4, 6), (8))), ((4, 8), (6))), ((6, 8), (4))), and ((4, 6, 8), ()).

The values of S - T in these ways are -18, -10, -6, -2, 2, 6, 10, and 18, respectively, so there are eight possible values of S - T.

Sample Input 2

2 3 -3

Sample Output 2

2

A is (3, 0). There are two possible values of S - T: -3 and 3.

Sample Input 3

100 14 20

Sample Output 3

49805

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

fn main() {
    let (r, w) = (std::io::stdin(), std::io::stdout());
    let mut sc = IO::new(r.lock(), w.lock());

    let n: usize = sc.read();
    let x: i64 = sc.read();
    let d: i64 = sc.read();

    let ans = solve(n, x, d);
    println!("{}", ans);
}

fn solve(n: usize, x: i64, d: i64) -> usize {
    if x == 0 && d == 0 {
        return 1;
    }
    if d == 0 {
        assert_ne!(x, 0);
        return n + 1;
    }
    assert_ne!(d, 0);

    if x == 0 {
        return n * n - n * (n + 1) / 2 + 1;
    }
    assert!(d != 0 && x != 0);

    let lcm = lcm(x.abs() as usize, d.abs() as usize);
    let a = lcm / (d.abs() as usize);
    let b = lcm / (x.abs() as usize);
    let mut group_sets = vec![vec![]; b];
    if (x < 0) == (d < 0) {
        // ad = bx
        for i in 0..(n + 1) {
            let (from, to) = if i == 0 {
                (0, 0)
            } else {
                ((i - 1) * i / 2, i * n - (i + 1) * i / 2)
            };
            let group_id = i % b;
            let add = (i / b * a) as i64;
            let (from, to) = (from as i64 + add, to as i64 + add);
            group_sets[group_id].push((from, to));
        }
    } else {
        // ad+bx=0
        for i in 0..(n + 1) {
            let (from, to) = if i == 0 {
                (0, 0)
            } else {
                ((i - 1) * i / 2, i * n - (i + 1) * i / 2)
            };
            let group_id = i % b;
            let add = (i / b * a) as i64;
            let (from, to) = (from as i64 - add, to as i64 - add);
            group_sets[group_id].push((from, to));
        }
    }

    let mut ans = 0;
    for set in group_sets.into_iter() {
        ans += calc(set);
    }

    ans
}

fn calc(mut set: Vec<(i64, i64)>) -> usize {
    set.sort();

    let mut ans = 0;

    let mut prev: Option<(i64, i64)> = None;

    for (from, to) in set.into_iter() {
        match prev {
            Some((prev_from, prev_to)) => {
                assert!(prev_from <= from);
                if prev_to >= to {
                    prev = Some((prev_from, prev_to));
                } else if prev_to >= from {
                    prev = Some((prev_from, to));
                } else {
                    ans += prev_to - prev_from + 1;
                    prev = Some((from, to));
                }
            }
            None => {
                prev = Some((from, to));
            }
        }
    }

    if let Some((from, to)) = prev {
        ans += to - from + 1;
    }
    assert!(ans >= 0);
    ans as usize
}

fn lcm(a: usize, b: usize) -> usize {
    let g = gcd(a, b);
    a / g * b
}

fn gcd(a: usize, b: usize) -> usize {
    if b == 0 {
        a
    } else {
        gcd(b, a % b)
    }
}

pub struct IO<R, W: std::io::Write>(R, std::io::BufWriter<W>);

impl<R: std::io::Read, W: std::io::Write> IO<R, W> {
    pub fn new(r: R, w: W) -> IO<R, W> {
        IO(r, std::io::BufWriter::new(w))
    }
    pub fn write<S: std::ops::Deref<Target = str>>(&mut self, s: S) {
        use std::io::Write;
        self.1.write(s.as_bytes()).unwrap();
    }
    pub fn read<T: std::str::FromStr>(&mut self) -> T {
        use std::io::Read;
        let buf = self
            .0
            .by_ref()
            .bytes()
            .map(|b| b.unwrap())
            .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r' || b == b'\t')
            .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r' && b != b'\t')
            .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()
    }
}