結果

問題 No.108 トリプルカードコンプ
ユーザー kusirakusirakusirakusira
提出日時 2022-08-28 22:02:02
言語 PyPy3
(7.3.15)
結果
AC  
実行時間 184 ms / 5,000 ms
コード長 7,333 bytes
コンパイル時間 179 ms
コンパイル使用メモリ 82,048 KB
実行使用メモリ 89,856 KB
最終ジャッジ日時 2024-10-15 19:01:13
合計ジャッジ時間 5,351 ms
ジャッジサーバーID
（参考情報） 		judge5 / judge3
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 178 ms
89,216 KB
testcase_01 AC 182 ms
89,216 KB
testcase_02 AC 181 ms
89,216 KB
testcase_03 AC 180 ms
89,344 KB
testcase_04 AC 177 ms
89,728 KB
testcase_05 AC 180 ms
89,344 KB
testcase_06 AC 181 ms
89,216 KB
testcase_07 AC 184 ms
89,600 KB
testcase_08 AC 180 ms
89,216 KB
testcase_09 AC 179 ms
89,472 KB
testcase_10 AC 180 ms
89,344 KB
testcase_11 AC 179 ms
89,216 KB
testcase_12 AC 175 ms
89,856 KB
testcase_13 AC 177 ms
89,600 KB
testcase_14 AC 177 ms
89,216 KB
testcase_15 AC 178 ms
89,472 KB
testcase_16 AC 179 ms
89,472 KB
testcase_17 AC 181 ms
89,216 KB
testcase_18 AC 181 ms
89,472 KB
testcase_19 AC 180 ms
89,472 KB
testcase_20 AC 180 ms
89,216 KB
testcase_21 AC 180 ms
89,344 KB
testcase_22 AC 180 ms
89,216 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

#Python3/Pypy3テンプレート集

#ライブラリ-------------------------------------------------------------------
import bisect
import heapq
import collections
from itertools import groupby
import itertools
import math
import array
import string
import copy

#テンプレート------------------------------------------------------------------
INF=10**18
MOD=10**9+7
mod=998244353
def YesNo(b): print("Yes") if b else print("No")
def YESNO(b): print("YES") if b else print("NO")

