Problem:


Score : 600 points

Problem Statement

We have one slime.

You can set the health of this slime to any integer value of your choice.

A slime reproduces every second by spawning another slime that has strictly less health. You can freely choose the health of each new slime. The first reproduction of our slime will happen in one second.

Determine if it is possible to set the healths of our first slime and the subsequent slimes spawn so that the multiset of the healths of the 2^N slimes that will exist in N seconds equals a multiset S.

Here S is a multiset containing 2^N (possibly duplicated) integers: S_1,~S_2,~...,~S_{2^N}.

Constraints

All values in input are integers.

1 \leq N \leq 18

1 \leq S_i \leq 10^9

Input

Input is given from Standard Input in the following format:

N
S_1 S_2 ... S_{2^N}

Output

If it is possible to set the healths of the first slime and the subsequent slimes spawn so that the multiset of the healths of the 2^N slimes that will exist in N seconds equals S, print Yes; otherwise, print No.

Sample Input 1

2
4 2 3 1

Sample Output 1

Yes

We will show one way to make the multiset of the healths of the slimes that will exist in 2 seconds equal to S.

First, set the health of the first slime to 4.

By letting the first slime spawn a slime whose health is 3, the healths of the slimes that exist in 1 second can be 4,~3.

Then, by letting the first slime spawn a slime whose health is 2, and letting the second slime spawn a slime whose health is 1, the healths of the slimes that exist in 2 seconds can be 4,~3,~2,~1, which is equal to S as multisets.

Sample Input 2

2
1 2 3 1

Sample Output 2

Yes

S may contain multiple instances of the same integer.

Sample Input 3

1
1 1

Sample Output 3

No

Sample Input 4

5
4 3 5 3 1 2 7 8 7 4 6 3 7 2 3 6 2 7 3 2 6 7 3 4 6 7 3 4 2 5 2 3

Sample Output 4

No



Sample input:
2
4 2 3 1


Sample output:
Yes

Submission status: Wrong Answer

Solution code:
def main(n,s):
  from collections import Counter
  cs=Counter(s)
  key=sorted(cs)
  # 最大の体力をkとする
  # 根つき木。葉と枝。
  # 体力kのスライムは根。1のスライムは葉
  # 1は最大2**(n-1)。
  # 体力k-1の親はkのスライム
  # 体力k-1のスライムがn個なら、kのスライムは毎秒k-1を作った。
  # 逆にn個未満なら、k-1未満のスライムを作った秒がその差だけある
  # 体力kは子をn個持てる。体力k-1は子をn-1個持てるものが一個、n-2個持てるものが1個、。。。
  # 体力k-2は難しい。1秒時点で作られたならn-1個子を持てる。その場合、k-1でn-1の子を持てるものはいなくなる。
  # これは考慮しなくてもいいか。k-3のスライムはk,k-1,k-2のどれから生まれたかを考慮しなくてもいい
  if cs[key[-1]]!=1:return 'No'
  from collections import deque
  chd=deque([n])
  now=n
  for x in key[-2::-1]:
    #print(x,now,cs[x],chd)
    if now<cs[x]:return 'No'
    nchd=deque()
    k=cs[x]
    while k:
      if not chd:return 'No'
      tmp=chd.popleft()
      now-=tmp
      for i in range(min(k,tmp)):
        if tmp-1-i:
          nchd.append(tmp-1-i)
          now+=tmp-1-i
      if tmp-1-i:
        nchd.append(tmp-1-i)
        now+=tmp-1-i
      k-=tmp
      k=max(k,0)
    chd+=nchd
    nchd=deque()
  return 'Yes'

n=int(input())
s=list(map(int,input().split()))
print(main(n,s))
#s.sort()
#print(n)
#print(*s,sep=' ')

Submission status: Wrong Answer

Solution code:
def main(n,s):
  from collections import Counter
  cs=Counter(s)
  key=sorted(cs)
  # 最大の体力をkとする
  # 根つき木。葉と枝。
  # 体力kのスライムは根。1のスライムは葉
  # 1は最大2**(n-1)。
  # 体力k-1の親はkのスライム
  # 体力k-1のスライムがn個なら、kのスライムは毎秒k-1を作った。
  # 逆にn個未満なら、k-1未満のスライムを作った秒がその差だけある
  # 体力kは子をn個持てる。体力k-1は子をn-1個持てるものが一個、n-2個持てるものが1個、。。。
  # 体力k-2は難しい。1秒時点で作られたならn-1個子を持てる。その場合、k-1でn-1の子を持てるものはいなくなる。
  # これは考慮しなくてもいいか。k-3のスライムはk,k-1,k-2のどれから生まれたかを考慮しなくてもいい
  if cs[key[-1]]!=1:return 'No'
  from collections import deque
  chd=deque([n])
  now=n
  for x in key[-2::-1]:
    #print(chd)
    if now<cs[x]:return 'No'
    nchd=deque()
    k=cs[x]
    while k:
      if not chd:return 'No'
      tmp=chd.popleft()
      for i in range(min(k,tmp)):
        if tmp-1-i:nchd.append(tmp-1-i)
      if tmp-1-i:nchd.append(tmp-1-i)
      k-=tmp
      k=max(k,0)
    chd+=nchd
    nchd=deque()
  return 'Yes'

