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 Java8 (OpenJDK 1.8.0) (judge verdict: Accepted)


import java.util.ArrayList;
import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);

		int n = sc.nextInt();
		int x = sc.nextInt() - 1;
		int y = sc.nextInt() - 1;

		@SuppressWarnings("unchecked")
		ArrayList<Edge> edges[] = new ArrayList[n];

		for(int i = 0; i < n; i++){
			if(edges[i] == null){
				edges[i] = new ArrayList<Edge>();
			}
		}
		
//		int matrix[][] = new int[n][n];
//		for(int i = 0; i < n; i++){
//			Arrays.fill(matrix[i], INF);
//		}

		for(int i = 0; i < n - 1; i++){
			int from = i;
			int to = i + 1;
			int cost = 1;

//			matrix[from][to] = cost;
//			matrix[to][from] = cost;
			
			edges[from].add( new Edge(to, cost));
			edges[to].add(new Edge(from, cost));
		}
		edges[x].add( new Edge(y, 1));
		edges[y].add(new Edge(x, 1));

//		matrix[x][y] = 1;
//		matrix[y][x] = 1;
//
//		solve(matrix);
		solve(edges, n);
	}

	//	static final int INF = 10_000_001;

	static void solve(ArrayList<Edge>[] edges,  int n){
		int result[] = new int[n + 1];
		
		for(int I = 0; I < n; I++) {
			//xからそれぞれのfarmへの帰り道の最短距離
			int[] dist = dijkstra(edges, I, n);

//			for(int i = 0; i < n; i++){
//				if(dist[i] == INF){
//					System.out.println("INF");
//				}
//				else {
//					System.out.println(dist[i]);
//				}
//			}
			
			for(int i = 0; i < n; i++) {
				result[(int)dist[i]]++;
			}
		}
		
		for(int i = 1; i <= n - 1; i++) {
			System.out.println(result[i]/2);
		}
	}
	
	static void solve(int matrix[][]){
		long[][] dist = warshallFloyd(matrix);

		int n = matrix.length;

		int result[] = new int[n + 1];
		for(int i = 0; i < n; i++){
			for(int j = 0; j < n; j++){
				if(j != 0){
					//					System.out.print(" ");
				}
				//				System.out.print(dist[i][j]);
			}
			//			System.out.println();
		}

		for(int i = 0; i < n; i++) {
			for(int j = i + 1; j < n; j++) {
				result[(int)dist[i][j]]++;
			}
		}

		for(int i = 1; i <= n - 1; i++) {
			System.out.println(result[i]);
		}
	}

	static final int INF = Integer.MAX_VALUE;


	static long[][] warshallFloyd(int[][] matrix){
		int n = matrix.length;

		long[][] dist = new long[n][n];

		for(int i = 0; i < n; i++){
			for(int j = 0; j < n; j++){
				if(i == j){
					dist[i][j] = 0;
				}
				else {
					dist[i][j] = matrix[i][j];
				}
			}
		}

		for(int k = 0; k < n; k++){
			for(int i = 0; i < n; i++){
				for(int j = 0; j < n; j++){
					if(dist[i][k] == INF || dist[k][j] == INF){
						continue;
					}
					dist[i][j] = Math.min(dist[i][j], dist[i][k] + dist[k][j]);
					//					System.out.println("test "+dist[i][j]);
				}
			}
		}

		return dist;
	}
	//ダイクストラ法
	static int[] dijkstra(ArrayList<Edge>[] edges, int s, int n){
		//			if(n == 1){
		//				return new int[]{0};
		//			}

		PriorityQueue<Distance> que = new PriorityQueue<Distance>();
		int[] dist = new int[n];

		Arrays.fill(dist, INF);
		dist[s] = 0;
		que.add(new Distance(0, s));

		while(!que.isEmpty()){
			Distance tmpDist = que.poll();
			int tmpV = tmpDist.id;

			if(dist[tmpV] < tmpDist.dist){
				continue;
			}
			//				System.out.println(tmpV);
			for(int i = 0; i < edges[tmpV].size() ; i++){
				//					System.out.println(i);
				Edge e = (Edge) edges[tmpV].get(i);
				if(dist[e.to] > dist[tmpV] + e.cost){
					dist[e.to] = dist[tmpV] + e.cost;
					que.add(new Distance(dist[e.to], e.to));
				}
			}
		}

		return dist;
	}
}

class Distance implements Comparable<Distance>{
	int dist;
	int id;

	Distance(int dist, int id){
		this.dist = dist;
		this.id = id;
	}

	@Override
	public int compareTo(Distance d) {
		return this.dist - d.dist;
	}
}

class Edge {
	int to;
	int cost;

	Edge(int to, int cost){
		this.to = to;
		this.cost = cost;
	}
}