"Time Limit Exceeded" for a Haskell solution to Knapsack

Just managed to get an accepted variant using IOUArray and IOArray. Also need to tweak the code to reduce the use of Lists as much as possible. Accepted with 1.61 seconds.

I tried STUArray/STArray early on and thought they would offer the same performance as IOUArray/IOArray. However, it turns out that even if STUArray/STArray based solution used less memory and time than functional Arrays, it still failed the last test file for TLE.

I saw the fastest accepted Haskell solution used only 0.38 second. I am curious what they did to make it that fast. My accepted code is attached below along with some profile info. Any ideas to further improve its performance are welcome.

{-# Language OverloadedStrings #-}

import Control.Arrow ((>>>))
import Control.Monad
import Data.List (intercalate)
import Data.Array.IO
import Data.Maybe
import qualified Data.ByteString.Lazy.Char8 as C
  
main = do
  inStr <- C.getContents
  solveCases $ (C.words >>> fmap readInt) inStr
  where readInt = C.readInt >>> fromJust >>> fst

solveCases :: [Int] -> IO ()
solveCases [] = return ()
solveCases (c:n:os) = do
  objs <- newArray (1, n) (0,0)
  os' <- fillObj objs n os
  table <- buildTable objs
  indices <- recover table objs n c []
  putStrLn $ show $ length indices
  putStrLn $ intercalate " " $ show <$> indices
  solveCases os'
  where 
    recover :: IOUArray (Int, Int) Int ->
               IOArray Int (Int, Int) ->
               Int -> Int -> [Int] -> IO [Int]
    recover table objs i j rs = do
      v <- readArray table (i, j)
      if (v == 0)
        then return rs
        else do
        v' <- readArray table (i-1, j)
        if (v == v')
          then recover table objs (i-1) j rs
          else do
          (_, wi) <- readArray objs i
          recover table objs (i-1) (j-wi) ((i-1):rs)
          
    fillObj :: IOArray Int (Int, Int) -> Int -> [Int] -> IO [Int]
    fillObj objs n vws = go 1 vws
      where go :: Int -> [Int] -> IO [Int]
            go i (v:w:vws) | i == n = writeArray objs i (v, w) >> return vws
                           | otherwise = do
                               writeArray objs i (v, w)
                               go (i+1) vws

    bnds = ((0,0), (n,c))

    -- table[i][j] is the max value that can be achieved with
    -- objects [0..i] such that the max selected weight is <= j.
    buildTable :: IOArray Int (Int, Int) -> IO (IOUArray (Int, Int) Int)
    buildTable objs = do
      table <- newArray bnds 0
      forM_ (range bnds) $ \(i, w) -> do
        when (i > 0 && w > 0) $ do
          (vi, wi) <- readArray objs i
          vx <- readArray table (i-1, w)
          if (w < wi)
            then do
            writeArray table (i, w) vx
            else do
            vy <- readArray table (i-1, w-wi)
            writeArray table (i, w) $ max vx (vy+vi)
      return table

      33,901,296 bytes allocated in the heap
         183,504 bytes copied during GC
          53,320 bytes maximum residency (1 sample(s))
          36,792 bytes maximum slop
              33 MiB total memory in use (0 MB lost due to fragmentation)

                                     Tot time (elapsed)  Avg pause  Max pause
  Gen  0         2 colls,     0 par    0.000s   0.000s     0.0001s    0.0002s
  Gen  1         1 colls,     0 par    0.000s   0.003s     0.0025s    0.0025s

  INIT    time    0.000s  (  0.004s elapsed)
  MUT     time    0.040s  (  0.048s elapsed)
  GC      time    0.000s  (  0.003s elapsed)
  EXIT    time    0.000s  (  0.006s elapsed)
  Total   time    0.040s  (  0.061s elapsed)

  %GC     time       0.0%  (0.0% elapsed)

  Alloc rate    847,130,013 bytes per MUT second

  Productivity  98.9% of total user, 79.3% of total elapsed