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

using System;

using System.Linq;

using System.Collections.Generic;

using System.Numerics;



namespace hello_cs

{

    class Program

    {

        static void Main(string[] args)

        {

            var blank = " ";

            var ipt = System.Console.ReadLine().Split(blank.ToCharArray()).Select(a => int.Parse(a)).ToArray();



            var n = ipt[0];

            var x = ipt[1];

            var y = ipt[2];

            var com = new List<int>();



            for (var i = 1; i < n; i++)

            {

                for (var j = i + 1; j <= n; j++)

                {

                    var dis = 0;



                    // 前同士 or 後ろ同士

                    if (i >= y || j <= x)

                    {

                        dis = j - i;

                    }

                    // 前後の組み合わせ

                    else if (i <= x && j >= y)

                    {

                        dis = x - i + j - y + 1;

                    }

                    // 中同士

                    else if (i >= x && j <= y)

                    {

                        var rdis = j - i;

                        var ldis = i + (y - x + 1) - j;

                        dis = rdis <= ldis ? rdis : ldis;

                    }

                    // 前中の組み合わせ

                    else if (j <= y)

                    {

                        var rdis = j - x;

                        var ldis = x + (y - x + 1) - j;

                        dis = rdis <= ldis ? rdis : ldis;

                        dis += i < x ? x - i : 0;

                    }

                    // 中後の組み合わせ

                    else

                    {

                        var rdis = y - i;

                        var ldis = i + (y - x + 1) - y;

                        dis = rdis <= ldis ? rdis : ldis;

                        dis += j > y ? j - y : 0;

                    }

                    com.Add(dis);

                }

            }



            for (var i = 1; i < n; i++)

            {

                var cnt = com.Where(b => b == i).Count();

                System.Console.WriteLine(cnt);

            }



        }

    }

}