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)

use std::vec::Vec;

fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}

fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>().split_whitespace().map(|e| e.parse().ok().unwrap()).collect()
}

fn read_touple<T: std::str::FromStr + Copy>() -> (T, T, T) {
  let v: Vec<T> = read_vec();
  assert_eq!(v.len(), 3);
  (v[0], v[1], v[2])
}

fn main() {
   let (n, x, y) = read_touple::<usize>();
   let mut g = vec![vec![]; n];
   for i in 0..n-1 {
     g[i].push(i+1);
     g[i+1].push(i);
   }

   g[x-1].push(y-1);
   g[y-1].push(x-1);

   let mut ans = vec![0; n-1];
   for i in 0..n {
     let dist = bfs_dist(n, &g, i);
     //println!("{:?}", dist);
     for d in dist {
       if d == std::usize::MAX {
         continue
       }
        ans[d] += 1;
     }
   }
   
   for a in ans {
     println!("{}", a/2);
   }
}

use ::std::collections::VecDeque;
use std::cmp::*;

//単一視点から目的のノードまでの最短距離、ただし全ての辺の重みが等しいグラフに限る
fn bfs_dist(n: usize, g: &Vec<Vec<usize>>, start: usize) -> Vec<usize> {
  let mut visit = vec![false; n];
  let mut q = VecDeque::new();
  let mut dist = vec![std::usize::MAX; n];

  //init
  visit[start] = true;
  q.push_back(start);

  while let Some(now) = q.pop_front() {

    for &e in &g[now] {
      if !visit[e] {
        visit[e] = true;
        dist[e] = min(dist[e], dist[now] + 1);
        q.push_back(e);
      }
    }
  }
  return dist;
}