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 C++14 (GCC 5.4.1) (judge verdict: Accepted)

#include<bits/stdc++.h>
using namespace std;

struct edge{
  int to;
  int cost;
};

using P = pair<int,int>;

const int MAX_N = 1e3*2;
const int INF = 1e9;
vector<edge> G[MAX_N];
vector<int> dist(MAX_N);

void dijkstra(int s, int n){
  priority_queue<P,vector<P>,greater<P>> PQ;
  for(int i=0; i<n; i++){
    dist[i] = INF;
  }
  dist[s] = 0;
  PQ.push(P(0,s));
  
  while(PQ.size()){
    P p = PQ.top();
    PQ.pop();
    int v = p.second; //from
    if(dist[v] < p.first){ //現在わかっている距離が更新できない
      continue;
    }
    for(int i=0; i<G[v].size(); i++){
      edge e = G[v][i];
      if(dist[e.to] > dist[v] + e.cost){
        dist[e.to] = dist[v] + e.cost;
        PQ.push(P(dist[e.to], e.to));
      }
    }
  }
}

int main(){
  int N, X, Y;
  cin >> N >> X >> Y;
  X--; Y--;
  for(int i=0; i<N-1; i++){
    edge add;
    add.to = i+1;
    add.cost = 1;
    G[i].push_back(add);
    add.to = i;
    G[i+1].push_back(add);
  }
  edge add;
  add.to = Y;
  add.cost = 1;
  G[X].push_back(add);
  vector<int> ans(N);
  for(int i=0; i<N; i++){
    dijkstra(i,N);
    for(int j=i+1; j<N; j++){
      ans.at(dist[j])++;
    }
  }
  for(int i=1; i<N; i++){
    cout << ans.at(i) << endl;
  }
}