#標準入力---------------------------------------------------------------------
import sys
sys.setrecursionlimit(10 ** 5 + 10000)
input = sys.stdin.readline    ####
def int1(x): return int(x) - 1
def II(): return int(input())
def MI(): return map(int, input().split())
def MI1(): return map(int1, input().split())
def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LIS(): return list(map(int, SI()))
def LA(f): return list(map(f, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return input().strip('\n')
def MS(): return input().split()
def LS(): return list(input().strip('\n'))
def LLS(rows_number): return [LS() for _ in range(rows_number)]

#関数------------------------------------------------------------------------
def At(A): #二次元配列の転置
    A_t = []
    for i in range(len(A[0])) :
        tmp = []
        for v in A :
            tmp.append(v[i])
        A_t.append(tmp)
    return A_t
def D2L(A): #二次元配列の重複削除
    return list(map(list, set(map(tuple, A))))
def CSL(A): #配列Aの累積和
  return [0] + list(itertools.accumulate(A))
def nF(n, m=0): #nの階乗 | m:mod(デフォなし)
    if(n<=0):
        return 0
    P = 1
    for i in range(1,n+1):
        P *= i
        if(m==0):
          continue        
        P %= m
    return P
def nPr(n, r, m=0): #順列nPr
    if(n<=0 or r<=0 or n<r):
        return 0
    P = 1
    for i in range(r,n+1):
        P *= i
        if(m==0):
          continue
        P %= m
    return P
def nCr(n, r, m=0): #組み合わせnCr
    if(n<=0 or r<=0 or n<r):
        return 0
    N = 1
    for i in range(r):
        N *= n-i
        if(m==0):
            continue
        N %= m
    R = nF(r)
    return N//R
def nCrm(n,r,m): #逆元を用いた組み合わせnCr%mod
    if(n<=0 or r<=0 or n<r):
        return 0
    over=1
    for i in range(n-r+1,n+1):
        over *= i
        over %= m
    under=1
    for i in range(1,r+1):
        under *= i
        under %= m
    return over*pow(under,m-2,m)%m
def DL(n): #nまでの約数のリスト
    lower_divisors , upper_divisors = [], []
    i = 1
    while i*i <= n:
        if n % i == 0:
            lower_divisors.append(i)
            if i != n // i:
                upper_divisors.append(n//i)
        i += 1
    return lower_divisors + upper_divisors[::-1]  
def IP(n): #素数判定 => True/False
  if n == 2:
    return True
  if n % 2 == 0:
    return False
  m = math.floor(math.sqrt(n)) + 1
  for p in range(3, m, 2):
      if n % p == 0:
        return False
  return True
def PL(n): #nまでの素数のリスト
    is_prime = [True] * (n + 1)
    is_prime[0] = False
    is_prime[1] = False
    for i in range(2, int(n**0.5) + 1):
        if not is_prime[i]:
            continue
        for j in range(i * 2, n + 1, i):
            is_prime[j] = False
    return [i for i in range(n + 1) if is_prime[i]]
def F2L(n): #2以上の整数n => [[素因数, 指数], ...]の2次元リスト
    if(n==1):
        return []
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])
    if temp!=1:
        arr.append([temp, 1])
    if arr==[]:
        arr.append([n, 1])
    return arr
def DtoN(num_10,n): #10進数からn進数へ変換する(n<=10)
    str_n = ''
    while num_10:
        if num_10%n>=10:
            return -1
        str_n += str(num_10%n)
        num_10 //= n
    return int(str_n[::-1])    
def StoR(S: str): #文字列/リストからラングレス圧縮
    grouped = groupby(S)
    res = []
    for k, v in grouped:
        res.append((k, int(len(list(v)))))
    return res
def RtoS(L: "list[tuple]"): #ラングレス圧縮から文字列 => 文字だけ
    res = ""
    for c, n in L:
        res += c * int(n)
    return res
def RtoSc(S: str) : #ラングレス圧縮から文字列 => 文字と個数
    grouped = groupby(S)
    res = ""
    for k, v in grouped:
        res += k + str(len(list(v)))
    return res    
def dsin(d): #度数法でsinを計算する
    return math.sin(math.radians(d))
def dcos(d): #度数法でcosを計算する
    return math.cos(math.radians(d))
def RM(x,y,d,cx=0,cy=0): #P(x,y)をA(cx,cy)を中心としてに反時計回りにd°回転 => [x,y]
  nx = (x-cx)*dcos(d)-(y-cy)*dsin(d)
  ny = (x-cx)*dsin(d)+(y-cy)*dcos(d)
  return [nx+cx,ny+cy]
def engL(): return list(string.ascii_lowercase)
def ENGL(): return list(string.ascii_uppercase)
def TS(_str): #変数/リストに格納されている値を確認
    print('{}: {}'.format(_str, eval(_str)))
def T2d(A): #二次元配列の確認用
    for a in A:
        print(*a)
def BR(): #横線で区切りを入れる
    print("---")
#クラス----------------------------------------------------------------------

#カンニングペーパー-----------------------------------------------------------
'''
At(A): #二次元配列の転置
D2L(A): #二次元配列の重複削除
CSL(A) #配列Aの累積和
nF(n,m) #nの階乗 | m:mod(デフォなし)
nPr(n,r,m) #順列nPr | m:mod(デフォなし)
nCr(n,r,m) #組み合わせ,nCr | m:mod(デフォなし)
nCrm(n,r,m): #逆元を用いた組み合わせnCr%mod
DL(n) #nの約数のリスト
IP(n) #素数判定 => True/False
PL(n) #nまでの素数のリスト
F2L(n) #2以上の整数n => [[素因数, 指数], ...]の2次元リスト
DtoN(num_10,n) #10進数からn進数へ変換する(n<=10)
StoR #文字列/リストからラングレス圧縮
RtoS #ラングレス圧縮から文字列 => 文字だけ
RtoSc #ラングレス圧縮から文字列 => 文字と個数
dsin(d): #度数法でsinを計算する
dcos(d): #度数法でcosを計算する
RM(x,y,d,cx,cy): #P(x,y)をA(cx,cy)を中心としてに反時計回りにd°回転(デフォ原点) => [x,y]
engL() #英小文字のリスト
ENGL() #英大文字のリスト
TS(_str) #変数/リストに格納されている値を確認 => 〇〇:××
T2d(A): #二次元配列の確認用
BR() #横線で区切りを入れる
'''
#----------------------------------------------------------------------------
#このテンプレートではAtCoder Easy Test v2でnumpyは動かない。

n = II()
A = LI()

cnt = collections.Counter(A)
dp = [[[0 for _ in range(105)]for _ in range(105)]for _ in range(105)]

for i in range(101):
    for j in range(101):
        for k in range(101):
            z = i+j+k
            if(z==0): continue
            dp[i][j][k] = n/z
            if(i-1>=0): dp[i][j][k] += dp[i-1][j+1][k] * i / z
            if(j-1>=0): dp[i][j][k] += dp[i][j-1][k+1] * j / z
            if(k-1>=0): dp[i][j][k] += dp[i][j][k-1] * k / z

print(dp[cnt[0]][cnt[1]][cnt[2]])
0