Problem:
Score : 400 points

Problem Statement

There are N one-off jobs available. If you take the i-th job and complete it, you will earn the reward of B_i after A_i days from the day you do it.

You can take and complete at most one of these jobs in a day.

However, you cannot retake a job that you have already done.

Find the maximum total reward that you can earn no later than M days from today.

You can already start working today.

Constraints

All values in input are integers.

1 \leq N \leq 10^5

1 \leq M \leq 10^5

1 \leq A_i \leq 10^5

1 \leq B_i \leq 10^4

Input

Input is given from Standard Input in the following format:

N M
A_1 B_1
A_2 B_2
\vdots
A_N B_N

Output

Print the maximum total reward that you can earn no later than M days from today.

Sample Input 1

3 4
4 3
4 1
2 2

Sample Output 1

5

You can earn the total reward of 5 by taking the jobs as follows:

Take and complete the first job today. You will earn the reward of 3 after four days from today.

Take and complete the third job tomorrow. You will earn the reward of 2 after two days from tomorrow, that is, after three days from today.

Sample Input 2

5 3
1 2
1 3
1 4
2 1
2 3

Sample Output 2

10

Sample Input 3

1 1
2 1

Sample Output 3

0

Solution in Haskell (GHC 7.10.3) (judge verdict: Time Limit Exceeded)

-- ABC 137 D
import Data.Maybe
import Data.Char
import Data.List
import Data.Array
import Control.Monad
import qualified Data.ByteString.Char8 as BS
import qualified Data.Vector.Unboxed as VU

main :: IO ()
main = do
  [n, m] <- getIntList
  jobs <- replicateM n getIntPair
  let joba = accumArray ((flip . insertBy . flip) compare) [] (1, 10^5) jobs
  print $ solve m joba

solve m a = fst . foldl' f (0, []) $ [1..m]
  where
    f (n, ns) m = case merge' ns (a!m) of
      (k:ks) -> (n+k, ks)
      [] -> (n, ns)
    merge' ns [] = ns
    merge' [] ms = ms
    merge' (n:ns) (m:ms)
      | n < m = m : merge' (n:ns) ms
      | otherwise = n : merge' ns (m:ms)

readInt :: BS.ByteString -> Int
readInt = fst . fromJust . BS.readInt

getInt :: IO Int
getInt = readInt <$> BS.getLine

getIntList :: IO [Int]
getIntList = unfoldr (BS.readInt . BS.dropWhile isSpace) <$> BS.getLine

getIntVec :: Int -> IO (VU.Vector Int)
getIntVec n = VU.unfoldrN n (BS.readInt . BS.dropWhile isSpace) <$> BS.getLine

getIntPair :: IO (Int, Int)
getIntPair = do
  [a, b] <- getIntList
  return (a, b)