n=int(input())
s=list(map(int,input().split()))
print(main(n,s))

Submission status: Wrong Answer

Solution code:
def main(n,s):
    from collections import Counter
    cs=Counter(s)
    key=sorted(cs)
    # 最大の体力をkとする
    # 根つき木。葉と枝。
    # 体力kのスライムは根。1のスライムは葉
    # 1は最大2**(n-1)。
    # 体力k-1の親はkのスライム
    # 体力k-1のスライムがn個なら、kのスライムは毎秒k-1を作った。
    # 逆にn個未満なら、k-1未満のスライムを作った秒がその差だけある
    # 体力kは子をn個持てる。体力k-1は子をn-1個持てるものが一個、n-2個持てるものが1個、。。。
    # 体力k-2は難しい。1秒時点で作られたならn-1個子を持てる。その場合、k-1でn-1の子を持てるものはいなくなる。
    # これは考慮しなくてもいいか。k-3のスライムはk,k-1,k-2のどれから生まれたかを考慮しなくてもいい
    if cs[key[-1]]!=1:return 'No'
    from collections import deque
    chd=deque([n])
    now=n
    for x in key[-2::-1]:
        #print(chd)
        if now<cs[x]:return 'No'
        nchd=deque()
        for _ in range(cs[x]):
            if chd:
                tmp=chd.popleft()
            else:
                return 'No'
            # 子をtmp個持てる頂点に一つ子を作る
            now-=tmp
            if tmp>1:
                now+=tmp-1
                now+=tmp-1
                nchd.append(tmp-1)
                nchd.append(tmp-1)
        chd=chd+nchd
        nchd=deque()
    return 'Yes'

n=int(input())
s=list(map(int,input().split()))
print(main(n,s))

Submission status: Wrong Answer

Solution code:
def main(n,s):
    from collections import Counter
    cs=Counter(s)
    key=sorted(cs)
    # 最大の体力をkとする
    # 根つき木。葉と枝。
    # 体力kのスライムは根。1のスライムは葉
    # 1は最大2**(n-1)。
    # 体力k-1の親はkのスライム
    # 体力k-1のスライムがn個なら、kのスライムは毎秒k-1を作った。
    # 逆にn個未満なら、k-1未満のスライムを作った秒がその差だけある
    # 体力kは子をn個持てる。体力k-1は子をn-1個持てるものが一個、n-2個持てるものが1個、。。。
    # 体力k-2は難しい。1秒時点で作られたならn-1個子を持てる。その場合、k-1でn-1の子を持てるものはいなくなる。
    # これは考慮しなくてもいいか。k-3のスライムはk,k-1,k-2のどれから生まれたかを考慮しなくてもいい
    if cs[key[-1]]!=1:return 'No'
    from collections import deque
    chd=deque([n])
    now=n
    for x in key[-2::-1]:
        if now<cs[x]:return 'No'
        nchd=deque()
        for _ in range(cs[x]):
            if chd:tmp=chd.popleft()
            # 子をtmp個持てる頂点に一つ子を作る
            now-=tmp
            if tmp:
                now+=tmp-1
                now+=tmp-1
                nchd.append(tmp-1)
                nchd.append(tmp-1)
            chd=nchd
            nchd=deque()
    return 'Yes'

n=int(input())
s=list(map(int,input().split()))
print(main(n,s))

Submission status: Wrong Answer

Solution code:
def main(n,s):
    from collections import Counter
    cs=Counter(s)
    key=sorted(cs)
    # 最大の体力をkとする
    # 根つき木。葉と枝。
    # 体力kのスライムは根。1のスライムは葉
    # 1は最大2**(n-1)。
    # 体力k-1の親はkのスライム
    # 体力k-1のスライムがn個なら、kのスライムは毎秒k-1を作った。
    # 逆にn個未満なら、k-1未満のスライムを作った秒がその差だけある
    # 体力kは子をn個持てる。体力k-1は子をn-1個持てるものが一個、n-2個持てるものが1個、。。。
    # 体力k-2は難しい。1秒時点で作られたならn-1個子を持てる。その場合、k-1でn-1の子を持てるものはいなくなる。
    # これは考慮しなくてもいいか。k-3のスライムはk,k-1,k-2のどれから生まれたかを考慮しなくてもいい
    chd=[n]
    now=1
    for x in key[::-1]:
        if now<cs[x]:return 'No'
        now-=cs[x]
        for _ in range(cs[x]):
            if chd:
                tmp=chd.pop()
                now+=tmp
                for i in range(tmp):
                    chd.append(i)
    return 'Yes'

