from collections import deque
import sys
input = sys.stdin.readline

N = int(input())
grid = [list(input().strip()) for _ in range(N)]
visited = [[[False] * N for _ in range(N)] for _ in range(2)]
answer = [0, 0]

def bfs(start, visited, st):
    queue = deque([start])
    dy = [0,1,0,-1]
    dx = [-1,0,1,0]

    while queue:
        y,x = queue.popleft()
        for i in range(4):
            ny, nx = y+dy[i], x+dx[i]
            if 0<=ny<N and 0<=nx<N and not visited[ny][nx]:
                if st[grid[y][x]] == st[grid[ny][nx]]:
                    queue.append((ny,nx))
                    visited[ny][nx] = True
    return 1

for i in range(N):
    for j in range(N):
        if not visited[0][i][j]:
            answer[0] += bfs((i,j), visited[0], {'R':0,'G':1,'B':2})
        if not visited[1][i][j]:
            answer[1] += bfs((i,j), visited[1], {'R':0,'G':0,'B':2})

print(answer[0], answer[1])

N = int(input())
arr = list(map(int, input().split()))
forward, backward = [arr[0]]+[0]*(N-1), [0]*(N-1)+[arr[-1]]
for i in range(1,N):
    forward[i] = forward[i-1] + arr[i]
    backward[N-i-1] = backward[N-i] + arr[N-i-1]
answer = 0

for i in range(1,N-1):
    answer = max(answer, forward[N-1]*2-forward[0]-forward[i-1]-arr[i]*2)
    answer = max(answer, backward[0]*2-backward[N-1]-backward[N-i]-arr[N-i-1]*2)
    answer = max(answer, forward[i]-arr[0]+backward[i]-arr[-1])

print(answer)

from collections import deque
import sys
input = sys.stdin.readline

W, H = map(lambda x: int(x)+2, input().split())
maps = [[0] * W for _ in range(H)]
for i in range(1,H-1):
    maps[i] = [0]+list(map(int, input().split()))+[0]
visited = [[False] * W for _ in range(H)]

def bfs(start):
    queue = deque([start])
    dy = [0,1,0,-1,1,-1]
    cnt = 0

    while queue:
        y,x = queue.popleft()
        dx = [-1,0,1,0,-1,-1] if y%2==0 else [-1,0,1,0,1,1]
        for i in range(6):
            ny, nx = y+dy[i], x+dx[i]
            if 0<=ny<H and 0<=nx<W:
                if maps[ny][nx] == 0 and not visited[ny][nx]:
                    queue.append((ny,nx))
                    visited[ny][nx] = True
                elif maps[ny][nx] == 1:
                    cnt += 1
    return cnt

visited[0][0] = True
print(bfs((0,0)))

from datetime import date
strptime = lambda: date(**{k:int(v) for k,v in zip(['year','month','day'],input().split())})
today, dday = strptime(), strptime()
if dday >= today.replace(today.year+1000):
    print('gg')
else:
    print('D-'+str((dday-today).days))

from collections import deque
import sys
input = sys.stdin.readline

M, N, H = map(int, input().split())
box = [[list(map(int, input().split())) for _ in range(N)] for _ in range(H)]
queue = deque([(h,r,c) for h in range(H) for r in range(N) for c in range(M) if box[h][r][c]==1])
days = 0

dz = [0,0,0,0,1,-1]
dy = [0,1,0,-1,0,0]
dx = [-1,0,1,0,0,0]

while queue:
    z,y,x = queue.popleft()
    days = max(days, box[z][y][x])
    for i in range(6):
        nz,ny,nx = z+dz[i],y+dy[i],x+dx[i]
        if 0<=nz<H and 0<=ny<N and 0<=nx<M and box[nz][ny][nx]==0:
            box[nz][ny][nx] = box[z][y][x] + 1
            queue.append((nz,ny,nx))

if 0 in {cell for layer in box for row in layer for cell in row}:
    print(-1)
