;;; Utils (quoted from https://competitive12.blogspot.com/2020/03/common-lisp.html)


;; Read fixnum

(declaim (ftype (function * (values fixnum &optional)) read-fixnum))
(defun read-fixnum (&optional (in *standard-input*))
  (declare (inline read-byte)
           #-swank (sb-kernel:ansi-stream in))
  (macrolet ((%read-byte ()
               `(the (unsigned-byte 8)
                     #+swank (char-code (read-char in nil #\Nul))
                     #-swank (read-byte in nil 0))))
    (let* ((minus nil)
           (result (loop (let ((byte (%read-byte)))
                           (cond ((<= 48 byte 57)
                                  (return (- byte 48)))
                                 ((zerop byte) ; #\Nul
                                  (error "Read EOF or #\Nul."))
                                 ((= byte #.(char-code #\-))
                                  (setq minus t)))))))
      (declare ((integer 0 #.most-positive-fixnum) result))
      (loop
        (let* ((byte (%read-byte)))
          (if (<= 48 byte 57)
              (setq result (+ (- byte 48) (the (integer 0 #.(floor most-positive-fixnum 10)) (* result 10))))
              (return (if minus (- result) result))))))))

;; fast read-line

(defmacro buffered-read-line (&optional (buffer-size 30) (in '*standard-input*) (term-char #\Space))
  (let ((buffer (gensym))
        (character (gensym))
        (idx (gensym)))
    `(let* ((,buffer (load-time-value (make-string ,buffer-size :element-type 'base-char))))
       (declare (simple-base-string ,buffer)
                (inline read-byte))
       (loop for ,character of-type base-char =
             ,(if (member :swank *features*)
                  `(read-char ,in nil #\Newline) ; on SLIME
                `(code-char (read-byte ,in nil #.(char-code #\Newline))))
             for ,idx from 0
             until (char= ,character #\Newline)
             do (setf (schar ,buffer ,idx) ,character)
             finally (when (< ,idx ,buffer-size)
                       (setf (schar ,buffer ,idx) ,term-char))
             (return (values ,buffer ,idx))))))


;; invoke child process

#-swank
(unless (member :child-sbcl *features*)
  (quit
    :unix-status
    (process-exit-code
      (run-program *runtime-pathname*
                   `("--control-stack-size" "128MB"
                     "--noinform" "--disable-ldb" "--lose-on-corruption" "--end-runtime-options"
                     "--eval" "(push :child-sbcl *features*)"
                     "--script" ,(namestring *load-pathname*))
                                                                 :output t :error t :input t))))



;-------------------
; Write code here
;-------------------

(defparameter *inf* (expt 10 7))

;; todo

;; scores: '((0 . score0) (1 . score1) ... 


(defun solve (n m x cost table &optional (ans *inf*))
  (labels ((dp (amount-of-book scores)
             (cond
               ((zerop amount-of-book)
                (if (every (lambda (score) (<= (rest score) 0)) scores)
                    0
                    *inf*))
               (t
                (min (dp (1- amount-of-book) scores)
                     (+ (dp (1- amount-of-book)
                            (mapcar (lambda (score)
                                      (cons (first score)
                                            (- (rest score) (aref table (1- amount-of-book) (first score)))))
                                    scores))
                        (aref cost (1- amount-of-book))))))))
    (let (scores)
      (dotimes (i m)
        (push `(,i . ,x) scores))
      (let ((ans (dp n (reverse scores))))
        (if (= ans *inf*)
            -1
            ans)))))


;; done

(defun main ()
  (let* ((n (read))
         (m (read))
         (x (read))
         (cost (make-array n))
         (table (make-array `(,n ,m))))
    (dotimes (i n)
      (setf (aref cost i) (read-fixnum))
      (dotimes (j m)
        (setf (aref table i j) (read-fixnum))))
    (princ (solve n m x cost table))
    (fresh-line)))

(main)


Measured memory_bytes: 27224