n=int(input())
s=list(map(int,input().split()))
print(main(n,s))

Submission status: Wrong Answer

Solution code:
def main(n,s):
    from collections import Counter
    cs=Counter(s)
    key=sorted(cs)
    # 最大の体力をkとする
    # 根つき木。葉と枝。
    # 体力kのスライムは根。1のスライムは葉
    # 1は最大2**(n-1)。
    # 体力k-1の親はkのスライム
    # 体力k-1のスライムがn個なら、kのスライムは毎秒k-1を作った。
    # 逆にn個未満なら、k-1未満のスライムを作った秒がその差だけある
    # 体力kは子をn個持てる。体力k-1は子をn-1個持てるものが一個、n-2個持てるものが1個、。。。
    # 体力k-2は難しい。1秒時点で作られたならn-1個子を持てる。その場合、k-1でn-1の子を持てるものはいなくなる。
    # これは考慮しなくてもいいか。k-3のスライムはk,k-1,k-2のどれから生まれたかを考慮しなくてもいい
    now=1
    chd=n
    nchd=0
    for x in key[::-1]:
        if now<cs[x]:return 'No'
        nchd=chd-1
        now-=cs[x]
        for _ in range(cs[x]):
            now+=chd
            if chd:chd-=1
        chd=nchd
    return 'Yes'

n=int(input())
s=list(map(int,input().split()))
print(main(n,s))

Submission status: Wrong Answer

Solution code:
def main(n,s):
    from collections import Counter
    cs=Counter(s)
    key=sorted(cs)
    if len(key)<n+1:return 'No'
    # 最大の体力をkとする
    # 根つき木。葉と枝。
    # 体力kのスライムは根。1のスライムは葉
    # 1は最大2**(n-1)。
    # 体力k-1の親はkのスライム
    # 体力k-1のスライムがn個なら、kのスライムは毎秒k-1を作った。
    # 逆にn個未満なら、k-1未満のスライムを作った秒がその差だけある
    # 体力kは子をn個持てる。体力k-1は子をn-1個持てるものが一個、n-2個持てるものが1個、。。。
    # 体力k-2は難しい。1秒時点で作られたならn-1個子を持てる。その場合、k-1でn-1の子を持てるものはいなくなる。
    # これは考慮しなくてもいいか。k-3のスライムはk,k-1,k-2のどれから生まれたかを考慮しなくてもいい
    now=1
    j=0
    # n回分裂できるのは1個、n-1回分裂できるのは1個、n-2回分裂できるのは2個、n-3回分裂できるのは4個
    # n-i回分裂できるのは2**(i-1)個
    tt=[n]
    for i in range(n):
        for _ in range(2**i):
            tt.append(n-i-1)
    for x in key[::-1]:
        if now<cs[x]:return 'No'
        now-=cs[x]
        for _ in range(cs[x]):
            now+=tt[j]
            j+=1
    return 'Yes'

n=int(input())
s=list(map(int,input().split()))
print(main(n,s))

Submission status: Wrong Answer

Solution code:
def main(n,s):
    from collections import Counter
    cs=Counter(s)
    key=sorted(cs)
    if len(key)<n+1:return 'No'
    # 最大の体力をkとする
    # 根つき木。葉と枝。
    # 体力kのスライムは根。1のスライムは葉
    # 1は最大2**(n-1)。
    # 体力k-1の親はkのスライム
    # 体力k-1のスライムがn個なら、kのスライムは毎秒k-1を作った。
    # 逆にn個未満なら、k-1未満のスライムを作った秒がその差だけある
    # 体力kは子をn個持てる。体力k-1は子をn-1個持てるものが一個、n-2個持てるものが1個、。。。
    # 体力k-2は難しい。1秒時点で作られたならn-1個子を持てる。その場合、k-1でn-1の子を持てるものはいなくなる。
    # これは考慮しなくてもいいか。k-3のスライムはk,k-1,k-2のどれから生まれたかを考慮しなくてもいい
    now=1
    j=0
    # n回分裂できるのは1個、n-1回分裂できるのは1個、n-2回分裂できるのは2個、n-3回分裂できるのは4個
    # n-i回分裂できるのは2**(i-1)個
    tt=[n]
    for i in range(n):
        for _ in range(2**i):
            tt.append(n-i-1)
    print(tt)
    for x in key[::-1]:
        if now<cs[x]:return 'No'
        now-=cs[x]
        for _ in range(cs[x]):
            now+=tt[j]
            j+=1
    return 'Yes'

