結果

問題 No.189 SUPER HAPPY DAY
ユーザー terasaterasa
提出日時 2022-11-04 21:34:25
言語 PyPy3
(7.3.15)
結果
AC  
実行時間 761 ms / 5,000 ms
コード長 3,657 bytes
コンパイル時間 263 ms
コンパイル使用メモリ 87,228 KB
実行使用メモリ 112,844 KB
最終ジャッジ日時 2023-09-25 23:50:03
合計ジャッジ時間 10,804 ms
ジャッジサーバーID
（参考情報） 		judge15 / judge14
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 186 ms
83,276 KB
testcase_01 AC 199 ms
83,264 KB
testcase_02 AC 186 ms
82,676 KB
testcase_03 AC 195 ms
83,208 KB
testcase_04 AC 196 ms
83,212 KB
testcase_05 AC 197 ms
83,088 KB
testcase_06 AC 197 ms
83,288 KB
testcase_07 AC 200 ms
83,148 KB
testcase_08 AC 200 ms
83,100 KB
testcase_09 AC 199 ms
83,300 KB
testcase_10 AC 201 ms
83,304 KB
testcase_11 AC 203 ms
83,364 KB
testcase_12 AC 204 ms
83,280 KB
testcase_13 AC 468 ms
91,116 KB
testcase_14 AC 536 ms
94,136 KB
testcase_15 AC 480 ms
95,100 KB
testcase_16 AC 524 ms
97,292 KB
testcase_17 AC 578 ms
100,608 KB
testcase_18 AC 472 ms
94,212 KB
testcase_19 AC 615 ms
98,660 KB
testcase_20 AC 341 ms
87,320 KB
testcase_21 AC 378 ms
87,992 KB
testcase_22 AC 225 ms
83,500 KB
testcase_23 AC 480 ms
103,520 KB
testcase_24 AC 480 ms
98,184 KB
testcase_25 AC 761 ms
112,844 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

from typing import List, Tuple, Callable, TypeVar
import sys
import itertools
import heapq
import bisect
from collections import deque, defaultdict
from functools import lru_cache, cmp_to_key

input = sys.stdin.readline

# for AtCoder Easy test
if __file__ != 'prog.py':
    sys.setrecursionlimit(10 ** 6)


def readints(): return map(int, input().split())
def readlist(): return list(readints())
def readstr(): return input().rstrip()


T = TypeVar('T')


class Rerooting:
    # reference: https://null-mn.hatenablog.com/entry/2020/04/14/124151
    # 適当な頂点vを根とする部分木に対して計算される値dp_vが、vの子c1, c2, ... ckを用いて
    # 下記のように表すことができる
    # dp_v = g(merge(f(dp_c1,c1), f(dp_c2,c2), ..., f(dp_ck,ck)), v)
    def __init__(self, N: int, E: List[Tuple[int, int]],
                 f: Callable[[T, int, int, int], T],
                 g: Callable[[T, int], T],
                 merge: Callable[[T, T], T], e: T):
        self.N = N
        self.E = E
        self.f = f
        self.g = g
        self.merge = merge
        self.e = e

        self.dp = [[self.e for _ in range(len(self.E[v]))] for v in range(self.N)]
        self._calculate()

    def _dfs1(self, root):
        stack = [(root, -1)]
        ret = [self.e] * self.N
        while stack:
            v, p = stack.pop()
            if v < 0:
                v = ~v
                acc = self.e
                for i, (c, d) in enumerate(self.E[v]):
                    if d == p:
                        continue
                    self.dp[v][i] = ret[d]
                    acc = self.merge(acc, self.f(ret[d], v, d, c))
                ret[v] = self.g(acc, v)
                continue

            stack.append((~v, p))
            for i, (c, d) in enumerate(self.E[v]):
                if d == p:
                    continue
                stack.append((d, v))

    def _dfs2(self, root):
        stack = [(root, -1, self.e)]
        while stack:
            v, p, from_par = stack.pop()
            for i, (c, d) in enumerate(self.E[v]):
                if d == p:
                    self.dp[v][i] = from_par
                    break
            ch = len(self.E[v])
            Sr = [self.e] * (ch + 1)
            for i in range(ch, 0, -1):
                c, d = self.E[v][i - 1]
                Sr[i - 1] = self.merge(Sr[i], self.f(self.dp[v][i - 1], v, d, c))
            Sl = self.e
            for i, (c, d) in enumerate(self.E[v]):
                if d != p:
                    val = self.merge(Sl, Sr[i + 1])
                    stack.append((d, v, self.g(val, v)))
                Sl = self.merge(Sl, self.f(self.dp[v][i], v, d, c))

    def _calculate(self, root=0):
        self._dfs1(root)
        self._dfs2(root)

    def solve(self, v):
        ans = self.e
        for i, (c, d) in enumerate(self.E[v]):
            ans = self.merge(ans, self.f(self.dp[v][i], v, d, c))
        return self.g(ans, v)


M, D = input().split()
mod = 10 ** 9 + 9


def solve(n):
    dp = [[0, 0] for _ in range(L + 1)]
    dp[0][0] = 1
    for i in range(len(n)):
        ndp = [[0, 0] for _ in range(L + 1)]
        for j in range(L + 1):
            for k in range(10):
                if j - k < 0:
                    break
                ndp[j][1] += dp[j - k][1]

                if k < int(n[i]):
                    ndp[j][1] += dp[j - k][0]
                elif k == int(n[i]):
                    ndp[j][0] += dp[j - k][0]
        dp = ndp
    return dp


L = 2000
dpm = solve(M)
dpd = solve(D)
ans = 0
for i in range(1, L + 1):
    ans += sum(dpm[i]) * sum(dpd[i]) % mod
    ans %= mod
print(ans)
0