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 Python (3.4.3) (judge verdict: Time Limit Exceeded)

# coding: utf-8

from copy import deepcopy

import sys
sys.setrecursionlimit(100000)

N, X, Y = map(int, input().split())

# from time import time
# start = time()

# neighbor = {}
# for i in range(1, N):
#     neighbor[i] = [i+1]
# for i in range(X+4, Y):
#     neighbor[i] = [i-1, i+1]
# neighbor[X] = [X+1, Y]
# neighbor[Y] = [Y-1, Y+1]
# neighbor[N] = [] if Y < N else [N-1] 
# print(neighbor)

neighbor = {}
for i in range(1, X):
    neighbor[i] = [i+1]
for i in range(Y+1, N):
    neighbor[i] = [i+1]
for i in range(X+1, Y):
    neighbor[i] = [i-1, i+1]
neighbor[X] = [X+1, Y]
neighbor[Y] = [Y-1, Y+1]
neighbor[N] = [] if Y < N else [N-1]
# print(neighbor)

# print(neighbor)

# neighbor = {i: [i-1, i+1] for i in range(2, N)}
# neighbor[1] = [2]
# neighbor[N] = [N-1]
# neighbor[X].append(Y)
# neighbor[Y].append(X)

# appeared_st = set([])
appeared_st = [set([]) for _ in range(N+1)]
# appeared_st[0] = 0
n_k = [0] * N
s_t_dict = {}


# def rec(n, dist, s, k, appeared):
#     # print(appeared_st)
#     if dist == k:
#         # if k == 2:
#         #     input()
#         if s < n and n not in appeared_st[s]:
#             appeared_st[s].add(n)
#             appeared_st[0] += 1
#             # print(appeared_st)

#     toes = [node for node in neighbor[n] if node not in appeared]
#     for to in toes:
#         appeared_copy = deepcopy(appeared)
#         appeared_copy.add(to)
#         rec(to, dist+1, s, k, appeared_copy)


def rec(n, dist, s, limit, appeared):
    if s < n:
        ke = "{}.{}".format(s, n)
        if ke in s_t_dict:
            if dist < s_t_dict[ke]:
                n_k[s_t_dict[ke]] -= 1
                s_t_dict[ke] = dist
                n_k[dist] += 1
        else:
            s_t_dict[ke] = dist
            n_k[dist] += 1
            
    # if s < n and n not in appeared_st[s]:
    #     appeared_st[s].add(n)
    #     n_k[dist] += 1
    #     print(appeared_st)
    #     print(n_k)
    #     input()

    if dist == limit:
        return None

    toes = [node for node in neighbor[n] if node not in appeared]
    for to in toes:
        appeared_copy = deepcopy(appeared)
        appeared_copy.add(to)
        rec(to, dist+1, s, limit, appeared_copy)


for s in range(1, N):
    rec(s, 0, s, N-1, {s})

for k in range(1, N):
    print(n_k[k])

# for k in range(1, N):
#     tmp = appeared_st[0]

#     for s in range(1, N+1):
#         rec(s, 0, s, k, {s})

    # print(appeared_st[0] - tmp)

# print(appeared_st)
# print(len(appeared_st))
            
# print(time() - start)