딩딩크롱의 블로그

개념 #12. 트리 순회(Tree traversal) 후위 순회, 전위 순회, 중위 순회

딩딩크롱 — Sat, 29 Jul 2023 02:11:55 +0900

트리 순회(Tree traversal)는 트리 구조에서 각각의 노드를 정확히 한 번만, 체계적인 방법으로 방문하는 과정을 말한다. 이는 노드를 방문하는 순서에 따라 후위 순회, 전위 순회, 중위 순회, 레벨 순회가 있다. 보통 설명할 때는 이진 트리를 기반으로 설명하지만 다른 모든 트리에서 일반화를 시킬 수 있다.

후위 순회

후위 순회(postorder traversal)는 자식들 노드를 방문하고 자신의 노드를 방문하는 것을 말한다.

postorder( node )
    if (node.visited == false) 
        postorder( node->left ) 
        postorder( node->right )
        node.visited = true

전위 순회

전위 순회(preorder traversal)는 먼저 자신의 노드를 방문하고 그 다음 노드들을 방문하는 것을 말한다. (DFS)

preorder( node )
    if (node.visited == false)
        node.visited = true
        preorder( node->left )
        preorder( node->right )

중위 순회

중위 순회(inorder traversal)는 왼쪽 노드를 먼저 방문 그 다음의 자신의 노드를 방문하고 그 다음 오른쪽 노드를 방문하는 것을 말한다.

inorder( node )
    if (node.visited == false) 
        inorder( node->left )
        node.visited = true
        inorder( node->right )

레벨 순회

레벨 순회(lever traversal)는 BFS

Q. 아래의 그래프가 주어졌을 때 preorder, inorder, postorder를 구현하라.

adj = [[] for _ in range(1004)]
visited = [0] * 1004

def postOrder(here):
    if visited[here] == 0:
        if len(adj[here]) == 1:
            postOrder(adj[here][0])
        if len(adj[here]) == 2:
            postOrder(adj[here][0])
            postOrder(adj[here][1])
        visited[here] = 1
        print(here, end=' ')

def preOrder(here):
    if visited[here] == 0:
        visited[here] = 1
        print(here, end=' ')
        if len(adj[here]) == 1:
            preOrder(adj[here][0])
            
        if len(adj[here]) == 2:
            preOrder(adj[here][0])
            preOrder(adj[here][1])

def inOrder(here):
    if visited[here] == 0:
        if len(adj[here]) == 1:
            inOrder(adj[here][0])
            visited[here] = 1
            print(here, end=' ')
        elif len(adj[here]) == 2:
            inOrder(adj[here][0])
            visited[here] = 1
            print(here, end=' ')
            inOrder(adj[here][1])
        else:
            visited[here] = 1
            print(here, end=' ')

adj[1].extend([2, 3])
adj[2].extend([4, 5])
root = 1
print("\n트리순회 : postOrder")
postOrder(root)
visited = [0] * 1004  # Reset visited array
print("\n트리순회 : preOrder")
preOrder(root)
visited = [0] * 1004  # Reset visited array
print("\n트리순회 : inOrder")
inOrder(root)

'''
트리순회 : postOrder
4 5 2 3 1
트리순회 : preOrder
1 2 4 5 3
트리순회 : inOrder
4 2 5 1 3
'''

[AWS EC2 + Docker + Github Actions + Spring Boot] 자동 배포 환경

딩딩크롱 — Sun, 16 Jul 2023 02:59:48 +0900

Dockerfile 생성하기

Dockerfile

