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)

import heapq
import collections

N,X,Y = (int(i) for i in input().split())

graph = collections.defaultdict(list)
# X->Yの経路を追加
graph[X].append((1,Y))
# grpah[node_num] = [(cost,next_node_num)]
for i in range(1,N):
  graph[i].append((1,i+1))
  if i >=X and i <= Y:
    graph[i+1].append((1,i))

# 4-3-7 :min
# 5-4-3-7: not min
# 3(X)-4-5(i)-6-7(Y)
# (i-X+1) <= Y-i

# ans[i] = 最短経路がiである個数
ans = [0] * (N-1)
# Node 1 ~ N Nodeまでをループ
for i in range(1,N+1):
  # priority_queue : (cost, node_num)
  priority_queue = [(0,i)]
  # 探索したnode
  checked_node = {}

  while priority_queue:
    (cost, node_num) = heapq.heappop(priority_queue)
    if node_num in checked_node:
      continue
    else:
      if node_num >= i+1:
        ans[cost-1] += 1
      checked_node[node_num] = cost
      for next_cost,next_node_num in graph[node_num]:
        if next_node_num not in checked_node:
          heapq.heappush(priority_queue, (cost + next_cost, next_node_num))

for a in ans:
  print(a)