n=int(input())
s=list(map(int,input().split()))
print(main(n,s))

Submission status: Wrong Answer

Solution code:
def main(n,s):
    from collections import Counter
    cs=Counter(s)
    key=sorted(cs)
    # 最大の体力をkとする
    # kは1個
    # k-1は最大n個
    # k-2は最大nCk-2
    # k-3は最大
    # 根つき木。葉と枝。
    # 体力kのスライムは根。1のスライムは葉
    # 1は最大2**(n-1)。
    # 体力k-1の親はkのスライム
    # 体力k-1のスライムがn個なら、kのスライムは毎秒k-1を作った。
    # 逆にn個未満なら、k-1未満のスライムを作った秒がその差だけある
    # 体力kは子をn個持てる。体力k-1は子をn-1個持てるものが一個、n-2個持てるものが1個、。。。
    # 体力k-2は難しい。1秒時点で作られたならn-1個子を持てる。その場合、k-1でn-1の子を持てるものはいなくなる。
    # これは考慮しなくてもいいか。k-3のスライムはk,k-1,k-2のどれから生まれたかを考慮しなくてもいい
    now=1
    j=0
    # n回分裂できるのは1個、n-1回分裂できるのは1個、n-2回分裂できるのは2個、n-3回分裂できるのは4個
    # n-i回分裂できるのは2**(i-1)個
    tt=[n]
    for i in range(n):
        for _ in range(2**i):
            tt.append(n-i-1)
    for x in key[::-1]:
        if now<cs[x]:return 'No'
        now-=cs[x]
        for _ in range(cs[x]):
            now+=tt[j]
            j+=1
    return 'Yes'

n=int(input())
s=list(map(int,input().split()))
print(main(n,s))

Submission status: Wrong Answer

Solution code:
import sys
input = sys.stdin.readline

def main():
    n = int(input())
    slst = list(map(int, input().split()))
    slst.sort(reverse = True)
    lst = [slst[0]]
    
    for i in range(n):
        tmp = pow(2, i)
        for j in range(tmp):
            if lst[j] > slst[tmp + j]:
                lst.append(slst[tmp + j])
            else:
                print("No")
                return

    print("Yes")
    
    
main()

Submission status: Wrong Answer

Solution code:
import sys
input = sys.stdin.readline

n = int(input())
S = sorted(map(int, input().split()), reverse=True)
L = [S[0]]
used = [False]*(1<<n)
used[0] = True
for i in range(n):
  idx = 0
  for j, s in enumerate(S):
    if used[j]:
      continue
    if L[idx] > s:
      L.append(s)
      used[j] = True
      idx += 1
      if idx == 1<<i:
        break
  else:
    print("No")
    exit()
print("Yes")

Submission status: Wrong Answer

Solution code:
import sys
input = sys.stdin.readline

n = int(input())
S = sorted(map(int, input().split()), reverse=True)
L = [S[0]]
used = [False]*(1<<n)
used[0] = True
for i in range(n):
  T = []
  idx = 0
  for j, s in enumerate(S):
    if used[j]:
      continue
    if L[idx] > s:
      T.append(s)
      used[j] = True
      idx += 1
      if idx == 1<<i:
        break
  else:
    print("No")
    exit()
  L += T
print("Yes")

Submission status: Wrong Answer

Solution code:
import sys
input = sys.stdin.readline
n = int(input())
S = sorted(map(int, input().split()), reverse=True)
for i in range(n):
  for j in range(1<<i):
    if S[j] <= S[1<<i|j]:
      print("No")
      exit()
print("Yes")

Submission status: Wrong Answer

Solution code:
N = int(input())
S = sorted(list(map(int, input().split())))[::-1]
piv = 1
t = [0] * pow(2, N)
flg = True
for i, s in enumerate(S):
    for j in range(t[i] + 1, N + 1):
        if s <= S[piv]:
            flg = False
            break
        t[piv] = j
        piv += 1
    if not flg:
        break
print('Yes' if flg else 'No')

Submission status: Wrong Answer

Solution code:
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))  #空白あり


N = I()
S = LI()

A = sorted(list(set(S)),reverse=True)

if len(A) <= N:
    print('No')
    exit()

d = {}
for a in A:
    d[a] = 0
for s in S:
    d[s] += 1

C = [1,1]  # 二項係数
for _ in range(N-1):
    X = [1]
    for i in range(len(C)-1):
        X.append(C[i]+C[i+1])
    X += [1]
    C = X

