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 s: String = {
        let mut s = String::new();
        std::io::stdin().read_line(&mut s).unwrap();
        s.trim_right().to_owned()
    };
    let (n, x, y) = {
        let mut ws = s.split_whitespace();
        let a: i64 = ws.next().unwrap().parse().unwrap();
        let b: i64 = ws.next().unwrap().parse().unwrap();
        let c: i64 = ws.next().unwrap().parse().unwrap();
        (a, b, c)
    };

    let mut table = vec![];
    for i in 0..n - 1 {
        let mut row = vec![];
        for j in i + 1..n {
            row.push((i - j).abs())
        }
        table.push(row);
    }

    {
        let add_path = table
            .get_mut((x - 1) as usize)
            .unwrap()
            .get_mut((y - x - 1) as usize)
            .unwrap();
        *add_path = 1;
    }

    // 同じ行に反映する
    // 左のセルに反映する
    for index in 0..(y - x - 1) as usize {
        let base = {
            *table
                .get((x - 1) as usize)
                .unwrap()
                .get((y - x - 1) as usize - index)
                .unwrap()
        };
        let row = table.get_mut((x - 1) as usize).unwrap();
        let cell = row.get_mut((y - x - 2) as usize - index).unwrap();
        *cell = std::cmp::min(*cell, base + 1);
    }
    // 右のセルに反映する
    for index in (y - x) as usize..(n - 1 - (x - 1)) as usize {
        let base = { *table.get((x - 1) as usize).unwrap().get(index - 1).unwrap() };
        let row = table.get_mut((x - 1) as usize).unwrap();
        let cell = row.get_mut(index).unwrap();
        *cell = std::cmp::min(*cell, base + 1);
    }

    // 上の行に反映する
    // println!("up");
    for row_index in 0..(x - 1) as usize {
        let rev_row_index = (x - 1) as usize - row_index;
        // println!("r{}", rev_row_index);
        let base_row = table.get(rev_row_index).unwrap().to_owned();
        let mut column: usize = 0;
        for value in table.get_mut(rev_row_index - 1).unwrap() {
            // println!("c{}", column);
            let base_value = match column {
                0 => n,
                _ => *base_row.get(column - 1).unwrap(),
            };
            // println!("b{}", base_value);
            *value = std::cmp::min(*value, base_value + 1);
            column += 1;
        }
    }

    // 下の行に反映する
    for row_index in x as usize..(n - 1) as usize {
        // println!("r{}", row_index);
        let base_row = table.get(row_index - 1).unwrap().to_owned();
        let mut column: usize = 1;
        for value in table.get_mut(row_index).unwrap() {
            // println!("c{}", column);
            let base_value = *base_row.get(column).unwrap();
            // println!("b{}", base_value);
            *value = std::cmp::min(*value, base_value + 1);
            column += 1;
        }
    }

    // println!("{:?}", table);

    // 集計する
    let mut sum = vec![0; (n - 1) as usize];
    for row in table {
        for cell in row {
            let value = sum.get_mut((cell - 1) as usize).unwrap();
            *value += 1;
        }
    }

    for v in sum {
        println!("{}", v);
    }
}

// 全ての組は n(n-1)/2 = n^2/2 - n/2

// 追加の辺がない場合
// 1 -> n-1
// 2 -> n-2
// 3 -> n-3
// ...
// n-1 -> 1