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# (.NET Core 3.1.201) (judge verdict: Time Limit Exceeded)

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


class Program
{
    static void Main(string[] args)
    {
        // 入力
        //var s = Console.ReadLine();
        //var n = int.Parse(Console.ReadLine());
        int[] nxy = Console.ReadLine().Split().Select(int.Parse).ToArray();
        var n = nxy[0];
        var x = nxy[1];
        var y = nxy[2];

        var g = new List<List<int>>();
        for (int i = 0; i < n; i++)
        {
            g.Add(new List<int>());
        }

        for (int i = 0; i < n - 1; i++)
        {
            g[i].Add(i + 1);
            g[i + 1].Add(i);
        }

        g[x - 1].Add(y - 1);
        g[y - 1].Add(x - 1);
        int[] ans = new int[n - 1];
        var dic = new Dictionary<Tuple<int, int>, int>() { };

        for (int i = 0; i < n; i++)
        {
            var que = new Queue<int>();
            var count = new Queue<int>();
            for (int k = 0; k < g[i].Count; k++)
            {
                que.Enqueue(g[i][k]);
                count.Enqueue(0);
            }
            while (que.Count > 0)
            {
                var tmp1 = que.Dequeue();
                var tmp2 = count.Dequeue();

                if (tmp1 == i) continue;

                if (!dic.ContainsKey(new Tuple<int, int>(i, tmp1)) && !dic.ContainsKey(new Tuple<int, int>(tmp1, i)))
                {
                    dic.Add(new Tuple<int, int>(i, tmp1), tmp2);
                }
                else
                {
                    if(dic.ContainsKey(new Tuple<int, int>(i, tmp1)))
                    {
                        if (dic[new Tuple<int, int>(i, tmp1)] > tmp2)
                        {
                            dic[new Tuple<int, int>(i, tmp1)] = tmp2;
                        }
                    }
                    else
                    {
                        if (dic[new Tuple<int, int>(tmp1, i)] > tmp2)
                        {
                            dic[new Tuple<int, int>(tmp1, i)] = tmp2;

                        }
                    }
                }

                if(tmp2 + 1 < n)
                {
                    for (int k = 0; k < g[tmp1].Count; k++)
                    {
                        if (g[tmp1][k] != tmp1)
                        {
                            que.Enqueue(g[tmp1][k]);
                            count.Enqueue(tmp2 + 1);
                        }
                    }
                }
            }
        }


        foreach (var item in dic)
        {
            ans[item.Value]++;
        }

        // 出力
        foreach (var item in ans)
        {
            Console.WriteLine(item);
        }
    }
}