#1102400 (Scheme) No.2196 Pair Bonus

• 問題: No.2196 Pair Bonus
• ユーザー: norioc
• 提出日時: 2025-07-01 22:27:26
• 言語: Scheme (Gauche-0.9.15)
• 結果: AC
• 実行時間: 646 ms / 2,000 ms
• コード長: 4,400 bytes
• コンパイル時間: 3 ms
• コンパイル使用メモリ: 7,212 KB
• 実行使用メモリ: 93,056 KB
• 最終ジャッジ日時: 2026-07-13 00:02:41
• 合計ジャッジ時間: 6,510 ms
• ジャッジサーバーID （参考情報）: judge3_0 / judge2_0

ファイルパターン	結果
sample	AC * 3
other	AC * 15

ソースコード

(use scheme.list)
(use util.match)
(use srfi.13)  ; string
(use srfi.42)  ; list-ec
(use srfi.197) ; chain
(use gauche.collection)
(use gauche.generator)
(use gauche.sequence)

(define input read-line)

(define (ii)
  (string->number (read-line)))

(define (li)
  (let ((s (read-line)))
    (map string->number (string-split s " "))))

(define (prn . args)
  (for-each-with-index (lambda (i x)
                         (when (> i 0)
                           (display " "))
                         (display x))
                       args)
  (newline))

(define prn* (pa$ apply prn))

(define int string->number)
(define str x->string)

(define-method min ((xs <sequence>))
  (fold min (~ xs 0) xs))
(define-method max ((xs <sequence>))
  (fold max (~ xs 0) xs))

(define (minmax . xs)
  (values->list (apply min&max xs)))
(define-method minmax ((xs <sequence>))
  (values->list (apply min&max xs)))

(define (sum xs)
  (fold + 0 xs))

(define (divmod a b)
  (values->list (div-and-mod a b)))

(define (1+ n) (+ n 1))
(define (1- n) (- n 1))
(define (!= a b) (not (= a b)))

(define pow
  (case-lambda
   ((a b) (expt a b))
   ((a b m) (expt-mod a b m))))

(define isqrt exact-integer-sqrt)

(define ++ string-append)

(define (comb n k)
  (if (or (< k 0) (> k n))
      0
      (let loop ((i 0)
                 (x 1))
        (if (= i k)
            x
            (loop (1+ i) (div (* x (- n i)) (1+ i)))))))

(define-method frequencies ((xs <sequence>))
  (rlet1 ht (make-hash-table)
    (for-each (^x (hash-table-update! ht x 1+ 0))
              xs)))

(define (pairwise xs)
  (zip xs (cdr xs)))

(define (group xs test)
  (define (sub ys)
    (assume (not (null? ys)))

    (let loop ((g (list (car ys)))
               (ys (cdr ys)))
      (if (null? ys)
          (values (reverse g) ys)
          (match-let1 (y . rest) ys
            (if (test (car g) y)
                (loop (cons y g) rest)
                (values (reverse g) ys))))))

  (if (null? xs)
      '()
      (receive (g rest) (sub xs)
        (if (null? rest)
            (list g)
            (cons g (group rest test))))))

(define (yn b)
  (prn (if b "Yes" "No")))

(define-macro (input! bindings . body)
  (let loop ((bs (reverse bindings))
             (res '()))
    (if (null? bs)
        `(let*-values ,res
           ,@body)
        (cond
         ((symbol? (car bs))
          (loop (cdr bs)
                (cons `((,(car bs)) (values (ii)))
                      res)))
         ((list? (car bs))
          (loop (cdr bs)
                (cons `(,(car bs) (apply values (li)))
                      res)))
         (else
          'error)))))

(define mlet1 match-let1)

(define (slide xs k :key step)
  (let* ((n (length xs))
         (step (if (undefined? step) k step)))
    (let loop ((xs xs)
               (res '()))
      (if (null? xs)
          (reverse res)
          (loop (drop* xs step)
                (cons (take* xs k) res))))))

(define-macro (mfn pat . body)
  (let ((arg (gensym)))
    `(lambda (,arg)
       (mlet1 ,pat ,arg
         ,@body))))

(define (accum xs)
  (define (proc a b)
    (let1 t (+ a b)
      (values t t)))
  (map-accum proc 0 xs))

(define (bsearch low high pred :key (complement? #f))
  (define satisfy? (if complement?
                       (complement pred)
                       pred))

  (let loop ((lo low)
             (hi high)
             (res low))
    (cond
     ((<= lo hi)
      (let1 m (div (+ lo hi) 2)
        (if (satisfy? m)
            (loop (1+ m) hi (max res m))
            (loop lo (1- m) res))))
     (else
      (if complement?
          (1+ res)
          res)))))

(define (digits n)
  (list-ec (:list c (string->list (str n)))
           (digit->integer c)))

(define (calc a1 a2 b1 b2 x y)
  (max (+ a1 a2 x)
       (+ a1 b2 y)
       (+ b1 a2 y)
       (+ b1 b2 x)))

(let ((N (ii))
      (A (li))
      (B (li))
      (X (li))
      (Y (li)))

  (chain
   (let loop ((score 0)
              (A A)
              (B B)
              (X X)
              (Y Y))
     (if (null? A)
         score
         (let ((s (calc (car A)
                        (cadr A)
                        (car B)
                        (cadr B)
                        (car X)
                        (car Y))))
           (loop (+ s score)
                 (cddr A)
                 (cddr B)
                 (cdr X)
                 (cdr Y)))))
   (prn _)))