結果

問題 No.2035 Tunnel
ユーザー motoshiramotoshira
提出日時 2022-08-12 21:40:45
言語 Common Lisp
(sbcl 2.3.8)
結果
AC  
実行時間 28 ms / 2,000 ms
コード長 6,065 bytes
コンパイル時間 1,241 ms
コンパイル使用メモリ 44,092 KB
実行使用メモリ 39,328 KB
最終ジャッジ日時 2023-10-24 08:56:26
合計ジャッジ時間 2,913 ms
ジャッジサーバーID
（参考情報） 		judge15 / judge14
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 10 ms
30,108 KB
testcase_01 AC 10 ms
30,108 KB
testcase_02 AC 9 ms
30,108 KB
testcase_03 AC 10 ms
30,108 KB
testcase_04 AC 10 ms
30,108 KB
testcase_05 AC 28 ms
37,280 KB
testcase_06 AC 27 ms
37,280 KB
testcase_07 AC 27 ms
37,280 KB
testcase_08 AC 23 ms
35,196 KB
testcase_09 AC 23 ms
35,196 KB
testcase_10 AC 28 ms
39,328 KB
testcase_11 AC 23 ms
35,424 KB
testcase_12 AC 26 ms
37,268 KB
testcase_13 AC 12 ms
30,784 KB
testcase_14 AC 15 ms
33,368 KB
testcase_15 AC 25 ms
35,440 KB
testcase_16 AC 20 ms
35,376 KB
testcase_17 AC 10 ms
30,196 KB
testcase_18 AC 12 ms
30,656 KB
testcase_19 AC 16 ms
33,372 KB
testcase_20 AC 24 ms
35,424 KB
testcase_21 AC 17 ms
33,404 KB
testcase_22 AC 17 ms
33,408 KB
testcase_23 AC 13 ms
31,252 KB
testcase_24 AC 19 ms
35,340 KB
testcase_25 AC 22 ms
35,380 KB
testcase_26 AC 21 ms
35,368 KB
testcase_27 AC 25 ms
37,248 KB
testcase_28 AC 17 ms
33,416 KB
testcase_29 AC 13 ms
31,292 KB
testcase_30 AC 12 ms
31,104 KB
権限があれば一括ダウンロードができます
コンパイルメッセージ
; compiling file "/home/judge/data/code/Main.lisp" (written 23 OCT 2023 11:56:23 PM):

; wrote /home/judge/data/code/Main.fasl
; compilation finished in 0:00:00.070

ソースコード

diff # 

(in-package #:cl-user)

;;;
;;; Init
;;;

(eval-when (:compile-toplevel :load-toplevel :execute)
  #+swank (declaim (optimize (speed 3) (safety 2)))
  #-swank (declaim (optimize (speed 3) (safety 0) (debug 0)))
  #+swank (load "~/ghq/github.com/motoshira/atcoder-submission/ac-tools/act.lisp")
  #-swank (declaim (sb-ext:muffle-conditions sb-ext:compiler-note))
  #-swank (sb-ext:disable-debugger))

;;;
;;; Reader Macros
;;;

(eval-when (:compile-toplevel :load-toplevel :execute)
  (set-dispatch-macro-character
   #\# #\f
   #'(lambda (stream c2 n)
       (declare (ignore c2 n))
       (let ((form (read stream t nil t)))
         `(lambda (&optional %) (declare (ignorable %)) ,form))))

  (set-dispatch-macro-character
   #\# #\>
   #'(lambda (stream c2 n)
       (declare (ignore c2 n))
       (let ((form (read stream t nil t)))
         (declare (ignorable form))
         #-swank nil
         #+swank (if (atom form)
                     `(format *error-output* "~a => ~a~&" ',form ,form)
                     `(format *error-output* "~a => ~a~&" ',form `(,,@form)))))))

;;;
;;; Libraries
;;;

;;;
;;; Macros
;;;

