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

#include<stdio.h>
#define QUEUE_LEN  2000
#define INIT_QUEUE (queue){.head_ind = 0,.len = 0}
#define INF 32700

typedef struct{
    int data[QUEUE_LEN];
    int head_ind,len;
}queue;

static inline void enqueue(queue *dest,int num){
    dest->data[(dest->head_ind + dest->len) % QUEUE_LEN] = num;
    dest->len++;
}

static inline int dequeue(queue *q){
    int res = q->data[q->head_ind];
    q->len--;
    q->head_ind++;
    q->head_ind %= QUEUE_LEN;
    return res;
}

int main(void){
    int n,x,y;
    scanf("%d %d %d",&n,&x,&y);
    x--;
    y--;
    int anscnt[n];
    for(int i = 0;i < n;i++)anscnt[i] = 0;
    for(int ns = 0;ns < n;ns++){
        int dist[n];
        for(int i = 0;i < n;i++)dist[i] = INF;
        dist[ns] = 0;
        queue quu = INIT_QUEUE;
        enqueue(&quu,ns);
        while(quu.len){
            int node = dequeue(&quu);
            if(node + 1 < n && dist[node + 1] == INF){
                dist[node + 1] = dist[node] + 1;
                enqueue(&quu,node+1);
            }
            if(node - 1 >= 0 && dist[node - 1] == INF){
                dist[node - 1] = dist[node] + 1;
                enqueue(&quu,node-1);
            }
            if(node == x && dist[y] == INF){
                dist[y] = dist[node] + 1;
                enqueue(&quu,y);
            }
            if(node == y && dist[x] == INF){
                dist[x] = dist[node] + 1;
                enqueue(&quu,x);
            }
        }
        for(int i = 0;i < n;i++)anscnt[dist[i]]++;
    }
    for(int i = 1;i < n;i++)printf("%d\n",anscnt[i] / 2);
    return 0;
}