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: Wrong Answer)

using System;
using System.Collections.Generic;
using System.Linq;

namespace AtCoder
{
	class Program
	{
		static void Main(string[] args)
		{
            var firstLine = Console.ReadLine().Split(' ').Select(value => int.Parse(value)).ToList();
			var n = firstLine[0];
			var x = firstLine[1] - 1;
			var y = firstLine[2] - 1;

			var normalPath = new List<int>();
			var routeAPath = new List<int>();
			var routeBPath = new List<int>();

			for (int i = 0; i < n; i++)
			{
				normalPath.Add(i);

				if (i <= x || i >= y)
				{
					routeAPath.Add(i);
				}

				if(i <= x || y == i)
				{
					routeBPath.Add(i);
				}
			}

			for(int i = y - 1; i > x; i--)
			{
				routeBPath.Add(i);
			}

			for(int i = x; i < n; i++)
			{
				if(i == x || i >= y)
				{
					routeBPath.Add(i);
				}
			}

			var normalDistance = new List<List<int>>();
			var routeADistance = new List<List<int>>();
			var routeBDistance = new List<List<int>>();
			var answer = new Dictionary<int, int>();

			for (int i = 0; i < n; i++)
			{
				normalDistance.Add(new List<int>());
				routeADistance.Add(new List<int>());
				routeBDistance.Add(new List<int>());
				if (i != n - 1)
				{
					answer.Add(i + 1, 0);
				}

				for (int j = 0; j < n; j++)
				{
					normalDistance[i].Add(int.MaxValue);
					routeADistance[i].Add(int.MaxValue);
					routeBDistance[i].Add(int.MaxValue);
				}
			}

			var normalLength = normalPath.Count();
			for(int i = 0; i < normalLength - 1; i++)
			{
				for(int j = i + 1; j < normalLength; j++)
				{
					normalDistance[normalPath[i]][normalPath[j]] = j - i;
				}
			}

			var routeALength = routeAPath.Count();
			for (int i = 0; i < routeALength - 1; i++)
			{
				for (int j = i + 1; j < routeALength; j++)
				{
					int source, destination;
					if (routeAPath[i] < routeAPath[j])
					{
						source = routeAPath[i];
						destination = routeAPath[j];
					}
					else
					{
						source = routeAPath[j];
						destination = routeAPath[i];
					}
					routeADistance[source][destination] = Math.Min(routeADistance[source][destination], j - i);
				}
			}

			var routeBLength = routeBPath.Count();
			for (int i = 0; i < routeBLength - 1; i++)
			{
				for (int j = i + 1; j < routeBLength; j++)
				{
					int source, destination;
					if(routeBPath[i] < routeBPath[j])
					{
						source = routeBPath[i];
						destination = routeBPath[j];
					}
					else
					{
						source = routeBPath[j];
						destination = routeBPath[i]; 
					}
					routeBDistance[source][destination] = Math.Min(routeBDistance[source][destination], j - i);
				}
			}

			for(int i = 0; i < n; i++)
			{
				for(int j = i + 1; j < n; j++)
				{
					answer[Math.Min(normalDistance[i][j], Math.Min(routeADistance[i][j], routeBDistance[i][j]))]++;
				}
			}

			foreach (var value in answer.Values)
			{
				Console.WriteLine(value);
			}
		}
	}
}