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: Time Limit Exceeded)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define INF 100
#define TRUE 1
#define FALSE 0

void Show(int N, int* m)
{
	for (int r = 0; r < N; r++)
	{
		for (int c = 0; c < N; c++)
		{
			printf("%4d", m[r * N + c]);
		}
		printf("\n");
	}
}

void calc(int N, int X, int Y)
{
	int* m = (int*)malloc(sizeof(int) * N * N);
	int* t = (int*)malloc(sizeof(int) * N);
	memset(t, 0, sizeof(int) * N);

	for (int r = 0; r < N * N; r++) m[r] = INF;
	for (int r = 0; r < N - 1; r++)
	{
		m[r * N + (r + 1)] = 1;
		m[(r + 1) * N + r] = 1;
	}
	m[X * N + Y] = 1;
	m[Y * N + X] = 1;
	//Show(N, m);
	for (int _ = 0; _ < N; _++)
	{
		int  flg = FALSE;
		memset(t, 0, sizeof(int) * N);

		for (int r = 0; r < N; r++)
		{
			for (int c = r+1; c < N; c++)
			{
				for (int k = 0; k < N; k++)
				{
					int p1 = r * N + c;
					int p2 = r * N + k;
					int p3 = k * N + c;
					if (m[p2] + m[p3] < m[p1])
					{
						flg = TRUE;
						m[p1] = m[p2] + m[p3];
					}
				}
				if (m[r * N + c] != INF)
				{
					m[c * N + r] = m[r * N + c];
					t[m[r * N + c]]++;
				}
			}
		}
		//Show(N, m);
		if (flg == FALSE) break;
	}

	for (int i = 1; i < N; i++)
	{
		printf("%d\n", t[i]);
	}

	if (m != NULL)   free(m);
	if (t != NULL)   free(t);
}

int main(void) {
	int i, n;
	char buf[1000];
	int N, X, Y;
	gets(buf, sizeof(buf));
	sscanf(buf, "%d %d %d\n", &N, &X, &Y);
	calc(N, X-1, Y-1);
	return 0;
}
//
//[200, 1, 2, 3, 4, 5, 5, 4, 5, 6]
//[1, 200, 1, 2, 3, 4, 4, 3, 4, 5]
//[2, 1, 200, 1, 2, 3, 3, 2, 3, 4]
//[3, 2, 1, 200, 1, 2, 2, 1, 2, 3]
//[4, 3, 2, 1, 200, 1, 2, 2, 3, 4]
//[5, 4, 3, 2, 1, 200, 1, 2, 3, 4]
//[5, 4, 3, 2, 2, 1, 200, 1, 2, 3]
//[4, 3, 2, 1, 2, 2, 1, 200, 1, 2]
//[5, 4, 3, 2, 3, 3, 2, 1, 200, 1]
//[6, 5, 4, 3, 4, 4, 3, 2, 1, 200]
//
//100   1   2   3   4   5   6   6   5   6
//1 100   1   2   3   4   5   5   4   5
//2   1 100   1   2   3   4   4   3   4
//3   2   1 100   1   2   3   3   2   3
//4   3   2   1 100   1   2   2   1   2
//5   4   3   2   1 100   1   2   2   3
//6   5   4   3   2   1 100   1   2   3
//6   5   4   3   2   2   1 100   1   2
//5   4   3   2   1   2   2   1 100   1
//6   5   4   3   2   3   3   2   1 100