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: Runtime Error)

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

class Program
{
    static Dictionary<int, Node> dic = new Dictionary<int, Node>();

    static void Main(string[] args)
    {
        var inputs = Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
        var n = inputs[0];
        var x = inputs[1];
        var y = inputs[2];

        // 元
        for(int i = 1; i <= n; i++)
        {
            if(i == 1)
            {
                dic[i] = new Node(new int[] { i + 1 },i);
            }
            else if(i == n)
            {
                dic[i] = new Node(new int[] { i - 1},i);
            }
            else
            {
                dic[i] = new Node(new int[] { i - 1, i + 1 },i);
            }
        }

        // 作る奴
        dic[x].Add(y);
        dic[y].Add(x);

        var nums = Enumerable.Range(1, n).ToArray();

        for(int i = 1; i < n; i++)
        {
            var count = 0;

            

            foreach (var e in Combination.Enumerate(nums, 2, false)){
                // e[0](dic:key) から e[1]への最短距離
                foreach (var item in dic.Values) item.isAlready = false;
                var first = e[0];
                var last = e[1];

                var saitan = dic[first].Serch(last,n, 0);

                if (saitan == i) count++;
            }

            Console.WriteLine(count);
        }
    }

    private class Node
    {
        public List<int> tonari;
        public int id;
        public bool isAlready = false;

        public Node(int[] tonari, int id)
        {
            this.tonari = tonari.ToList();
            this.id = id;
        }

        public void Add(int i)
        {
            tonari.Add(i);
            tonari.Distinct();
        }

        public int Serch(int target,int n, int count)
        {
            if (count > n) return int.MaxValue;
            if (id == target) return count;

            List<int> nums = new List<int>();
            dic[id].isAlready = true;
            foreach (var item in tonari)
            {
                if (dic[item].isAlready == false)
                {
                    nums.Add(dic[item].Serch(target, n, count + 1));
                }
            }

            return nums.Min();
        }
    }

    public static class Combination
    {
        public static IEnumerable<T[]> Enumerate<T>(IEnumerable<T> items, int k, bool withRepetition)
        {
            if (k == 1)
            {
                foreach (var item in items)
                    yield return new T[] { item };
                yield break;
            }
            foreach (var item in items)
            {
                var leftside = new T[] { item };

                // item よりも前のものを除く （順列と組み合わせの違い)
                // 重複を許さないので、unusedから item そのものも取り除く
                var unused = withRepetition ? items : items.SkipWhile(e => !e.Equals(item)).Skip(1).ToList();

                foreach (var rightside in Enumerate(unused, k - 1, withRepetition))
                {
                    yield return leftside.Concat(rightside).ToArray();
                }
            }
        }
    }
}

/*
 *
 *
 
    

    


    

 */