Problem:
Score : 400 points

Problem Statement

We have an undirected graph G with N vertices numbered 1 to N and N edges as follows:

For each i=1,2,...,N-1, there is an edge between Vertex i and Vertex i+1.

There is an edge between Vertex X and Vertex Y.

For each k=1,2,...,N-1, solve the problem below:

Find the number of pairs of integers (i,j) (1 \leq i < j \leq N) such that the shortest distance between Vertex i and Vertex j in G is k.

Constraints

3 \leq N \leq 2 \times 10^3

1 \leq X,Y \leq N

X+1 < Y

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N X Y

Output

For each k=1, 2, ..., N-1 in this order, print a line containing the answer to the problem.

Sample Input 1

5 2 4

Sample Output 1

5
4
1
0

The graph in this input is as follows:

There are five pairs (i,j) (1 \leq i < j \leq N) such that the shortest distance between Vertex i and Vertex j is 1: (1,2)\,,(2,3)\,,(2,4)\,,(3,4)\,,(4,5).

There are four pairs (i,j) (1 \leq i < j \leq N) such that the shortest distance between Vertex i and Vertex j is 2: (1,3)\,,(1,4)\,,(2,5)\,,(3,5).

There is one pair (i,j) (1 \leq i < j \leq N) such that the shortest distance between Vertex i and Vertex j is 3: (1,5).

There are no pairs (i,j) (1 \leq i < j \leq N) such that the shortest distance between Vertex i and Vertex j is 4.

Sample Input 2

3 1 3

Sample Output 2

3
0

The graph in this input is as follows:

Sample Input 3

7 3 7

Sample Output 3

7
8
4
2
0
0

Sample Input 4

10 4 8

Sample Output 4

10
12
10
8
4
1
0
0
0

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

fn main() {
    let (n, x, y): (usize, usize, usize) =
        (read::<usize>(), read::<usize>() - 1, read::<usize>() - 1);
    let mut adjl = vec![vec![]; n];
    adjl[x].push(Edge { node: y, cost: 1 });
    adjl[y].push(Edge { node: x, cost: 1 });
    for i in 0..n - 1 {
        adjl[i].push(Edge {
            node: (i + 1) % n,
            cost: 1,
        });
        adjl[(i + 1) % n].push(Edge { node: i, cost: 1 });
    }
    // println!("{:?}", adjl);
    let mut ansv = vec![0; n];
    for i in 0..n {
        let distimes = shortest_path(&adjl, i);

        for j in i + 1..n {
            ansv[distimes[j].0] += distimes[j].1;
        }
    }
    for i in 1..n {
        println!("{}", ansv[i]);
    }
}

#[derive(Copy, Clone, Eq, PartialEq)]
struct State {
    cost: usize,
    position: usize,
    times: usize,
}

impl Ord for State {
    fn cmp(&self, other: &State) -> std::cmp::Ordering {
        other.cost.cmp(&self.cost)
    }
}

impl PartialOrd for State {
    fn partial_cmp(&self, other: &State) -> Option<std::cmp::Ordering> {
        Some(self.cmp(other))
    }
}

#[derive(Debug, Copy, Clone)]
struct Edge {
    node: usize,
    cost: usize,
}

fn shortest_path(adjl: &Vec<Vec<Edge>>, start: usize) -> Vec<(usize, usize)> {
    let mut distimes: Vec<(usize, usize)> = (0..adjl.len()).map(|_| (std::usize::MAX, 0)).collect();

    let mut heap = std::collections::BinaryHeap::new();

    distimes[start] = (0, 1);
    heap.push(State {
        cost: 0,
        position: start,
        times: 1,
    });

    while let Some(State {
        cost,
        position,
        times,
    }) = heap.pop()
    {
        if cost > distimes[position].0 {
            continue;
        }

        for edge in &adjl[position] {
            let next = State {
                cost: cost + edge.cost,
                position: edge.node,
                times: times,
            };
            // 次に行けるところがdistに書いたのより早く行ける
            if next.cost < distimes[next.position].0 {
                heap.push(next);
                distimes[next.position].0 = next.cost;
                distimes[next.position].1 = next.times;
            } else if next.cost == distimes[next.position].0 {
                heap.push(State {
                    cost: cost + edge.cost,
                    position: edge.node,
                    times: times + 1,
                });
            }
        }
    }
    distimes
}

// =========
#[allow(unused_imports)]
use std::cmp::{max, min};
#[allow(unused_imports)]
use std::collections::{HashMap, HashSet};
#[allow(unused_imports)]
use std::process::exit;

#[allow(dead_code)]
const MOD: usize = 1000000007;

fn read<T: std::str::FromStr>() -> T {
    use std::io::Read;
    let stdin = std::io::stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

// =========