c = 0
for i in range(N+1):
    c += C[i]
    if d[A[i]] > c:
        print('No')
        break
    c -= d[A[i]]
else:
    print('Yes')

Submission status: Wrong Answer

Solution code:
def main():
    lim = int(input())
    s = list(map(int, input().split()))
    n = len(s)
    s.sort(reverse=True)
    f = True
    for i in range(lim):
        p = 2**i
        for j in range(p):
            if s[j] <= s[p+j]:
                f = False
                break
        if not f:
            break
    if f:
        print("Yes")
    else:
        print("No")

if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
def main():
    lim = int(input())
    s = list(map(int, input().split()))
    n = len(s)
    s.sort(reverse=True)
    sec = [float("inf")]*n
    sec[0] = 0
    f = True
    p = 0
    for i in range(n):
        rng = lim - sec[i]
        if rng > 0:
            for j in range(1, rng+1):
                if s[i] > s[p+j]:
                    sec[p+j] = sec[i] + j
                else:
                    f = False
                    break
            p += rng
        if not f:
            break
    if f:
        print("Yes")
    else:
        print("No")

if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
def examA():
    N = I()
    ans = 0
    print(ans)
    return

def examB():
    ans = 0
    print(ans)
    return

def examC():
    ans = 0
    print(ans)
    return

def examD():
    ans = 0
    print(ans)
    return

def examE():
    class Bit():
        def __init__(self, n):
            self.size = n
            self.tree = [0] * (n + 1)
            return

        def sum(self, i):
            s = 0
            while i > 0:
                s += self.tree[i]
                i -= i & -i
            return s

        def add(self, i, x=1):
            # i==0 はだめ => 全部+1するとか
            while i <= self.size:
                self.tree[i] += x
                i += i & -i
            return

        def search(self, x):
            # 二分探索。和がx以上となる最小のインデックス(>= 1)を返す
            # maspyさんの参考　よくわかってない
            i = 0
            s = 0
            step = 1 << ((self.size).bit_length() - 1)
            while step:
                if i + step <= self.size and s + self.tree[i + step] < x:
                    i += step
                    s += self.tree[i]
                step >>= 1
            return i + 1

        def debug(self, k):
            return [self.sum(i) for i in range(k)]

    N = I()
    P = LI()
    Order = [[i+1] for i in range(N)]
    for i,p in enumerate(P):
        Order[i].append(p)
    Order.sort(key=lambda x:x[1],reverse=True)
    #print(Order)
    ans = 0
    bit = Bit(N+2)

    for i,p in Order:
        L = bit.sum(i)
        R = bit.sum(N)-L
        bit.add(i)
        l0, l1, r0, r1 = 0, 0, N+1, N+1
        if L>=2:
            l0 = bit.search(L-1)
        if L>=1:
            l1 = bit.search(L)
        if R>=1:
            r0 = bit.search(L+2)
        if R>=2:
            r1 = bit.search(L+3)
        #print(L,R)
        #print(l0,l1,r0,r1)
        #print(bit.debug(N+2))
        cnt = 0
        if l1>0:
            cnt += (l1-l0)*(r0-i)
        if r0>0:
            cnt += (i-l1)*(r1-r0)
        ans += cnt * p
        #print(ans)
    print(ans)
    return

def examF():
    def bfs(N, S):
        used = [False] * (1<<N)
        used[0] = True
        for n in range(N):
            cur = deque()
            rem = 1<<n
            for i in range(1<<N):
                s = S[i]
                if used[i]:
                    cur.append(s)
                elif cur and cur[0] > s:
                    cur.popleft()
                    used[i] = True
                    rem -= 1
                    if rem == 0:
                        break
            if rem > 0:
                print(cur,used)
                return 'No'
        return 'Yes'
    N = I()
    S = LI()
    S.sort(reverse=True)
    #print(S)
    ans = bfs(N,S)
    print(ans)
    return


import sys,copy,bisect,itertools,heapq,math
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
alphabet = [chr(ord('a') + i) for i in range(26)]

if __name__ == '__main__':
    examF()

"""
5
4 3 5 3 1 2 7 8 7 4 6 3 7 2 3 6 2 7 3 2 6 7 3 4 6 6 3 4 2 5 2 3

"""

Submission status: Wrong Answer

