#include <iostream>

#include <vector>
using namespace std;

int countPairsWithShortestPath(int N, int X, int Y) {

vector<vector<int>> dp(N + 1, vector<int>(N + 1, 0));

for (int i = 1; i <= N; i++) {

for (int j = i + 1; j <= N; j++) {
if ((i <= X && j >= Y) || (j <= X && i >= Y)) {
dp[i][j] = 1;
dp[j][i] = 1;
}
else {
dp[i][j] = min(j - i, abs(X - i) + 1 + abs(Y - j));
dp[j][i] = dp[i][j];
}
}
}

vector<int> ans(N, 0);

for (int i = 1; i <= N; i++) {
for (int j = i + 1; j <= N; j++) {
ans[dp[i][j]]++;
}
}

return ans;
}

int main() {
int N, X, Y;
cin >> N >> X >> Y;

vector<int> result = countPairsWithShortestPath(N, X, Y);

 for (int i = 1; i <= N; i++) {
cout << result[i] << " ";
}

return 0;
}

include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;

// Function to find the diameter of the graph using BFS

int findDiameter(int g_nodes, vector<int>g_from,
vector<int>g_to) {

//Form adjacency matrix

vector<vector<int>>adj(g_nodes);
for(int i=0 ; i<g_from.size(); i++){
adj[g_from[i]].push_back(g_to[i]);
adj[g_to[i]].push_back(g_from[i]);
}

int diameter = 0;

// Perform BFS from each node to calculate the shortest path

for (int startNode = 0; startNode < n; ++startNode) {
vector<bool> visited(n, false);
vector<int> distance(n, 0);

queue<int> q;
q.push(startNode);
visited[startNode] = true;

while (!q.empty()) {
int current = q.front();
q.pop();

for (int k = 0 ; k<adj[current].size() ; k++) {

int neighbor = adj[current][k];
if (!visited[neighbor]) {
visited[neighbor] = true;
distance[neighbor] = distance[current] + 1;
q.push(neighbor);
}
}
}
 int maxDistance = *max_element(distance.begin(),
distance.end());
diameter = max(diameter, maxDistance);
}

return diameter;
}