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 Kotlin (1.0.0) (judge verdict: Accepted)

import java.util.*

fun main(args: Array<String>) = abc160d()

fun abc160d() {
    val (n, x, y) = readLine()!!.split(' ').map { it.toInt() }

    val graph = Array(n) {
        Vertex(
            it, (mutableSetOf<Int>() + (if (it != 0) setOf(it - 1) else setOf())
                    + if (it != n - 1) setOf(it + 1) else setOf()).toMutableSet()
        )
    }
    graph[x - 1].neighbor.add(y - 1)
    graph[y - 1].neighbor.add(x - 1)
    val count = IntArray(n)

    fun bfs(fromIndex: Int) {
        val queue = ArrayDeque(listOf(fromIndex to 0))
        val visited = mutableSetOf<Int>()

        while (queue.isNotEmpty()) {
            val (index, dist) = queue.poll()
            if (!visited.add(index)) continue

            count[dist]++
            graph[index].neighbor.filterNot { visited.contains(it) }
                .map { it to dist + 1 }.let { queue.addAll(it) }
        }
    }

    for (i in 0 until n) bfs(i)

    val answer = count.drop(1).map { it / 2 }.joinToString(System.lineSeparator())

    println(answer)
}

private data class Vertex(val index: Int, val neighbor: MutableSet<Int> = mutableSetOf())