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++14 (GCC 5.4.1) (judge verdict: Accepted)

#include <bits/stdc++.h>

#define endl '\n'
#define fi first
#define se second
#define pb push_back
#define debug(x) cout << "[debug] " << #x << ": " << x << endl
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
typedef pair<ll, ll> PLL;
const int MOD = 1e9 + 7;
const int maxn = 1e6 + 5;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
const double eps = 1e-8;
const double PI = acos(-1.0);

void header() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
}

struct Edge {
	int to, dist, next;
};

struct HeapNode {
	int d, u;
	HeapNode(int d, int u) : d(d), u(u) {}
	bool operator < (const HeapNode &rhs) const {
		return d > rhs.d;
	}
};

int head[maxn];
int tot;

struct Dijkstra {
	int n;
	Edge edges[maxn]; // 注意是maxm 最大边数
	int d[maxn];
	bool done[maxn];

	void init(int n) {
		this->n = n;
		for (int i = 0; i < n; i++) {
			d[i] = inf;
			done[i] = 0;
		}
	}

	void addEdge(int from, int to, int dist) {
		edges[tot].to = to;
		edges[tot].dist = dist;
		edges[tot].next = head[from];
		head[from] = tot++;
	}

	void dijkstra(int s) {
		priority_queue<HeapNode> Q;
		d[s] = 0;
		Q.push(HeapNode(0, s));
		while (Q.size()) {
			HeapNode x = Q.top();
			Q.pop();
			int u = x.u;
			if (done[u]) continue;
			done[u] = true;
			for (int i = head[u]; i != -1; i = edges[i].next) {
				int id = edges[i].to;
				if (d[id] > d[u] + edges[i].dist) {
					d[id] = d[u] + edges[i].dist;
					Q.push(HeapNode(d[id], id));
				}
			}
		}
	}
}dj;

ll res[maxn];

void solve() {
    memset(head, -1, sizeof(head));
    tot = 0;
    ll n, x, y, tmp = 0;
    cin >> n >> x >> y;
    dj.init(n + 1);
    for (int i = 1; i < n; i++) dj.addEdge(i, i + 1, 1), dj.addEdge(i + 1, i, 1);
    dj.addEdge(x, y, 1);
    dj.addEdge(y, x, 1);
    for (int i = 1; i <= n; i++) {
        dj.dijkstra(i);
        for (int j = 1; j <= n; j++) res[dj.d[j]]++;
        dj.init(n + 1);
    }
    for (int i = 1; i < n; i++) cout << res[i] / 2 << endl;
}

int main() {
	header();
	solve();
	return 0;
}