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 Haskell (GHC 7.10.3) (judge verdict: Wrong Answer)

{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE TypeFamilies #-}
import           Data.Maybe
import           Data.Int
import           Data.List
import           Data.Char
  -- import qualified Data.Vector.Unboxing as VU
import qualified Data.Vector as V
import qualified Data.Vector.Mutable as VM
import qualified Data.Vector.Unboxed as VU
import qualified Data.Vector.Unboxed.Mutable as VUM
import qualified Data.ByteString.Char8 as BS
import           Data.List (scanl')
import           Data.IORef
import           Control.Monad
import           Control.Monad.ST
import           Control.Monad.State.Strict
import           Control.Applicative
import           Debug.Trace
import           Text.Printf


readInt = BS.readInt . BS.dropWhile isSpace
getVector f = VU.unfoldr f <$> BS.getLine
getIntVector = getVector readInt
getBSVector = getVector BS.uncons
getInt = readLn :: IO Int
getIntTuple = (\vec -> (vec VU.! 0, vec VU.! 1, vec VU.! 2)) <$> getIntVector

genGraph n x y = toUnDirectedGraph (n+1) . V.fromList $ (x,y) : zip [1..n-1] [2..n]

toDirectedGraph n input = V.create $ do
  graph <- VM.replicate n []
  V.forM_ input $ \(a,b) -> do
    VM.modify graph (b:) a
  return graph

toUnDirectedGraph n input = V.create $ do
  graph <- VM.replicate n []
  V.forM_ input $ \(a,b) -> do
    VM.modify graph (b:) a
    VM.modify graph (a:) b
  return graph

next :: V.Vector [Int] -> Int -> [Int]
next graph node = graph V.! node

dfs graph start goal = dfs' start []
  where
    next' = next graph
    dfs' now path
      | now == goal = return $ reverse $ now:path
      | otherwise = concatMap (\node -> dfs' node $ now:path) [x | x <- next' now, not (x `elem` path)]

bfs :: V.Vector [Int] -> Int -> Int -> Maybe [Int]
bfs graph start goal = bfs' [x : [start] | x <- next' start]
  where
    next' = next graph
    bfs' [] = fail "no Path"
    bfs' (path:queue)
      | goal == now = (return $ reverse path) `mplus` (bfs' queue)
      | otherwise = bfs' $ queue ++ [x : path | x <- next' now, not $ x `elem` path]
      where now = head path

solve' n x y = do
  let graph = genGraph n x y
  i <- [1..n-1]
  j <- [i+1..n]
  return $ (\n -> n - 1) . length . fromJust $ bfs graph i j

solve'' n x y = do
  let graph = genGraph n x y
  i <- [1..n-1]
  j <- [i+1..n]
  return $ fromJust $ bfs graph i j


solve n x y = VU.create $ do
  let graph = genGraph n x y
  dp <- VUM.replicate (n+1) (0 :: Int)
  forM_ [1..n-1] $ \i -> do
    forM_ [i+1 .. n] $ \j -> do
      -- let minPathLen = length . fromJust $ bfs graph i j
      -- trace (show minPathLen) $ VUM.modify dp (\n -> n+1) minPathLen
      let d1 = j - i
          d2 = abs (i-x) + abs (j-y) + 1
          k = min d1 d2
      VUM.modify dp (\n -> n+1) k
  return dp

main = do
  (n,x,y) <- getIntTuple
  let ans = solve n x y
  forM_ [1..n] $ \i -> do
    print $ ans VU.! i