FROM openjdk:17-jdk
COPY build/libs/*.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "-Dspring.profiles.active=prod", "/app.jar"]

build.gradle

jar {
    enabled = false
}

Github 리포지토리 생성 후 push

AWS EC2 인스턴스 생성하기

키 페어
방화벽(보안 그룹)
탄력적 IP 주소
- 인스턴스의 Publid IP는 고정된 IP 주소가 아니라 유동적인 IP 주소이다.
- EC2 인스턴스를 STOP 하고 중지 상태에서 새롭게 실행 상태로 변경하면, 기존에 할당받은 IP 주소가 변경되어 버린다.
- 이를 해결하고자 AWS에서는 한 번 할당받으면 절대 바뀌지 않는 Elastic IP를 제공한다.

EC2 × Docker

# 패키지 원격 설치 도구인 YUM 업데이트한다.
sudo yum update -y

# YUM을 이용해 docker 설치한다.
sudo yum install -y docker

# 리눅스 계정인 ec2-user에 docker 사용 시 sudo를 붙이지 않고도 사용할 수 있게 한다.
sudo usermod -aG docker ec2-user

# docker 데몬 부팅 시 자동 시작 서비스로 등록하고 재시작한 뒤 EC2를 재시작한다.
sudo systemctl enable docker
sudo systemctl restart docker
sudo reboot

# 재시작을 확인한 뒤 putty를 재접속한 다음 docker version의 서버(Server:)를 통해 정상 동작하는 도커를 확인한다.
docker version

실행 중인 모든 컨테이너를 종료하려면

docker kill $(docker ps -a -q)

EC2 × Git

# git 패키지를 설치한다.
sudo yum -y install git

# git을 다운로드 한다.
git clone [URL]

Git Actions를 사용해 자동 배포하기

Actions > New workflow > Java with Gradle 선택

./github/workflows/github-actions.yml

name: Java CI with Gradle

on:
  push:
    branches: [ "main" ]
  pull_request:
    branches: [ "main" ]

permissions:
  contents: read

jobs:
  build:

    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v3
    
    - name: Setup Java JDK 17
      uses: actions/setup-java@v3
      with:
        java-version: '17'
        distribution: 'temurin'        
      
    - name: Make application.yml
      run: |
        cd ./src/main/resources
        touch ./application.yml
        echo "${{ secrets.APPLICATION_YML }}" > ./application.yml
        
    - name: Run chmod to make gradlew executable
      run: chmod +x gradlew
        
    - name: Gradle Build Action
      uses: gradle/gradle-build-action@v2.6.0
      with:
        arguments: clean build
      
    - name: Docker Login
      uses: docker/login-action@v2.2.0
      with:
        username: ${{ secrets.DOCKER_USERNAME }}
        password: ${{ secrets.DOCKER_PASSWORD }}
        
    - name: Build and push Docker images
      uses: docker/build-push-action@v4.1.1
      with:
        context: .
        push: true
        tags: ${{ secrets.DOCKER_USERNAME }}/spring-boot-server

    - name: Deploy to AWS EC2
      uses: appleboy/ssh-action@v0.1.10
      with:
        host: ${{ secrets.HOST }}
        username: ec2-user
        key: ${{ secrets.PRIVATE_KEY }} # pem key
        script: |
          docker pull ${{ secrets.DOCKER_USERNAME }}/spring-boot-server
          docker stop $(docker ps -a -q)
          docker run -d --log-driver=syslog -p 8080:8080 ${{ secrets.DOCKER_USERNAME }}/spring-boot-server
          docker rm $(docker ps --filter 'status=exited' -a -q)
          docker image prune -a -f

Settings > Secrets and variables > Actions > New repository secrets

APPLICATION_YML : DB의 정보를 담고 있는 application.yml을 .gitignore에 추가하고 파일 내용을 비공개로 하여 생성하도록 하는 값
DOCKER_PASSWORD : 도커 허브 비밀번호
DOCKER_USERNAME : 도커 허브 사용자 이름
HOST : EC2 탄력적 IP 주소
PRIVATE_KEY : EC2 생성 시 생성한 pem 키 (BEGIN END 라인 포함)

위와 같이 완료되면 yml 파일 생성, 이미지 생성 및 도커 허브 업로드, 서버에서 실행된다.

에러 사항

Git Actions를 사용하면서 다양한 에러를 마주했다.

그 중에 가장 기억에 남는 것은 다음과 같다.

1. ssh.ParsePrivateKey: ssh: no key found (✅)

- Amazon Linux 2023 AMI ➔ Amazon Linux 2 AMI

https://github.com/appleboy/ssh-action/issues/6
https://github.com/appleboy/ssh-action#setting-up-ssh-key

2. dial tcp ~:22 i/o timeout' (✅)

https://dev.to/tarohida/error-on-appleboyssh-action-dial-tcp-lookup-exampleexample-on-19202153-io-timeout-6ng

3. 서버 구동 시 제대로 동작하지 않는 현상 (✅)

https://zzang9ha.tistory.com/331

- AWS EC2 보안 그룹의 8080 포트에 대해 인바운드 규칙을 설정하지 않아서 생긴 문제였다.

- 톰캣 포트(8080)을 붙여야 접속이 가능하므로 (80 ➔ 8080) 포트 포워딩을 해주었다.

- 80 포트에 대한 인바운드 규칙도 추가하였다.

# 80 port로 들어오면 8080 port로 재매핑
sudo iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 80 -j REDIRECT --to-port 8080

# 포트 포워딩 삭제
sudo iptables -t nat -D PREROUTING [num]

느낀점

도커의 중요성을 알고는 있었지만 적용해 본 것은 처음이라 재밌었다.

처음 자동 배포라는 것을 적용하면서 많은 어려움이 있었지만 복잡한 작업들을 내가 직접 하지 않아도 되어 개발이 매우 간편해졌다.

이렇게 구현하고자 했지만 실패했다..ㅠ

[백준] 1992번: 쿼드트리

딩딩크롱 — Tue, 30 May 2023 01:31:29 +0900

문제

https://www.acmicpc.net/problem/1992

1992번: 쿼드트리

첫째 줄에는 영상의 크기를 나타내는 숫자 N 이 주어진다. N 은 언제나 2의 제곱수로 주어지며, 1 ≤ N ≤ 64의 범위를 가진다. 두 번째 줄부터는 길이 N의 문자열이 N개 들어온다. 각 문자열은 0 또

www.acmicpc.net

풀이

재귀를 사용해 풀었습니다.
현재 구역의 색상이 모두 같으면 해당 색상을 출력합니다.
만약 다르다면 4개의 구역으로 분할하고 재확인해 괄호와 함께 출력합니다.
재귀를 이용하여 색상이 다르면 계속해서 분할하여 확인하게 됩니다.

코드

import java.util.*;
import java.io.*;

public class Main {
    public static char[][] image;

    public static boolean check(int x, int y, int n) {
        for (int i = x; i < x + n; i++) {
            for (int j = y; j < y + n; j++) {
                if (image[i][j] != image[x][y]) {
                    return false;
                }
            }
        }
        return true;
    }

    public static void QuadTree(int x, int y, int n) {
        if (check(x, y, n)) {
            System.out.print(image[x][y]);
        } else {
            System.out.print('(');
            n /= 2;
            QuadTree(x, y, n);
            QuadTree(x, y + n, n);
            QuadTree(x + n, y, n);
            QuadTree(x + n, y + n, n);
            System.out.print(')');
        }
    }

    public static void main(String args[]) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int N = Integer.parseInt(br.readLine());

        image = new char[N][N];
        for (int i = 0; i < N; i++) {
            image[i] = br.readLine().toCharArray();
        }

        QuadTree(0, 0, N);
    }
}

import sys

input = sys.stdin.readline


def check(x, y, n):
    for i in range(x, x + n):
        for j in range(y, y + n):
            if image[i][j] != image[x][y]:
                return False
    return True


def QuadTree(x, y, n):
    if check(x, y, n):
        print(image[x][y], end="")
    else:
        print("(", end="")
        n //= 2
        QuadTree(x, y, n)
        QuadTree(x, y + n, n)
        QuadTree(x + n, y, n)
        QuadTree(x + n, y + n, n)
        print(")", end="")


N = int(input())
image = [list(input().rstrip()) for _ in range(N)]

QuadTree(0, 0, N)

[백준] 5052번: 전화번호 목록

딩딩크롱 — Mon, 29 May 2023 23:57:12 +0900

문제

https://www.acmicpc.net/problem/5052

5052번: 전화번호 목록

첫째 줄에 테스트 케이스의 개수 t가 주어진다. (1 ≤ t ≤ 50) 각 테스트 케이스의 첫째 줄에는 전화번호의 수 n이 주어진다. (1 ≤ n ≤ 10000) 다음 n개의 줄에는 목록에 포함되어 있는 전화번호가

www.acmicpc.net

풀이

전화번호 목록을 정렬합니다.

그러면 전화번호 목록의 앞뒤의 시작이 같은지만 확인하면 됩니다.

코드

import sys

input = sys.stdin.readline


def solution():
    for i in range(n-1):
        if phone_num[i+1].startswith(phone_num[i]):
            return "NO"
    return "YES"


t = int(input())
for _ in range(t):
    n = int(input())
    phone_num = sorted([input().rstrip() for _ in range(n)])
    print(solution())

[백준] 1967번: 트리의 지름

딩딩크롱 — Mon, 15 May 2023 23:30:32 +0900

문제

https://www.acmicpc.net/problem/1967

1967번: 트리의 지름

파일의 첫 번째 줄은 노드의 개수 n(1 ≤ n ≤ 10,000)이다. 둘째 줄부터 n-1개의 줄에 각 간선에 대한 정보가 들어온다. 간선에 대한 정보는 세 개의 정수로 이루어져 있다. 첫 번째 정수는 간선이 연

www.acmicpc.net

풀이

DFS(깊이 우선 탐색)를 사용해 풀었습니다.

양방향 간선이므로 graph의 부모, 자식 노드에 해당하는 공간에 서로를 가중치와 함께 추가합니다.
트리의 지름을 구하는 방법은 다음과 같습니다.

루트 노드로부터 거리가 가장 먼 노드를 구합니다.
구한 노드로부터 거리가 가장 먼 노드까지의 거리를 구합니다.

코드

import sys

sys.setrecursionlimit(10**6)

input = sys.stdin.readline

n = int(input())
graph = [[] for _ in range(n + 1)]

for _ in range(n - 1):
    n1, n2, w = map(int, input().split())
    graph[n1].append((n2, w))
    graph[n2].append((n1, w))


def DFS(x, w):
    for nx, nw in graph[x]:
        if distance[nx] == -1:
            distance[nx] = w + nw
            DFS(nx, distance[nx])


distance = [-1] * (n + 1)
distance[1] = 0
DFS(1, 0)

start = distance.index(max(distance))
distance = [-1] * (n + 1)
distance[start] = 0
DFS(start, 0)

print(max(distance))

[백준] 16236번: 아기 상어

딩딩크롱 — Sat, 13 May 2023 18:21:21 +0900

문제

https://www.acmicpc.net/problem/16236

16236번: 아기 상어

N×N 크기의 공간에 물고기 M마리와 아기 상어 1마리가 있다. 공간은 1×1 크기의 정사각형 칸으로 나누어져 있다. 한 칸에는 물고기가 최대 1마리 존재한다. 아기 상어와 물고기는 모두 크기를 가

www.acmicpc.net

풀이

BFS(너비 우선 탐색)를 사용해 풀었습니다.

아기 상어의 위치(baby_shark)를 찾아 해당 위치의 값을 0으로 바꾸고 위치를 저장합니다.
BFS 함수 내의 fish 리스트에는 같은 거리 상에 있는 먹을 물고기들을 저장합니다.
상하좌우를 확인하며 0 혹은 같은 크기의 물고기는 지나가고, 아기 상어보다 작은 물고기를 fish 리스트에 추가합니다.
만약 먹을 수 있는 물고기가 있다면 물고기를 맨 위쪽, 왼쪽 순으로 정렬해 그 중 첫 번째 물고기를 선택합니다.
총 시간(time)에 걸린 시간(t)을 추가합니다.
그러나, 공간에 더 이상 먹을 수 있는 물고기가 없다면 총 시간(time)을 출력하고 마칩니다.

코드

import sys
from collections import deque

input = sys.stdin.readline

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

N = int(input())
graph = [list(map(int, input().split())) for _ in range(N)]


def getStart():
    for i in range(N):
        for j in range(N):
            if graph[i][j] == 9:
                graph[i][j] = 0
                return (i, j)


def BFS(x, y):
    fish = []
    L = 0
    queue = deque()
    visited = [[False] * N for _ in range(N)]
    visited[x][y] = True
    queue.append((x, y))
    while queue:
        for _ in range(len(queue)):
            x, y = queue.popleft()
            for i in range(4):
                nx = x + dx[i]
                ny = y + dy[i]
                if 0 <= nx < N and 0 <= ny < N and not visited[nx][ny]:
                    if graph[nx][ny] == 0 or graph[nx][ny] == size:
                        visited[nx][ny] = True
                        queue.append((nx, ny))
                    elif graph[nx][ny] < size:
                        visited[nx][ny] = True
                        fish.append((nx, ny))
        L += 1
        if fish:
            fish.sort()
            graph[fish[0][0]][fish[0][1]] = 0
            return [fish[0], L]
    return [[], 0]


time = 0
baby_shark = getStart()
size = 2
eaten = 0

while True:
    baby_shark, t = BFS(baby_shark[0], baby_shark[1])
    if t == 0:
        print(time)
        break
    else:
        time += t
        eaten += 1
        if size == eaten:
            size += 1
            eaten = 0

[백준] 2206번: 벽 부수고 이동하기

딩딩크롱 — Thu, 11 May 2023 19:56:59 +0900

문제

https://www.acmicpc.net/problem/2206

2206번: 벽 부수고 이동하기

N×M의 행렬로 표현되는 맵이 있다. 맵에서 0은 이동할 수 있는 곳을 나타내고, 1은 이동할 수 없는 벽이 있는 곳을 나타낸다. 당신은 (1, 1)에서 (N, M)의 위치까지 이동하려 하는데, 이때 최단 경로

www.acmicpc.net

풀이

visited는 앞서 방문한 위치를 체크하여 재방문하지 않도록 하고, 경로 및 이동 거리를 저장합니다.

visited를 벽 부수기 전후로 나누어 체크합니다.

visited[x][y][0] : 벽 부수기 전 경로
visited[x][y][1] : 벽 부수기 후 경로

이동할 위치의 이동 거리를 현재 위치의 이동 거리에 1을 더해 구합니다.

코드

import sys
from collections import deque

input = sys.stdin.readline

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

N, M = map(int, input().split())
board = [list(map(int, list(input().rstrip()))) for _ in range(N)]


def BFS():
    queue = deque()
    visited = [[[0] * 2 for _ in range(M)] for _ in range(N)]
    visited[0][0][False] = 1
    queue.append((0, 0, False))
    while queue:
        x, y, c = queue.popleft()
        if (x, y) == (N - 1, M - 1):
            return visited[x][y][c]
        for i in range(4):
            nx = x + dx[i]
            ny = y + dy[i]
            if 0 <= nx < N and 0 <= ny < M:
                if board[nx][ny] == 0 and not visited[nx][ny][c]:
                    visited[nx][ny][c] = visited[x][y][c] + 1
                    queue.append((nx, ny, c))
                elif board[nx][ny] == 1 and not c:
                    visited[nx][ny][True] = visited[x][y][c] + 1
                    queue.append((nx, ny, True))
    return -1


print(BFS())

[백준] 1987번: 알파벳

딩딩크롱 — Thu, 11 May 2023 18:19:48 +0900

문제

https://www.acmicpc.net/problem/1987

1987번: 알파벳

세로 R칸, 가로 C칸으로 된 표 모양의 보드가 있다. 보드의 각 칸에는 대문자 알파벳이 하나씩 적혀 있고, 좌측 상단 칸 (1행 1열) 에는 말이 놓여 있다. 말은 상하좌우로 인접한 네 칸 중의 한 칸으

www.acmicpc.net

풀이

DFS(깊이 우선 탐색), 백트래킹을 사용해 풀었습니다.

check 배열을 사용해 같은 알파벳이 적힌 칸을 두 번 지날 수 없도록 합니다.

ord 함수를 사용해 알파벳을 0~25의 값을 가지도록 합니다.

https://ralp0217.tistory.com/entry/Python3-%EC%99%80-PyPy3-%EC%B0%A8%EC%9D%B4

Python3 와 PyPy3 차이

Python3 와 PyPy3 차이 평소에 알고리즘 문제를 풀면서 Python을 지원하는 언어를 선택할 때, Python3와 PyPy3가 대표적으로 있었다. 원래 알던 개념은 PyPy3가 Python3의 실행시 시간이 매우 오래 걸린다는

ralp0217.tistory.com

코드

import sys

input = sys.stdin.readline

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

R, C = map(int, input().split())
board = [list(input().rstrip()) for _ in range(R)]
check = [False] * 26
answer = 0


def DFS(x, y, L):
    global answer
    answer = max(answer, L)
    for i in range(4):
        nx = x + dx[i]
        ny = y + dy[i]
        if 0 <= nx < R and 0 <= ny < C:
            idx = ord(board[nx][ny]) - ord("A")
            if not check[idx]:
                check[idx] = True
                DFS(nx, ny, L + 1)
                check[idx] = False


check[ord(board[0][0]) - ord("A")] = True
DFS(0, 0, 1)
print(answer)

[백준] 7569번: 토마토

딩딩크롱 — Thu, 11 May 2023 17:08:36 +0900

문제

https://www.acmicpc.net/problem/7569

7569번: 토마토

첫 줄에는 상자의 크기를 나타내는 두 정수 M,N과 쌓아올려지는 상자의 수를 나타내는 H가 주어진다. M은 상자의 가로 칸의 수, N은 상자의 세로 칸의 수를 나타낸다. 단, 2 ≤ M ≤ 100, 2 ≤ N ≤ 100,

www.acmicpc.net

풀이

BFS(너비 우선 탐색)를 사용해 풀었습니다.

6 방향(위, 아래, 상, 우, 하, 좌)을 미리 설정해 줍니다.
익은 토마토(1)의 위치를 모두 큐에 추가합니다.
익은 토마토를 주변으로 6 방향을 확인하며 익지 않은 토마토(0)를 익은 토마토(1)로 바꿔주고 바뀐 토마토 위치를 큐에 추가합니다.
시작 시점에 있던 큐를 모두 수행하면 하루가 지난 것이므로 L에 1을 더합니다.
마지막으로 익지 않은 토마토가 존재한다면 -1을, 모두 익었다면 L을 출력합니다.

코드

import sys
from collections import deque

input = sys.stdin.readline

M, N, H = map(int, input().split())
boxes = [[list(map(int, input().split())) for _ in range(N)] for _ in range(H)]

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


def BFS():
    L = -1
    queue = deque()
    for i in range(H):
        for j in range(N):
            for k in range(M):
                if boxes[i][j][k] == 1:
                    queue.append((i, j, k))
    while queue:
        for _ in range(len(queue)):
            x, y, z = queue.popleft()
            for i in range(6):
                nx = x + dx[i]
                ny = y + dy[i]
                nz = z + dz[i]
                if (
                    0 <= nx < H
                    and 0 <= ny < N
                    and 0 <= nz < M
                    and boxes[nx][ny][nz] == 0
                ):
                    boxes[nx][ny][nz] = 1
                    queue.append((nx, ny, nz))
        L += 1
    for i in range(H):
        for j in range(N):
            for k in range(M):
                if boxes[i][j][k] == 0:
                    return -1
    return L


print(BFS())

[백준] 10026번: 적록색약

딩딩크롱 — Thu, 11 May 2023 01:42:57 +0900

문제

https://www.acmicpc.net/problem/10026

10026번: 적록색약

적록색약은 빨간색과 초록색의 차이를 거의 느끼지 못한다. 따라서, 적록색약인 사람이 보는 그림은 아닌 사람이 보는 그림과는 좀 다를 수 있다. 크기가 N×N인 그리드의 각 칸에 R(빨강), G(초록)

www.acmicpc.net

풀이

BFS(너비 우선 탐색)와 DFS(깊이 우선 탐색)를 사용해 풀었습니다.

코드

import sys
from collections import deque

input = sys.stdin.readline

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

N = int(input())
board = [list(input()) for _ in range(N)]
visited1 = [[False] * N for _ in range(N)]
visited2 = [[False] * N for _ in range(N)]


def BFS(x, y, color_weakness):
    queue = deque()
    queue.append((x, y, color_weakness))
    while queue:
        x, y, color_weakness = queue.popleft()
        for i in range(4):
            nx = x + dx[i]
            ny = y + dy[i]
            if 0 <= nx < N and 0 <= ny < N:
                if not color_weakness:
                    if not visited1[nx][ny] and board[x][y] == board[nx][ny]:
                        visited1[nx][ny] = True
                        queue.append((nx, ny, color_weakness))
                else:
                    if not visited2[nx][ny]:
                        if board[x][y] == "B":
                            if board[x][y] == board[nx][ny]:
                                visited2[nx][ny] = True
                                queue.append((nx, ny, color_weakness))
                        else:
                            if board[nx][ny] != "B":
                                visited2[nx][ny] = True
                                queue.append((nx, ny, color_weakness))


count1 = 0
count2 = 0
for i in range(N):
    for j in range(N):
        if not visited1[i][j]:
            visited1[i][j] = True
            BFS(i, j, False)
            count1 += 1
        if not visited2[i][j]:
            visited2[i][j] = True
            BFS(i, j, True)
            count2 += 1
print(count1, count2)

import sys

sys.setrecursionlimit(10**6)

input = sys.stdin.readline

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

N = int(input())
board = [list(input().rstrip()) for _ in range(N)]


def DFS(x, y):
    for i in range(4):
        nx = x + dx[i]
        ny = y + dy[i]
        if 0 <= nx < N and 0 <= ny < N:
            if not visited[nx][ny] and board[x][y] == board[nx][ny]:
                visited[nx][ny] = True
                DFS(nx, ny)


count = 0
visited = [[False] * N for _ in range(N)]
for i in range(N):
    for j in range(N):
        if not visited[i][j]:
            visited[i][j] = True
            DFS(i, j)
            count += 1
print(count, end=" ")

for i in range(N):
    for j in range(N):
        if board[i][j] == "G":
            board[i][j] = "R"

count = 0
visited = [[False] * N for _ in range(N)]
for i in range(N):
    for j in range(N):
        if not visited[i][j]:
            visited[i][j] = True
            DFS(i, j)
            count += 1
print(count)