;; Utils

;; 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 10))

(defun solve (n weight-limit l)
  (let ((memo (make-array (list (1+ n) (1+ weight-limit)) :initial-element -1)))
    (labels ((dp (i w)
               ; 1 ~ iまでの品物での価値の最大化
               (cond
                 ((< w 0) (- *inf*))
                 ((zerop i) 0)
                 ((/= (aref memo i w) -1) (aref memo i w))
                 (t
                  (let ((weight (aref l (1- i) 0))
                        (value  (aref l (1- i) 1)))
                    (let ((res (max (dp (1- i) w)
                                    (+ (dp (1- i) (- w weight))
                                       value))))
                      (setf (aref memo i w) res)
                      res))))))
      (dp n weight-limit))))

(defun main ()
  (let* ((n (read))
         (weight-limit (read))
         (l (make-array (list n 2))))
    (dotimes (i n)
      (setf (aref l i 0) (read))
      (setf (aref l i 1) (read)))
    (princ (solve n weight-limit l))
    (fresh-line)))

(main)


Measured memory_bytes: 104764