結果
| 問題 | No.1364 [Renaming] Road to Cherry from Zelkova |
| ユーザー |
 sansaqua
|
| 提出日時 | 2021-01-23 03:36:58 |
| 言語 | Common Lisp (sbcl 2.3.8) |
| 結果 |
RE
|
| 実行時間 | - |
| コード長 | 26,901 bytes |
| コンパイル時間 | 1,314 ms |
| コンパイル使用メモリ | 90,752 KB |
| 実行使用メモリ | 38,784 KB |
| 最終ジャッジ日時 | 2024-06-09 08:55:37 |
| 合計ジャッジ時間 | 11,263 ms |
|
ジャッジサーバーID （参考情報） |
judge4 / judge1 |
（要ログイン）
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | AC | 12 ms
24,576 KB |
| testcase_01 | AC | 11 ms
23,808 KB |
| testcase_02 | AC | 12 ms
24,576 KB |
| testcase_03 | AC | 12 ms
24,704 KB |
| testcase_04 | AC | 12 ms
24,576 KB |
| testcase_05 | AC | 11 ms
24,448 KB |
| testcase_06 | AC | 11 ms
24,576 KB |
| testcase_07 | AC | 12 ms
24,448 KB |
| testcase_08 | AC | 17 ms
25,472 KB |
| testcase_09 | AC | 14 ms
24,960 KB |
| testcase_10 | AC | 17 ms
25,216 KB |
| testcase_11 | AC | 16 ms
25,344 KB |
| testcase_12 | AC | 17 ms
25,344 KB |
| testcase_13 | AC | 115 ms
34,304 KB |
| testcase_14 | AC | 157 ms
35,840 KB |
| testcase_15 | AC | 145 ms
36,224 KB |
| testcase_16 | AC | 105 ms
32,896 KB |
| testcase_17 | AC | 58 ms
30,720 KB |
| testcase_18 | AC | 210 ms
38,656 KB |
| testcase_19 | AC | 203 ms
38,784 KB |
| testcase_20 | AC | 207 ms
38,784 KB |
| testcase_21 | AC | 204 ms
38,784 KB |
| testcase_22 | AC | 208 ms
38,784 KB |
| testcase_23 | AC | 50 ms
27,904 KB |
| testcase_24 | AC | 53 ms
26,752 KB |
| testcase_25 | RE | - |
| testcase_26 | RE | - |
| testcase_27 | AC | 138 ms
33,280 KB |
| testcase_28 | RE | - |
| testcase_29 | AC | 137 ms
32,384 KB |
| testcase_30 | RE | - |
| testcase_31 | AC | 63 ms
29,184 KB |
| testcase_32 | AC | 111 ms
30,464 KB |
| testcase_33 | RE | - |
| testcase_34 | RE | - |
| testcase_35 | RE | - |
| testcase_36 | RE | - |
| testcase_37 | AC | 116 ms
30,592 KB |
| testcase_38 | AC | 193 ms
34,048 KB |
| testcase_39 | AC | 181 ms
33,920 KB |
| testcase_40 | AC | 193 ms
34,048 KB |
| testcase_41 | AC | 205 ms
33,920 KB |
| testcase_42 | AC | 209 ms
34,048 KB |
| testcase_43 | RE | - |
| testcase_44 | AC | 50 ms
33,920 KB |
| testcase_45 | RE | - |
| testcase_46 | AC | 18 ms
29,184 KB |
| testcase_47 | AC | 12 ms
24,576 KB |
コンパイルメッセージ
; compiling file "/home/judge/data/code/Main.lisp" (written 09 JUN 2024 08:55:28 AM): ; file: /home/judge/data/code/Main.lisp ; in: DEFUN MAKE-SCC ; (AREF CP/SCC::GRAPH CP/SCC::V) ; ; note: unable to ; optimize ; because: ; Upgraded element type of array is not known at compile time. ; in: DEFUN MAKE-CONDENSED-GRAPH ; (AREF CP/SCC::GRAPH CP/SCC::I) ; ; note: unable to ; optimize ; because: ; Upgraded element type of array is not known at compile time. ; ; compilation unit finished ; printed 2 notes ; wrote /home/judge/data/code/Main.fasl ; compilation finished in 0:00:00.276
ソースコード
(in-package :cl-user)
(eval-when (:compile-toplevel :load-toplevel :execute)
(defparameter *opt*
#+swank '(optimize (speed 3) (safety 2))
#-swank '(optimize (speed 3) (safety 0) (debug 0)))
#+swank (ql:quickload '(:cl-debug-print :fiveam :cp/util) :silent t)
#+swank (use-package :cp/util :cl-user)
#-swank (set-dispatch-macro-character
#\# #\> (lambda (s c p) (declare (ignore c p)) `(values ,(read s nil nil t))))
#+sbcl (setq *random-state* (seed-random-state (nth-value 1 (get-time-of-day)))))
#-swank (eval-when (:compile-toplevel)
(setq *break-on-signals* '(and warning (not style-warning))))
#+swank (set-dispatch-macro-character #\# #\> #'cl-debug-print:debug-print-reader)
(macrolet ((def (b)
`(progn (deftype ,(intern (format nil "UINT~A" b)) () '(unsigned-byte ,b))
(deftype ,(intern (format nil "INT~A" b)) () '(signed-byte ,b))))
(define-int-types (&rest bits) `(progn ,@(mapcar (lambda (b) `(def ,b)) bits))))
(define-int-types 2 4 7 8 15 16 31 32 62 63 64))
(defconstant +mod+ 1000000007)
(defmacro dbg (&rest forms)
(declare (ignorable forms))
#+swank (if (= (length forms) 1)
`(format *error-output* "~A => ~A~%" ',(car forms) ,(car forms))
`(format *error-output* "~A => ~A~%" ',forms `(,,@forms))))
(declaim (inline println))
(defun println (obj &optional (stream *standard-output*))
(let ((*read-default-float-format*
(if (typep obj 'double-float) 'double-float *read-default-float-format*)))
(prog1 (princ obj stream) (terpri stream))))
;; BEGIN_INSERTED_CONTENTS
;;;
;;; Strongly connected components of directed graph
;;;
(defpackage :cp/scc
(:use :cl)
(:export #:scc #:scc-graph #:scc-components #:scc-sizes #:scc-count
#:scc-p #:make-scc #:make-condensed-graph))
(in-package :cp/scc)
(defstruct (scc (:constructor %make-scc (graph components sizes count))
(:copier nil)
(:predicate nil))
(graph nil :type vector)
;; components[i] := strongly connected component of the i-th vertex
(components nil :type (simple-array (integer 0 #.most-positive-fixnum) (*)))
;; sizes[k] := size of the k-th strongly connected component
(sizes nil :type (simple-array (integer 0 #.most-positive-fixnum) (*)))
;; the total number of strongly connected components
(count 0 :type (integer 0 #.most-positive-fixnum)))
;; Tarjan's algorithm
;; Reference: http://www.prefield.com/algorithm/graph/strongly_connected_components.html
;; (Kosaraju's algorithm is put in the test file)
(defun make-scc (graph &key (key #'identity))
(declare (optimize (speed 3))
(vector graph)
(function key))
(let* ((n (length graph))
(ord 0)
(ords (make-array n :element-type 'fixnum :initial-element -1)) ; pre-order
;; store the lowest pre-order number as the representative element of a
;; strongly connected component
(lowlinks (make-array n :element-type 'fixnum))
(components (make-array n :element-type '(integer 0 #.most-positive-fixnum)))
(comp-index 0) ; index number of component
(sizes (make-array n :element-type '(integer 0 #.most-positive-fixnum)
:initial-element 0))
(stack (make-array n :element-type '(integer 0 #.most-positive-fixnum)))
(end 0) ; stack pointer
(in-stack (make-array n :element-type 'bit :initial-element 0)))
(declare ((integer 0 #.most-positive-fixnum) ord end comp-index))
(labels ((%push (v)
(setf (aref stack end) v
(aref in-stack v) 1)
(incf end))
(%pop ()
(decf end)
(let ((v (aref stack end)))
(setf (aref in-stack v) 0)
v))
(visit (v)
(setf (aref ords v) ord
(aref lowlinks v) ord)
(incf ord)
(%push v)
(dolist (next (aref graph v))
(let ((next (funcall key next)))
(cond ((= -1 (aref ords next))
(visit next)
(setf (aref lowlinks v)
(min (aref lowlinks v) (aref lowlinks next))))
((= 1 (aref in-stack next))
(setf (aref lowlinks v)
(min (aref lowlinks v) (aref ords next)))))))
(when (= (aref lowlinks v) (aref ords v))
(loop for size of-type (integer 0 #.most-positive-fixnum) from 1
for w = (%pop)
do (setf (aref components w) comp-index)
until (= v w)
finally (setf (aref sizes comp-index) size)
(incf comp-index)))))
(dotimes (v n)
(when (= -1 (aref ords v))
(visit v)))
;; Reverse the order of strongly connected components, because now
;; everything is in the reversed topological order
(dotimes (v n)
(setf (aref components v)
(- comp-index (aref components v) 1)))
(dotimes (i (ash comp-index -1))
(rotatef (aref sizes i) (aref sizes (- comp-index i 1))))
(%make-scc graph components (adjust-array sizes comp-index) comp-index))))
;; FIXME: Constant factor of this implementation is too large. Can we avoid
;; hash-table?
(declaim (ftype (function * (values (simple-array t (*)) &optional))
make-condensed-graph))
(defun make-condensed-graph (scc)
"Does graph condensation. This function is non-destructive."
(declare (optimize (speed 3)))
(let* ((graph (scc-graph scc))
(n (length graph))
(comp-n (scc-count scc))
(components (scc-components scc))
(condensed (make-array comp-n :element-type t)))
(dotimes (i comp-n)
;; Resorting to EQ is substandard, though I use it here for efficiency.
(setf (aref condensed i) (make-hash-table :test #'eq)))
(dotimes (i n)
(let ((i-comp (aref components i)))
(dolist (neighbor (aref graph i))
(let ((neighbor-comp (aref components neighbor)))
(unless (= i-comp neighbor-comp)
(setf (gethash neighbor-comp (aref condensed i-comp)) t))))))
(dotimes (i comp-n)
(setf (aref condensed i)
(loop for x being each hash-key of (aref condensed i)
collect x)))
condensed))
;;;
;;; Memoization macro
;;;
(defpackage :cp/with-cache
(:use :cl)
(:export #:with-cache #:with-caches))
(in-package :cp/with-cache)
;; FIXME: *RECURSION-DEPTH* should be included within the macro.
(declaim (type (integer 0 #.most-positive-fixnum) *recursion-depth*))
(defparameter *recursion-depth* 0)
(eval-when (:compile-toplevel :load-toplevel :execute)
(defun %enclose-with-trace (fname args form)
(let ((value (gensym)))
`(progn
(format t "~&~A~A: (~A ~{~A~^ ~}) =>"
(make-string *recursion-depth*
:element-type 'base-char
:initial-element #\ )
*recursion-depth*
',fname
(list ,@args))
(let ((,value (let ((*recursion-depth* (1+ *recursion-depth*)))
,form)))
(format t "~&~A~A: (~A ~{~A~^ ~}) => ~A"
(make-string *recursion-depth*
:element-type 'base-char
:initial-element #\ )
*recursion-depth*
',fname
(list ,@args)
,value)
,value))))
(defun %extract-declarations (body)
(remove-if-not (lambda (form) (and (consp form) (eql 'declare (car form))))
body))
(defun %parse-cache-form (cache-specifier)
(let ((cache-type (car cache-specifier))
(cache-attribs (cdr cache-specifier)))
(assert (member cache-type '(:hash-table :array)))
(let* ((dims-with-* (when (eql cache-type :array) (first cache-attribs)))
(dims (remove '* dims-with-*))
(rank (length dims))
(rest-attribs (ecase cache-type
(:hash-table cache-attribs)
(:array (cdr cache-attribs))))
(key (prog1 (getf rest-attribs :key) (remf rest-attribs :key)))
(trace-p (prog1 (getf rest-attribs :trace) (remf rest-attribs :trace)))
(cache-form (case cache-type
(:hash-table `(make-hash-table ,@rest-attribs))
(:array `(make-array (list ,@dims) ,@rest-attribs))))
(initial-element (when (eql cache-type :array)
(assert (member :initial-element rest-attribs))
(getf rest-attribs :initial-element))))
(let ((cache (gensym "CACHE"))
(value (gensym))
(present-p (gensym))
(args-lst (gensym))
(indices (loop repeat rank collect (gensym))))
(labels
((make-cache-querier (cache-type name args)
(let ((res (case cache-type
(:hash-table
`(let ((,args-lst (funcall ,(or key '#'list) ,@args)))
(multiple-value-bind (,value ,present-p)
(gethash ,args-lst ,cache)
(if ,present-p
,value
(setf (gethash ,args-lst ,cache)
(,name ,@args))))))
(:array
(assert (= (length args) (length dims-with-*)))
(let ((memoized-args (loop for dimension in dims-with-*
for arg in args
unless (eql dimension '*)
collect arg)))
(if key
`(multiple-value-bind ,indices
(funcall ,key ,@memoized-args)
(let ((,value (aref ,cache ,@indices)))
(if (eql ,initial-element ,value)
(setf (aref ,cache ,@indices)
(,name ,@args))
,value)))
`(let ((,value (aref ,cache ,@memoized-args)))
(if (eql ,initial-element ,value)
(setf (aref ,cache ,@memoized-args)
(,name ,@args))
,value))))))))
(if trace-p
(%enclose-with-trace name args res)
res)))
(make-reset-form (cache-type)
(case cache-type
(:hash-table `(setf ,cache (make-hash-table ,@rest-attribs)))
(:array `(prog1 nil
;; TODO: portable fill
(fill (sb-ext:array-storage-vector ,cache) ,initial-element)))))
(make-reset-name (name)
(intern (format nil "RESET-~A" (symbol-name name)))))
(values cache cache-form cache-type
#'make-reset-name
#'make-reset-form
#'make-cache-querier)))))))
(defmacro with-cache ((cache-type &rest cache-attribs) def-form)
"CACHE-TYPE := :HASH-TABLE | :ARRAY.
DEF-FORM := definition form with DEFUN, LABELS, FLET, or SB-INT:NAMED-LET.
Basic usage:
\(with-cache (:hash-table :test #'equal :key #'cons)
(defun add (a b)
(+ a b)))
This function caches the returned values for already passed combinations of
arguments. In this case ADD stores the key (CONS A B) and the returned value to
a hash-table when (ADD A B) is evaluated for the first time. When it is called
with the same arguments (w.r.t. EQUAL) again, ADD will return the stored value
instead of recomputing it.
The storage for cache can be hash-table or array. Let's see an example for
array:
\(with-cache (:array (10 20 30) :initial-element -1 :element-type 'fixnum)
(defun foo (a b c) ... ))
This form stores the value returned by FOO in an array, which was created
by (make-array (list 10 20 30) :initial-element -1 :element-type 'fixnum). Note
that INITIAL-ELEMENT must always be given here as it is used as the flag
expressing `not yet stored'. (Therefore INITIAL-ELEMENT should be a value FOO
never takes.)
If you want to ignore some arguments, you can put `*' in dimensions:
\(with-cache (:array (10 10 * 10) :initial-element -1)
(defun foo (a b c d) ...)) ; then C is ignored when querying or storing cache
Available definition forms in WITH-CACHE are DEFUN, LABELS, FLET, and
SB-INT:NAMED-LET.
You can trace a memoized function by :TRACE option:
\(with-cache (:array (10 10) :initial-element -1 :trace t)
(defun foo (x y) ...))
Then FOO is traced as with CL:TRACE.
"
(multiple-value-bind (cache-symbol cache-form cache-type
make-reset-name make-reset-form
make-cache-querier)
(%parse-cache-form (cons cache-type cache-attribs))
(ecase (car def-form)
((defun)
(destructuring-bind (_ name args &body body) def-form
(declare (ignore _))
`(let ((,cache-symbol ,cache-form))
(defun ,(funcall make-reset-name name) ()
,(funcall make-reset-form cache-type))
(defun ,name ,args
,@(%extract-declarations body)
(flet ((,name ,args ,@body))
(declare (inline ,name))
,(funcall make-cache-querier cache-type name args))))))
((labels flet)
(destructuring-bind (_ definitions &body labels-body) def-form
(declare (ignore _))
(destructuring-bind (name args &body body) (car definitions)
`(let ((,cache-symbol ,cache-form))
(,(car def-form)
((,(funcall make-reset-name name) ()
,(funcall make-reset-form cache-type))
(,name ,args
,@(%extract-declarations body)
(flet ((,name ,args ,@body))
(declare (inline ,name))
,(funcall make-cache-querier cache-type name args)))
,@(cdr definitions))
(declare (ignorable #',(funcall make-reset-name name)))
,@labels-body)))))
((nlet #+sbcl sb-int:named-let)
(destructuring-bind (_ name bindings &body body) def-form
(declare (ignore _))
`(let ((,cache-symbol ,cache-form))
(,(car def-form) ,name ,bindings
,@(%extract-declarations body)
,(let ((args (mapcar (lambda (x) (if (atom x) x (car x))) bindings)))
`(flet ((,name ,args ,@body))
(declare (inline ,name))
,(funcall make-cache-querier cache-type name args))))))))))
(defmacro with-caches (cache-specs def-form)
"DEF-FORM := definition form by LABELS or FLET.
\(with-caches (cache-spec1 cache-spec2)
(labels ((f (x) ...) (g (y) ...))))
is equivalent to the line up of
\(with-cache cache-spec1 (labels ((f (x) ...))))
and
\(with-cache cache-spec2 (labels ((g (y) ...))))
This macro will be useful to do mutual recursion between memoized local
functions."
(assert (member (car def-form) '(labels flet)))
(let (cache-symbol-list cache-form-list cache-type-list make-reset-name-list make-reset-form-list make-cache-querier-list)
(dolist (cache-spec (reverse cache-specs))
(multiple-value-bind (cache-symbol cache-form cache-type
make-reset-name make-reset-form make-cache-querier)
(%parse-cache-form cache-spec)
(push cache-symbol cache-symbol-list)
(push cache-form cache-form-list)
(push cache-type cache-type-list)
(push make-reset-name make-reset-name-list)
(push make-reset-form make-reset-form-list)
(push make-cache-querier make-cache-querier-list)))
(labels ((def-name (def) (first def))
(def-args (def) (second def))
(def-body (def) (cddr def)))
(destructuring-bind (_ definitions &body labels-body) def-form
(declare (ignore _))
`(let ,(loop for cache-symbol in cache-symbol-list
for cache-form in cache-form-list
collect `(,cache-symbol ,cache-form))
(,(car def-form)
(,@(loop for def in definitions
for cache-type in cache-type-list
for make-reset-name in make-reset-name-list
for make-reset-form in make-reset-form-list
collect `(,(funcall make-reset-name (def-name def)) ()
,(funcall make-reset-form cache-type)))
,@(loop for def in definitions
for cache-type in cache-type-list
for make-cache-querier in make-cache-querier-list
collect `(,(def-name def) ,(def-args def)
,@(%extract-declarations (def-body def))
(flet ((,(def-name def) ,(def-args def) ,@(def-body def)))
(declare (inline ,(def-name def)))
,(funcall make-cache-querier cache-type (def-name def) (def-args def))))))
(declare (ignorable ,@(loop for def in definitions
for make-reset-name in make-reset-name-list
collect `#',(funcall make-reset-name
(def-name def)))))
,@labels-body))))))
;;;
;;; Arithmetic operations with static modulus
;;;
(defpackage :cp/mod-operations
(:use :cl)
(:export #:define-mod-operations))
(in-package :cp/mod-operations)
(defmacro define-mod-operations
(divisor &optional (package #+sbcl (sb-int:sane-package) #-sbcl *package*))
(let ((mod* (intern "MOD*" package))
(mod+ (intern "MOD+" package))
(mod- (intern "MOD-" package))
(incfmod (intern "INCFMOD" package))
(decfmod (intern "DECFMOD" package))
(mulfmod (intern "MULFMOD" package)))
`(progn
(defun ,mod* (&rest args)
(cond ((cdr args) (reduce (lambda (x y) (mod (* x y) ,divisor)) args))
(args (mod (car args) ,divisor))
(t 1)))
(defun ,mod+ (&rest args)
(cond ((cdr args) (reduce (lambda (x y) (mod (+ x y) ,divisor)) args))
(args (mod (car args) ,divisor))
(t 0)))
(defun ,mod- (&rest args)
(if (cdr args)
(reduce (lambda (x y) (mod (- x y) ,divisor)) args)
(mod (- (car args)) ,divisor)))
#+sbcl
(eval-when (:compile-toplevel :load-toplevel :execute)
(locally (declare (sb-ext:muffle-conditions warning))
(sb-c:define-source-transform ,mod* (&rest args)
(case (length args)
(0 1)
(1 `(mod ,(car args) ,',divisor))
(otherwise (reduce (lambda (x y) `(mod (* ,x ,y) ,',divisor)) args))))
(sb-c:define-source-transform ,mod+ (&rest args)
(case (length args)
(0 0)
(1 `(mod ,(car args) ,',divisor))
(otherwise (reduce (lambda (x y) `(mod (+ ,x ,y) ,',divisor)) args))))
(sb-c:define-source-transform ,mod- (&rest args)
(case (length args)
(0 (values nil t))
(1 `(mod (- ,(car args)) ,',divisor))
(otherwise (reduce (lambda (x y) `(mod (- ,x ,y) ,',divisor)) args))))))
(define-modify-macro ,incfmod (delta)
(lambda (x y) (mod (+ x y) ,divisor)))
(define-modify-macro ,decfmod (delta)
(lambda (x y) (mod (- x y) ,divisor)))
(define-modify-macro ,mulfmod (multiplier)
(lambda (x y) (mod (* x y) ,divisor))))))
(defpackage :cp/read-fixnum
(:use :cl)
(:export #:read-fixnum))
(in-package :cp/read-fixnum)
(declaim (ftype (function * (values fixnum &optional)) read-fixnum))
(defun read-fixnum (&optional (in *standard-input*))
"NOTE: cannot read -2^62"
(macrolet ((%read-byte ()
`(the (unsigned-byte 8)
#+swank (char-code (read-char in nil #\Nul))
#-swank (sb-impl::ansi-stream-read-byte in nil #.(char-code #\Nul) nil))))
(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)
(* 10 (the (integer 0 #.(floor most-positive-fixnum 10))
result))))
(return (if minus (- result) result))))))))
;; BEGIN_USE_PACKAGE
(eval-when (:compile-toplevel :load-toplevel :execute)
(use-package :cp/read-fixnum :cl-user))
(eval-when (:compile-toplevel :load-toplevel :execute)
(use-package :cp/mod-operations :cl-user))
(eval-when (:compile-toplevel :load-toplevel :execute)
(use-package :cp/with-cache :cl-user))
(eval-when (:compile-toplevel :load-toplevel :execute)
(use-package :cp/scc :cl-user))
(in-package :cl-user)
;;;
;;; Body
;;;
(define-mod-operations +mod+)
(defun main ()
(declare #.*opt*)
(let* ((n (read))
(m (read))
(graph (make-array (+ n 1) :element-type 'list :initial-element nil))
(revgraph (make-array (+ n 1) :element-type 'list :initial-element nil))
(us (make-array m :element-type 'uint31 :initial-element 0))
(vs (make-array m :element-type 'uint31 :initial-element 0))
(ls (make-array m :element-type 'uint31 :initial-element 0))
(as (make-array m :element-type 'uint31 :initial-element 0)))
(declare (uint31 n m))
(dotimes (i m)
(setf (aref us i) (read-fixnum)
(aref vs i) (read-fixnum)
(aref ls i) (read-fixnum)
(aref as i) (read-fixnum))
(push i (aref graph (aref us i)))
(push i (aref revgraph (aref vs i))))
(labels ((make-reach-p (graph tos start)
(let ((marked (make-array (+ n 1) :element-type 'bit :initial-element 0)))
(sb-int:named-let dfs ((v start))
(setf (aref marked v) 1)
(dolist (ei (aref graph v))
(let ((next (aref tos ei)))
(when (zerop (aref marked next))
(dfs next)))))
marked)))
(let* ((reach0-p (make-reach-p graph vs 0))
(reachn-p (make-reach-p revgraph us n))
(scc (make-scc graph :key (lambda (ei) (aref vs ei))))
(comps (scc-components scc))
(sizes (scc-sizes scc)))
#>graph
#>scc
(dotimes (i (+ n 1))
(when (and (= 1 (aref reach0-p i))
(= 1 (aref reachn-p i))
(> (aref sizes (aref comps i)) 1))
(write-line "INF")
(return-from main)))
#>graph
(with-caches ((:array (100001) :element-type 'uint31 :initial-element #x7fffffff)
(:array (100001) :element-type 'uint31 :initial-element #x7fffffff))
(labels ((calc-in (v)
(if (= 0 v)
1
(let ((res 0))
(declare (uint31 res))
(dolist (ei (aref revgraph v))
(let ((prev (aref us ei))
(a (aref as ei)))
(when (= 1 (aref reach0-p prev))
(incfmod res (mod* a (calc-in prev))))))
res)))
(calc-out (v)
(if (= n v)
1
(let ((res 0))
(declare (uint31 res))
(dolist (ei (aref graph v))
(let ((next (aref vs ei))
(a (aref as ei)))
(when (= 1 (aref reachn-p next))
(incfmod res (mod* a (calc-out next))))))
res))))
(let ((res 0))
(declare (uint31 res))
(dotimes (ei m)
(let ((u (aref us ei))
(v (aref vs ei))
(l (aref ls ei))
(a (aref as ei)))
(when (and (= 1 (aref reach0-p u) (aref reachn-p v)))
(incfmod res (mod* l a (calc-in u) (calc-out v))))))
(println res))))))))
#-swank (main)
;;;
;;; Test
;;;
#+swank
(progn
(defparameter *lisp-file-pathname* (uiop:current-lisp-file-pathname))
(setq *default-pathname-defaults* (uiop:pathname-directory-pathname *lisp-file-pathname*))
(uiop:chdir *default-pathname-defaults*)
(defparameter *dat-pathname* (uiop:merge-pathnames* "test.dat" *lisp-file-pathname*))
(defparameter *problem-url* "https://yukicoder.me/problems/no/1364"))
#+swank
(defun gen-dat ()
(uiop:with-output-file (out *dat-pathname* :if-exists :supersede)
(format out "")))
#+swank
(defun bench (&optional (out (make-broadcast-stream)))
(time (run *dat-pathname* out)))
#+(and sbcl (not swank))
(eval-when (:compile-toplevel)
(when sb-c::*undefined-warnings*
(error "undefined warnings: ~{~A~^ ~}" sb-c::*undefined-warnings*)))
;; To run: (5am:run! :sample)
#+swank
(5am:test :sample
(5am:is
(equal "10
"
(run "3 4
0 1 2 1
1 2 1 1
2 3 3 1
0 3 4 1
" nil)))
(5am:is
(equal "INF
"
(run "3 4
0 1 1 1
1 2 1 1
2 1 1 1
2 3 1 1
" nil)))
(5am:is
(equal "18
"
(run "1 2
0 1 3 2
0 1 4 3
" nil))))