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# (Mono 4.6.2.0) (judge verdict: Accepted)

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

namespace AtCoder
{
	public class ABC
	{
		static readonly int mod = 1000000007;  // 10^9+7

		static void Main(string[] args)
		{
			//System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch(); sw.Start();
			//Console.SetOut(new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false });


			//string s = Console.ReadLine();
			//int x = int.Parse(Console.ReadLine());
			//long x = long.Parse(Console.ReadLine());
			int[] vs = Console.ReadLine().Split().Select(int.Parse).ToArray();
			//long[] vs = Console.ReadLine().Split().Select(long.Parse).ToArray();
			int n = vs[0];
			int x = vs[1];
			int y = vs[2];
			int[,] g = new int[n + 1, 3];
			for (int i = 1; i <= n; i++) {
				if (i > 1) {
					g[i, 0] = i - 1;
				}
				if (i < n) {
					g[i, 1] = i + 1;
				}
				if (i == x) {
					g[i, 2] = y;
				}
				if (i == y) {
					g[i, 2] = x;
				}
			}

			int[,] distance = new int[n + 1, n + 1];
			Queue<Tuple> queue = new Queue<Tuple>();
			for (int from = 1; from <= n; from++) {
				queue.Clear();
				queue.Enqueue(new Tuple() { n = from, d = 0 });

				while (queue.Count > 0) {
					Tuple tup = queue.Dequeue();
					for (int j = 0; j < 3; j++) {
						if (g[tup.n, j] > 0 && g[tup.n, j] != from) {
							int to = g[tup.n, j];
							if (distance[from, to] == 0 || tup.d + 1 < distance[from, to]) {
								distance[from, to] = tup.d + 1;
								//System.Diagnostics.Debug.WriteLine($"{from} -> {to} : {tup.d + 1}");
								queue.Enqueue(new Tuple() { n = to, d = tup.d + 1 });
							}
						}
					}
				}
				//System.Diagnostics.Debug.WriteLine("--");
			}

			int[] ans = new int[n - 1];
			for (int i = 1; i < n + 1; i++) {
				for (int j = i + 1; j < n + 1; j++) {
					ans[distance[i, j] - 1]++;
				}
			}
			for (int i = 0; i < n - 1; i++) {
				Console.WriteLine(ans[i]);
			}


			//Console.Out.Flush();
			//System.Diagnostics.Debug.WriteLine(sw.Elapsed);
		}
	}

	public class Tuple
	{
		public int n;
		public int d;
	}
}