else:
    print(days-1)

from collections import deque
import sys
input = sys.stdin.readline

M, N = map(int, input().split())
box = [list(map(int, input().split())) for _ in range(N)]
days = 0

# ============== 1안 (시간초과) =============

def bfs(graph, start, n, m, vistied):
    queue = deque([start])
    dist = 0

    dy = [0,1,0,-1]
    dx = [-1,0,1,0]

    while queue:
        for _ in range(len(queue)):
            y,x = queue.popleft()
            if graph[y][x] == 1:
                return dist
            for i in range(4):
                ny,nx = y+dy[i],x+dx[i]
                if 0<=ny<n and 0<=nx<m and not vistied[ny][nx] and graph[ny][nx]!=-1:
                    queue.append((ny,nx))
                    vistied[ny][nx] = True
        dist += 1
    raise Exception()

try:
    for i in range(N):
        for j in range(M):
            if box[i][j] == 0:
                vistied = [[False] * M for _ in range(N)]
                vistied[i][j] = True
                days = max(days, bfs(box, (i,j), N, M, vistied))
    print(days)
except Exception:
    print(-1)

# =============== 2안 (통과) ===============

queue = deque()
for i in range(N):
    for j in range(M):
        if box[i][j] == 1:
            queue.append((i,j))

def bfs(graph, queue, n, m):
    dy = [0,1,0,-1]
    dx = [-1,0,1,0]

    while queue:
        y,x = queue.popleft()
        for i in range(4):
            ny,nx = y+dy[i],x+dx[i]
            if 0<=ny<n and 0<=nx<m and graph[ny][nx]==0:
                graph[ny][nx] = graph[y][x] + 1
                queue.append((ny,nx))

bfs(box, queue, N, M)
for i in range(N):
    for j in range(M):
        if box[i][j] == 0:
            print(-1)
            exit(0)
        days = max(days, box[i][j])
print(days-1)

N = int(input())
X = list(map(int, input().split()))
xtoi = {x:i for i,x in enumerate(sorted(set(X)))}
print(' '.join(map(lambda x: str(xtoi[x]), X)))

import sys
input = sys.stdin.readline

N = int(input())
times = sorted([tuple(map(int, input().split())) for _ in range(N)], key=lambda x: [x[1],x[0]])
count, end_time = 0, 0

for t1,t2 in times:
    if t1 >= end_time:
        count += 1
        end_time = t2

print(count)

from itertools import combinations
import sys
input = sys.stdin.readline

N, M = map(int, input().split())
city = {'0':list(),'1':list(),'2':list()}
for r in range(N):
    for c,i in enumerate(input().split()):
        city[i].append((r,c))
houses, chickens = city['1'], city['2']
diff = lambda c1,c2: abs(c1[0]-c2[0])+abs(c1[1]-c2[1])

# =============== 1안 (틀림) ===============

house_cost = {chicken:0 for chicken in chickens}
chicken_cost = {house:house_cost.copy() for house in houses}

for house in houses:
    for chicken in chickens:
        cost = diff(house,chicken)
        chicken_cost[house][chicken] = cost
        house_cost[chicken] += cost

city_cost = 0
open = [chicken for chicken,cost in sorted(house_cost.items(), key=lambda x: x[1])[:M]]
for house, costs in chicken_cost.items():
    city_cost += min([cost for chicken,cost in costs.items() if chicken in open])

# =============== 2안 (통과) ===============

city_cost = sys.maxsize
for comb in combinations(chickens, M):
    cost = 0
    for house in houses:
        cost += min([diff(house,chicken) for chicken in comb])
    city_cost = min(city_cost,cost)

print(city_cost)

import heapq
import sys
input = sys.stdin.readline

N = int(input())
arr = list()

for _ in range(N):
    x = int(input())
    if x > 0:
        heapq.heappush(arr, x)
    else:
        if arr:
            print(heapq.heappop(arr))
        else:
            print(0)