Submission #210390

---

Source Code Expand

{-# LANGUAGE MultiParamTypeClasses,FlexibleContexts,FlexibleInstances,TypeSynonymInstances,BangPatterns,RankNTypes,TupleSections #-}
import Control.Monad
import Control.Monad.ST
import Control.Applicative
import Control.Arrow
import Debug.Trace
import Text.Printf

import Data.List
import Data.Int
import Data.Bits
import Data.Maybe
import Data.Array.Unboxed
import Data.Array.ST
import qualified Data.Map as M
import qualified Data.Set as S
import qualified Data.ByteString.Char8 as B

readInt = fromJust . fmap fst . B.readInt
readInts = map readInt . B.words <$> B.getLine
readIntPair = l2p . map readInt . take 2 . B.words <$> B.getLine
readLns :: Read a => IO [a]
readLns = map read . words <$> getLine
cmpFst (a,_) (b,_) = compare a b
cmpSnd (_,a) (_,b) = compare a b
cmpLen a b = length a `compare` length b
swap (a,b) = (b,a)
l2p (a:b:_) = (a,b)
p2l (a,b) = [a,b]
itof :: Int -> Double
itof = fromIntegral
defaultArray :: (IArray a e,Ix i) => e -> (i,i) -> [(i,e)] -> a i e
defaultArray = accumArray $ curry snd
flatten :: [(a,[(b,c)])] -> [((a,b),c)]
flatten = (=<<) $ uncurry $ fmap . first . (,)
stepM_ :: Monad m => a -> (a -> Bool) -> (a -> a) -> (a -> m ()) -> m ()
stepM_ i judge incr step = sub i where 
    sub i | judge i = step i >> sub (incr i) | otherwise = return ()
inf = maxBound `div` 2 :: Int

main = do
    s <- getLine
    print $ solve s

data Game = Game { combo :: Int
                 , kaburin :: Int
                 , score :: Integer
                 , tame  :: Int
                 , future :: [(Int,Int)] }deriving(Show)



solve :: String -> Integer
solve = step game
game = Game 0 5 0 0 []
step (Game c k s t f) [] = s
step g@(Game !c !k !s !t !f) (ch:cs) = step nxt2 cs where
    nxt1 = case ch of 
            'N' | k >= 1 && t == 0 -> Game c (k-1) (s + 10 + fromIntegral (div c 10))     0 ((7,1):f) 
            'C' | k >= 3 && t == 0 -> Game c (k-3) (s + 50 + 5 * fromIntegral (div c 10)) 3 ((9,3):f)
            _ -> Game c k s t f
    nxt2 = nxt1 { combo = c + length (filter ((==6).fst) f)
                , tame = max 0 (tame nxt1 - 1)
                , future = [(x-1,n) | (x,n) <- future nxt1, x > 1 ]
                , kaburin = kaburin nxt1 + sum (map snd (filter ((==1).fst) f)) }

Submission Info

Judge Result