(in-package #:cl-user)

(defmacro do-iota ((var count &optional (start 0) (step 1)) &body body)
  (check-type step integer)
  (let* ((last (gensym))
         (terminate (if (plusp step) `(>= ,var ,last) `(<= ,var ,last))))
    `(let ((,last (+ ,start (the fixnum (* ,step ,count)))))
       (declare (fixnum ,last))
       (do
        ((,var ,start (+ ,var ,step)))
        (,terminate)
         (progn ,@body)))))

(defmacro awhen (test &body forms)
  `(let ((it ,test))
     (when it
       ,@forms)))

(defmacro while (test &body body)
  `(loop while ,test do (progn ,@body)))

;;;
;;; I/O
;;;

(in-package #:cl-user)

(declaim (inline println))
(defun println (obj &optional (stream *standard-output*))
  #+sbcl (declare (sb-kernel:ansi-stream stream))
  (let ((*read-default-float-format* 'double-float))
    (prog1 obj
      (princ obj stream)
      (terpri stream))))

(declaim (inline %read-byte))
(defun %read-byte (&optional (stream *standard-input*))
  (declare (inline read-byte)
           #+sbcl (sb-kernel:ansi-stream stream))
  (the fixnum #+swank (char-code (read-char stream nil #\Nul))
              #-swank (read-byte stream nil #.(char-code #\Nul))))

(declaim (inline read-fixnum))
(defun read-fixnum (&optional (in *standard-input*) (byte-reader #'%read-byte))
  ;; Ref: https://competitive12.blogspot.com/2020/03/common-lisp.html
  ;;        partially modified
  (declare ((function (stream) (unsigned-byte 8)) byte-reader)
           (optimize (speed 3) (safety 0) (debug 0)))
  (let ((minus nil)
        (res 0))
    (declare (boolean minus)
             (fixnum res))
    (labels ((%byte->num (b)
               (the fixnum (- (the fixnum b) #.(char-code #\0))))
             (%digit-p (byte)
               (<= #.(char-code #\0) (the fixnum byte) #.(char-code #\9)))
             (%first-proc! ()
               (loop for byte of-type fixnum = (funcall byte-reader in)
                     do (cond
                          ((%digit-p byte)
                           (setf (the fixnum res) (%byte->num byte))
                           (return))
                          ((= byte #.(char-code #\Nul))
                           (error "EOF"))
                          ((= byte #.(char-code #\-))
                           (setf minus t)))))
             (%rest-proc! ()
               (loop for byte of-type fixnum = (funcall byte-reader in)
                     do (cond
                          ((%digit-p byte)
                           (setf (the fixnum res) (the fixnum (+ (the fixnum (* res 10)) (%byte->num byte)))))
                          (t (return))))))
      (declare (inline %byte->num %digit-p %first-proc! %rest-proc!))
      (%first-proc!)
      (%rest-proc!)
      (the fixnum (if minus (- res) res)))))

(declaim (inline read-base-char))
(defun read-base-char (&optional (stream *standard-input*))
  (code-char (%read-byte stream)))

(defun read-line-fast (&optional (stream *standard-input*))
  #+(and (not swank) sbcl) (declare (sb-kernel:ansi-stream stream))
  (loop with buffer of-type base-string = (make-array 0 :element-type 'base-char :fill-pointer 0)
        for c of-type base-char = (read-base-char stream)
        until (or (eql c #\Newline)
                  (eql c #\Nul))
        do (vector-push-extend c buffer)
        finally (return buffer)))

(declaim (inline parse-fixnum))
(defun parse-fixnum (string)
  (with-input-from-string (in string)
    (read-fixnum in #f(the (unsigned-byte 8)
                           (char-code (read-char % nil #\Nul nil))))))

(defun read-times (count &key (result-type 'list) (reader #'read-fixnum))
  (coerce (loop repeat count collect (funcall reader)) result-type))

;;;
;;; Body
;;;

(in-package #:cl-user)

(defun main ()
  (let* ((n (read))
         (ss (map 'vector
                  (lambda (c)
                    (if (eql c #\#)
                        1
                        0))
                  (read-line-fast)))
         (cs nil))
    (dotimes (i n)
      (when (= 1 (aref ss i))
        (push i cs)))
    #>cs
    (let ((wait 0))
      (loop for (c0 c1) on cs by #'cdr
            when c1
              do (setf wait (max 0 (+ 2 (- wait (- c0 c1)))))
            and do (progn #>wait))
      (println (+ (- n (first (last cs)))
                  wait)))))

#-swank (main)

;;;
;;; Debug
;;;

#+swank
(defun run ()
  (let ((*standard-input*
          (make-string-input-stream
           (with-output-to-string (*standard-output*)
             (run-program
              (truename "~/bin/copy-or-paste")
              '()
              :output *standard-output*)))))
    (main)))

;; Raise error on warning at compile time

#+(and sbcl (not swank))
(eval-when (:compile-toplevel)
  (when (or (plusp sb-c::*compiler-warning-count*)
            sb-c::*undefined-warnings*)
    (error "compiler-error-count:~a, undefined warnings:~a"
           sb-c::*compiler-warning-count*
           sb-c::*undefined-warnings*)))
0