{-# LANGUAGE BangPatterns #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE TupleSections #-} import Control.Monad import Control.Monad.Fix import Control.Monad.ST import Control.Monad.State import Data.Char import Data.Coerce import Data.IORef import Data.Ord import qualified Data.ByteString.Char8 as BSC8 import qualified Data.Vector.Fusion.Stream.Monadic as VFSM import qualified Data.Vector.Generic as VG import qualified Data.Vector.Generic.Mutable as VGM import qualified Data.Vector.Unboxed as VU import qualified Data.Vector.Unboxed.Mutable as VUM main :: IO () main = do n <- readLn :: IO Int a <- quickSort <$> seqInput n b <- quickSortBy (comparing Down) <$> seqInput n p <- VU.unsafeThaw $ VU.fromList ([0..(n - 1)] :: [Int]) ans <- newIORef (0 :: Int) let res = VU.sum $ VU.zipWith (\x y -> max 0 (x - y)) a b fix $ \loop -> do s <- newIORef (0 :: Int) rep n $ \i -> do pi <- VUM.unsafeRead p i modifyIORef' s (+ max 0 (a VU.! pi - b VU.! i)) su <- readIORef s when (su == res) $ modifyIORef' ans succ check <- VUM.nextPermutation p when check loop print =<< readIORef ans quickSort :: (Ord a, VG.Vector v a) => v a -> v a quickSort = quickSortBy compare quickSortBy :: VG.Vector v a => (a -> a -> Ordering) -> v a -> v a quickSortBy cmp = VG.modify $ fix $ \loop vec -> when (VGM.length vec > 1) $ do pivot <- getMedian3Pivot cmp vec cut <- pivotPartition cmp vec pivot loop (VGM.unsafeDrop cut vec) loop (VGM.unsafeTake cut vec) {-# INLINE quickSortBy #-} pivotPartition :: (VGM.MVector mv a) => (a -> a -> Ordering) -> mv s a -> a -> ST s Int pivotPartition cmp vec pivot = fix `flip` 0 `flip` VGM.length vec $ \loop !l !r -> do !l' <- flip fix l $ \loopL !i -> do x <- VGM.unsafeRead vec i case cmp x pivot of LT -> loopL (i + 1) _ -> return i !r' <- flip fix (r - 1) $ \loopR !i -> do x <- VGM.unsafeRead vec i case cmp pivot x of LT -> loopR (i - 1) _ -> return i if l' < r' then do VGM.unsafeSwap vec l' r' loop (l' + 1) r' else return l' {-# INLINE pivotPartition #-} getMedian3Pivot :: (VGM.MVector mv a) => (a -> a -> Ordering) -> mv s a -> ST s a getMedian3Pivot cmp vec = median cmp <$> VGM.unsafeRead vec 0 <*> VGM.unsafeRead vec (VGM.length vec `quot` 2) <*> VGM.unsafeRead vec (VGM.length vec - 1) {-# INLINE getMedian3Pivot #-} median :: (a -> a -> Ordering) -> a -> a -> a -> a median cmp x y z = case cmp x y of LT -> case cmp y z of LT -> y _ -> case cmp x z of LT -> z _ -> x _ -> case cmp x z of LT -> x _ -> case cmp y z of LT -> z _ -> y {-# INLINE median #-} -- | l -> x -> r, +d stream :: Monad m => Int -> Int -> Int -> VFSM.Stream m Int stream !l !r !d = VFSM.Stream step l where step x | x <= r = return $ VFSM.Yield x (x + d) | otherwise = return VFSM.Done {-# INLINE [0] step #-} {-# INLINE [1] stream #-} -- | 0 <= x < n, interval = 1 rep :: Monad m => Int -> (Int -> m ()) -> m () rep n = flip VFSM.mapM_ (stream 0 (n - 1) 1) {-# INLINE rep #-} type CParser a = StateT BSC8.ByteString Maybe a runCParser :: CParser a -> BSC8.ByteString -> Maybe (a, BSC8.ByteString) runCParser = runStateT {-# INLINE runCParser #-} int :: CParser Int int = coerce $ BSC8.readInt . BSC8.dropWhile isSpace {-# INLINE int #-} seqInput :: Int -> IO (VU.Vector Int) seqInput n = VU.unfoldrN n (runCParser int) <$> BSC8.getLine {-# INLINE seqInput #-}