Solution code:
class MultisetBIT:
    """
    最大値が小さい数について、その重複を許した集合を管理する。
    最大値 maxvalue を受け取り、[0, maxvalue] を管理する。
    counter は辞書型かリスト型で、counter[i] が i の個数を持つことを仮定する。
    counter が与えられなかった場合は、全て個数 0 で初期化される。
    基本的に閉区間で管理する。
    内部では受け取った数を +1 したものをindexとして持っているので注意。
    """

    __slots__ = ["n", "k", "data"]

    def __init__(self, maxvalue, counter = None):
        self.n = maxvalue + 1
        self.k = 1 << ((self.n + 1).bit_length() - 1)
        self.data = [0] * (self.n + 1)
        if counter is not None:
            self.update(counter)
        
    def update(self, counter):
        """
        counter を受け取って、それを反映させる。
        counter は辞書型かリスト型で、counter[i] が i の個数を持つことを仮定する。(0 <= i <= maxvalue)
        計算量は、n を要素の最大値として、 O(n) となる。
        """
        if isinstance(counter, list):
            self.data = [0] + counter + [0] * (self.n - len(counter))
        else:
            self.data = [0] * (self.n + 1)
            for k, v in counter.items():
                self.data[k + 1] = v
        for i in range(1, self.n + 1):
            if i + (i & -i) <= self.n:
                self.data[i + (i & -i)] += self.data[i]

    def add(self, value):
        """
        与えられた引数 value (0 <= value <= maxvalue) を Multiset に加える。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        value += 1
        while value <= self.n:
            self.data[value] += 1
            value += value & -value

    def pop(self, value):
        """
        Multiset から与えられた引数 value (0 <= value <= maxvalue) を取り除く。
        与えられた引数が Multiset に入っているかのチェックは行わなず、
        単にその個数を 1 減らすだけなので注意。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        value += 1
        while value <= self.n:
            self.data[value] -= 1
            value += value & -value

    def count_le(self, value):
        """
        Multiset 内の要素 elem のうち、0 <= elem <= value を満たすものを数える。
        計算量は、n を要素の最大値として、 O(log n) となる。
        value は value <= maxvalue を満たす必要がある。
        """
        value += 1
        ret = 0
        while value > 0:
            ret += self.data[value]
            value -= value & -value
        return ret

    def count(self, first, last):
        """
        Multiset 内の要素 elem のうち、first <= elem <= last を満たすものを数える。
        計算量は、n を要素の最大値として、 O(log n) となる。
        0 <= first <= last <= max_value が必要。
        """
        last += 1
        ret = 0
        while first < last:
            ret += self.data[last]
            last -= last & -last
        while last < first:
            ret -= self.data[first]
            first -= first & -first
        return ret

    def __getitem__(self, index):
        if isinstance(index, slice):
            return self.count(index.start, index.stop - 1)
        else:
            return self.count(index, index)

    def bisect(self, count):
        """
        Multiset 内の要素 elem のうち、count <= count_le(elem) を満たす最小のelemを返す。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        ret = 0
        k = self.k
        while k > 0:
            if ret + k <= self.n and self.data[ret + k] < count:
                count -= self.data[ret + k]
                ret += k
            k //= 2
        return ret

    def lower_bound(self, value):
        """
        Multiset 内の要素 elem のうち、value <= elem を満たす最小のelemを返す。
        そのような elem が存在しない場合は maxvalue + 1 を返す。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        return self.bisect(self.count_le(value - 1) + 1)

    def upper_bound(self, value):
        """
        Multiset 内の要素 elem のうち、value < elem を満たす最小のelemを返す。
        そのような elem が存在しない場合は maxvalue + 1 を返す。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        return self.bisect(self.count_le(value) + 1)


N = int(input())
S_list = sorted(map(int, input().split()), reverse=True)

ans_tree = [0] * ((2 ** N) * 2)

ms = MultisetBIT((2 ** N) * 2)
ms.add(1)
for S in S_list:
    elem = ms.lower_bound(0)
    while elem != ((2 ** N) * 2 + 1) and ans_tree[elem // 2] == S:
        elem = ms.upper_bound(elem)
    
    if elem == ((2 ** N) * 2 + 1):
        print("No")
        exit()
    else:
        ms.pop(elem)
        ans_tree[elem] = S
        elem *= 2
        while elem < 2 ** N * 2:
            ans_tree[elem] = S
            ms.add(elem + 1)
            elem *= 2

print("Yes")
print(ans_tree)

Submission status: Wrong Answer

Solution code:
import sys
input = sys.stdin.buffer.readline

N = int(input())
Ss = sorted(map(int, input().split()), reverse=True)

for i in range(2 ** (N-1)):
    child = i + (1 << i.bit_length())
    if Ss[i] == Ss[child]:
        print("No")
        exit()

print("Yes")

Submission status: Wrong Answer

Solution code:
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")


n = int(input())
s = list(map(int, input().split()))
s.sort(reverse=True)
l = pow(2,n)//2
ans = True
while l>0:
    for i in range(l):
        if s[i]<=s[i+l]:
            ans = False
            break
    else:
        s = s[:l]
        l //= 2
    if not ans:
        break
else:
    ans = True
if ans:
    print("Yes")
else:
    print("No")

Submission status: Wrong Answer

Solution code:
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")


n = int(input())
s = list(map(int, input().split()))
s.sort(reverse=True)
l = pow(2,n)//2
ans = True
while l>0:
    for i in range(l):
        if s[i]==s[i+l]:
            ans = False
            break
    else:
        s = s[:l]
        l //= 2
    if not ans:
        break
else:
    ans = True
if ans:
    print("Yes")
else:
    print("No")

Submission status: Wrong Answer

Solution code:
n = int(input())
s = list(map(int,input().split()))
s.sort(reverse=True)
nums = [0] * 2**n

def next_combination(sub):
    x = sub & -sub
    y = sub + x
    return (((sub & ~y) // x) >> 1) | y

ind = 0
for i in range(n,0,-1):
    j = (1<<i) -1
    while(j < 2**n):
        nums[j] = s[ind]
        ind += 1
        j = next_combination(j)

nums[0] = s[ind]

while(len(nums) > 1):
    new = []
    it = iter(nums)
    for l,r in zip(it,it):
        if(l>=r):
            print('No')
            exit()
        new.append(r)

    nums = new

print('Yes')

Submission status: Wrong Answer

Solution code:
N = int(input())
A = list(map(int, input().split()))
A.sort(reverse=True)
flag = True
for i in range(N):
    B = A[:(2**i)]
    C = A[(2**i):(2**(i+1))]
    if not all(B[j] > C[j] for j in range(2**i)):
        flag = False
        break
if flag:
    print("Yes")
else:
    print("No")

Submission status: Wrong Answer

Solution code:
N = int(input())
A = list(map(int, input().split()))
A.sort(reverse=True)
flag = True
for i in range(N):
    B = A[:(2**i)]
    C = A[(2**i):(2**(i+1))]
    if any(B[j] <= C[j] for j in range(2**i)):
        flag = False
        break
if flag:
    print("Yes")
else:
    print("No")

Submission status: Wrong Answer

Solution code:
N = int(input())
A = list(map(int, input().split()))
A.sort(reverse=True)
flag = True
for i in range(N):
    if min(A[:(2**i)]) <= max(A[(2**i):]):
        flag = False
        break
if flag:
    print("Yes")
else:
    print("No")

Submission status: Wrong Answer

Solution code:
from collections import Counter


class PascalsTriangle:
    def __init__(self, N):
        self.N = N
        self._build()

    def __call__(self, n, r):
        if n > self.N:
            raise "INVALID INPUT: input n must be smaller than N"
        if r < 0 or r > self.N:
            return 0
        return self.nCr[n][r]

    def _build(self):
        tmp = [(1,)]
        for i in range(1, self.N + 1):
            nCi = tuple(1 if j in (0, i)
                        else tmp[-1][j-1] + tmp[-1][j] for j in range(i+1))
            tmp.append(nCi)
        self.nCr = tuple(tmp)


nCr = PascalsTriangle(20)


def main():
    N = int(input())
    A = list(map(int, input().split()))

    C = Counter(A)
    keys = sorted(C.keys())

    for i in range(N):
        val = nCr(N, i)
        k = keys.pop()
        if C[k] > val:
            return False
        val -= C[k]
        while val:
            k = keys.pop()
            d = min(val, C[k])
            val -= d
            C[k] -= d
            if C[k] > 0:
                keys.append(k)
    return True


if main():
    print("Yes")
else:
    print("No")

Submission status: Wrong Answer

Solution code:
import sys
input = sys.stdin.readline

def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))

def main():
    """
    グラフ，2^i区切りで見ていって，親を決める．
    BFSで上から大きい数字を振っていく=>ダメっぽい
    なんかもっと単純に，今いるやつと，残りを持っておくか

    """
    
    mod=10**9+7
    N2=I()
    N=pow(2,N2)
    S=LI()
    S.sort(reverse=True)
    L=[S[0]]
    ite=1# Sの要素で次に見るやつ
    
    flag=1
    while ite!=N:
        temp=[]
        for val in L:
            if val>S[ite]:
                temp.append(S[ite])
                ite+=1
            else:
                flag=0
                break
        if flag==0:
            break    
        L+=temp
    
    if flag:
        print("Yes")
    else:
        print("No")

main()

Submission status: Wrong Answer

Solution code:
import sys
input = sys.stdin.readline

def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))

def main():
    """
    グラフ，2^i区切りで見ていって，親を決める．
    BFSで上から大きい数字を振っていく
    """
    
    mod=10**9+7
    N2=I()
    N=pow(2,N2)
    S=LI()
    S.sort(reverse=True)
    P=[0]*N
    adj=[[]for _ in range(N)]
    p2=1
    for i in range(1,N):
        if i-p2 == p2:
            p2*=2
        P[i]=i-p2
        adj[i].append(P[i])
        adj[P[i]].append(i)
        
    for i in range(N):
        adj[i].sort()
    
    L=[-1]*N
    import queue
    q=queue.Queue()
    q.put(0)
    L[0]=S[0]
    ite=1
    while not q.empty():
        v=q.get()
        for nv in adj[v]:
            if L[nv]==-1:
                L[nv]=S[ite]
                ite+=1
                q.put(nv)
    
    
    
    flag=1
    for i in range(1,N):
        if L[i] >= L[P[i]]:
            flag=0
            break
    
    if flag:
        print("Yes")
    else:
        print("No")

main()

Submission status: Wrong Answer

Solution code:
import sys
input = sys.stdin.readline

def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))

def main():
    """
    今はでかいやつから発生させているけど，違う．
    例えば5,4,4,4,3,3,3,2なら
    5から3つの4，4,4,から(3,3),(3),()，最初にできた3から２ができる
    
    グラフなんだからBFSで上からでかい数を埋めていく
    """
    
    mod=10**9+7
    N2=I()
    N=pow(2,N2)
    S=LI()
    S.sort(reverse=True)
    P=[0]*N
    adj=[[]for _ in range(N)]
    p2=1
    for i in range(1,N):
        if i-p2 == p2:
            p2*=2
        P[i]=i-p2
        adj[i].append(P[i])
        adj[P[i]].append(i)
        
    for i in range(N):
        adj[i].sort()
    
    L=[-1]*N
    import queue
    q=queue.Queue()
    q.put(0)
    L[0]=S[0]
    ite=1
    while not q.empty():
        v=q.get()
        for nv in adj[v]:
            if L[nv]==-1:
                L[nv]=S[ite]
                ite+=1
                q.put(nv)
    
    
    
    flag=1
    for i in range(1,N):
        if L[P[i]] <= L[i]:
            flag=0
            break
    
    if flag:
        print("Yes")
    else:
        print("No")

main()

Submission status: Wrong Answer

Solution code:
import sys
input = sys.stdin.readline

def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))

def main():
    """
    今はでかいやつから発生させているけど，違う．
    例えば5,4,4,4,3,3,3,2なら
    5から3つの4，4,4,から(3,3),(3),()，最初にできた3から２ができる
    
    グラフなんだからBFSで上からでかい数を埋めていく
    """
    
    mod=10**9+7
    N2=I()
    N=pow(2,N2)
    inf=10**9 + 1
    S=LI()
    S.sort(reverse=True)
    P=[0]*N
    adj=[[]for _ in range(N)]
    p2=1
    for i in range(1,N):
        if i-p2 == p2:
            p2*=2
        P[i]=i-p2
        adj[i].append(P[i])
        adj[P[i]].append(i)
        
    L=[-1]*N
    import queue
    q=queue.Queue()
    q.put(0)
    L[0]=S[0]
    ite=1
    while not q.empty():
        v=q.get()
        for nv in adj[v]:
            if L[nv]==-1:
                L[nv]=S[ite]
                ite+=1
                q.put(nv)
    
    
    
    flag=1
    for i in range(1,N):
        if L[P[i]] <= L[i]:
            flag=0
            break
    
    if flag:
        print("Yes")
    else:
        print("No")

main()

Submission status: Wrong Answer

Solution code:
import sys
input = sys.stdin.readline

def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))

def main():
    mod=10**9+7
    N2=I()
    N=pow(2,N2)
    inf=10**9 + 1
    S=LI()
    S.sort(reverse=True)
    S+=[inf]
    P=[-1]*(N+1)
    p2=1
    for i in range(1,N):
        if i-p2 == p2:
            p2*=2
        P[i]=i-p2
        
    flag=1
    for i in range(N):
        if S[P[i]] <= S[i]:
            flag=0
            break
    
    if flag:
        print("Yes")
    else:
        print("No")

main()

Submission status: Wrong Answer

Solution code:
import sys
N=int(input())
slist=list(map(int,input().split()))

slist.sort(reverse=True)
for i in range(N):
  slist_left=slist[:len(slist)//2]
  slist_right=slist[len(slist)//2:]
  #print(slist_left,slist_right)
  
  for j in range(len(slist)//2):
    if slist_left[j]<=slist_right[j]:
      print("No")
      sys.exit(0)

  slist=slist_left
  
print("Yes")