BackEnd Dev DreamTree It's

[백준] 15657 N과 M (8) with Python

형준_It's — Tue, 18 Apr 2023 17:44:55 +0900

BOJ 15657 N과 M (8)

조건

N개의 자연수와 자연수 M이 주어졌을 때, 아래 조건을 만족하는 길이가 M인 수열을 모두 구하는 프로그램을 작성하는 문제.
N개의 자연수는 모두 다른 수이다.
N개의 자연수 중에서 M개를 고른 수열
같은 수를 여러 번 골라도 된다.
고른 수열은 비내림차순이어야 한다.
길이가 K인 수열 A가 A1 ≤ A2 ≤ ... ≤ AK-1 ≤ AK를 만족하면, 비내림차순이라고 한다.
첫째 줄에 자연수 N과 M이 주어진다. (1 ≤ M ≤ N ≤ 8)
둘째 줄에 N개의 수가 주어진다. 입력으로 주어지는 수는 10,000보다 작거나 같은 자연수이다.
한 줄에 하나씩 문제의 조건을 만족하는 수열을 출력한다. 중복되는 수열을 여러 번 출력하면 안되며,
수열은 공백으로 구분해서 출력해야 한다. 수열은 사전 순으로 증가하는 순서로 출력해야 한다.
백트래킹 유형의 문제

예제 및 실행결과

예제 1

3 1
4 5 2

실행결과 1

2
4
5

예제 2

4 2
9 8 7 1

실행결과 2

예제 3

4 4
1231 1232 1233 1234

실행결과 3

1231 1231 1231 1231
1231 1231 1231 1232
1231 1231 1231 1233
1231 1231 1231 1234
1231 1231 1232 1232
1231 1231 1232 1233
1231 1231 1232 1234
1231 1231 1233 1233
1231 1231 1233 1234
1231 1231 1234 1234
1231 1232 1232 1232
1231 1232 1232 1233
1231 1232 1232 1234
1231 1232 1233 1233
1231 1232 1233 1234
1231 1232 1234 1234
1231 1233 1233 1233
1231 1233 1233 1234
1231 1233 1234 1234
1231 1234 1234 1234
1232 1232 1232 1232
1232 1232 1232 1233
1232 1232 1232 1234
1232 1232 1233 1233
1232 1232 1233 1234
1232 1232 1234 1234
1232 1233 1233 1233
1232 1233 1233 1234
1232 1233 1234 1234
1232 1234 1234 1234
1233 1233 1233 1233
1233 1233 1233 1234
1233 1233 1234 1234
1233 1234 1234 1234
1234 1234 1234 1234

⌨️ 문제 풀이

수열은 오름차순으로 구성되어야한다. 같은 숫자를 여러 번 골라도 된다.
비내림차순(오름차순)으로 구성하기 위해서는 수열(res) 의 맨 마지막과 현재 넣을 수를 비교하는 로직이 필요하다.
만약 수열(res)가 비어있으면 에러가 나기때문에, 수열이 비어있을 때도 고려해야한다.
만약 res가 출력된 적이 없다면, res를 출력하고, 출력된 res와 res의 역순 배열을 visited 에 넣는다.

소스 코드

from sys import stdin

n, m = map(int, stdin.readline().split())
arr = list(map(int, stdin.readline().split()))
arr.sort()
visited = []


def f(res, cnt):
    if cnt == m:
        if res not in visited:
            print(*res)
            visited.append(res)
            visited.append(res[::-1])
            return

    for i in arr:
        if cnt == 0:
            f(res + [i], cnt + 1)
        else:
            if res[-1] <= i:
                f(res + [i], cnt + 1)


f([], 0)

[백준] 15656 N과 M (7) with Python

형준_It's — Tue, 18 Apr 2023 17:32:59 +0900

BOJ 15656 N과 M (7)

조건

N개의 자연수와 자연수 M이 주어졌을 때, 아래 조건을 만족하는 길이가 M인 수열을 모두 구하는 프로그램을 작성하는 문제.
N개의 자연수는 모두 다른 수이다.
N개의 자연수 중에서 M개를 고른 수열
같은 수를 여러 번 골라도 된다.
첫째 줄에 N과 M이 주어진다. (1 ≤ M ≤ N ≤ 7)
둘째 줄에 N개의 수가 주어진다. 입력으로 주어지는 수는 10,000보다 작거나 같은 자연수이다.
한 줄에 하나씩 문제의 조건을 만족하는 수열을 출력한다. 중복되는 수열을 여러 번 출력하면 안되며,
수열은 공백으로 구분해서 출력해야 한다. 수열은 사전 순으로 증가하는 순서로 출력해야 한다.
백트래킹 유형의 문제

예제 및 실행결과

예제 1

3 1
4 5 2

실행결과 1

2
4
5

예제 2

4 2
9 8 7 1

실행결과 2

예제 3

3 3
1231 1232 1233

실행결과 3

1231 1231 1231
1231 1231 1232
1231 1231 1233
1231 1232 1231
1231 1232 1232
1231 1232 1233
1231 1233 1231
1231 1233 1232
1231 1233 1233
1232 1231 1231
1232 1231 1232
1232 1231 1233
1232 1232 1231
1232 1232 1232
1232 1232 1233
1232 1233 1231
1232 1233 1232
1232 1233 1233
1233 1231 1231
1233 1231 1232
1233 1231 1233
1233 1232 1231
1233 1232 1232
1233 1232 1233
1233 1233 1231
1233 1233 1232
1233 1233 1233

⌨️ 문제 풀이

순회하는 arr의 원소를 res 배열에 넣으면서 cnt가 m과 같아 질 때, res의 원소를 출력한다.
setrecursionlimit을 반드시 해주어야 한다.

소스 코드

from sys import stdin, setrecursionlimit

setrecursionlimit(10 ** 7)

n, m = map(int, stdin.readline().split())
arr = list(map(int, stdin.readline().split()))
arr.sort()


def f(res, cnt):
    if cnt == m:
        print(*res)
        return

    for i in arr:
        f(res + [i], cnt + 1)


f([], 0)

[백준] 15655 N과 M (6) with Python

형준_It's — Tue, 18 Apr 2023 16:33:01 +0900

BOJ 15655 N과 M (6)

조건

N개의 자연수와 자연수 M이 주어졌을 때, 아래 조건을 만족하는 길이가 M인 수열을 모두 구하는 프로그램을 작성하는 문제.
N개의 자연수는 모두 다른 수이다.
N개의 자연수 중에서 M개를 고른 수열
수열은 오름차순이어야 한다.
첫째 줄에 자연수 N과 M이 주어진다. (1 ≤ M ≤ N ≤ 8)
둘째 줄에 N개의 수가 주어진다. 입력으로 주어지는 수는 10,000보다 작거나 같은 자연수이다.
한 줄에 하나씩 문제의 조건을 만족하는 수열을 출력한다. 중복되는 수열을 여러 번 출력하면 안되며,
수열은 공백으로 구분해서 출력해야 한다. 수열은 사전 순으로 증가하는 순서로 출력해야 한다.
백트래킹 유형의 문제

예제 및 실행결과

예제 1

3 1
4 5 2

실행결과 1

2
4
5

예제 2

4 2
9 8 7 1

실행결과 2

예제 3

4 4
1231 1232 1233 1234

실행결과 3

1231 1232 1233 1234

⌨️ 문제 풀이

입력받은 배열을 sort 함수를 통해 정렬한다.
함수 f에서는 m과 cnt가 같을 때 결과값을 담고 있는 res 배열의 원소를 출력해준다.
함수 f에서는 res 배열의 길이가 0보다 클 때 res 배열의 맨 마지막의 원소와 현재 넣으려고 하는 숫자를 비교해 넣는다.
오름차순

소스 코드

from sys import stdin, setrecursionlimit

setrecursionlimit(10 ** 7)

n, m = map(int, stdin.readline().split())
arr = list(map(int, stdin.readline().split()))
arr.sort()


def f(res, cnt):
    if cnt == m:
        print(*res)
        return

    for i in range(cnt, n):
        if len(res) > 0:
            if res[-1] < arr[i]:
                f(res + [arr[i]], cnt + 1)
        else:
            f(res + [arr[i]], cnt + 1)


f([], 0)

[백준] 15654 N과 M (5) with Python

형준_It's — Tue, 18 Apr 2023 16:26:54 +0900

BOJ 15654 N과 M (5)

조건

N개의 자연수와 자연수 M이 주어졌을 때, 아래 조건을 만족하는 길이가 M인 수열을 모두 구하는 프로그램을 작성하는 문제.
N개의 자연수는 모두 다른 수이다.
N개의 자연수 중에서 M개를 고른 수열
첫째 줄에 자연수 N과 M이 주어진다. (1 ≤ M ≤ N ≤ 8)
둘째 줄에 N개의 수가 주어진다. 입력으로 주어지는 수는 10,000보다 작거나 같은 자연수이다.
한 줄에 하나씩 문제의 조건을 만족하는 수열을 출력한다.
중복되는 수열을 여러 번 출력하면 안되며, 각 수열은 공백으로 구분해서 출력해야 한다.
수열은 사전 순으로 증가하는 순서로 출력해야 한다.
백트래킹 유형의 문제

예제 및 실행결과

예제 1

3 1
4 5 2

실행결과 1

2
4
5

예제 2

4 2
9 8 7 1

실행결과 2

예제 3

4 4
1231 1232 1233 1234

실행결과 3

1231 1232 1233 1234
1231 1232 1234 1233
1231 1233 1232 1234
1231 1233 1234 1232
1231 1234 1232 1233
1231 1234 1233 1232
1232 1231 1233 1234
1232 1231 1234 1233
1232 1233 1231 1234
1232 1233 1234 1231
1232 1234 1231 1233
1232 1234 1233 1231
1233 1231 1232 1234
1233 1231 1234 1232
1233 1232 1231 1234
1233 1232 1234 1231
1233 1234 1231 1232
1233 1234 1232 1231
1234 1231 1232 1233
1234 1231 1233 1232
1234 1232 1231 1233
1234 1232 1233 1231
1234 1233 1231 1232
1234 1233 1232 1231

⌨️ 문제 풀이

숫자를 중복으로 고르면 안되기 때문에 "if i not in res" 구문을 통해서 중복숫자 선택을 피했다.

소스 코드

from sys import stdin, setrecursionlimit

setrecursionlimit(10 ** 7)
n, m = map(int, stdin.readline().split())
arr = list(map(int, stdin.readline().split()))
arr.sort()


def f(res, cnt):
    if cnt == m:
        print(*res)
        return

    for i in arr:
        if i not in res:
            f(res + [i], cnt + 1)


f([], 0)

[백준] 15652 N과 M (4) with Python

형준_It's — Tue, 18 Apr 2023 16:15:48 +0900

BOJ 15652 N과 M (4)

조건

자연수 N과 M이 주어졌을 때, 아래 조건을 만족하는 길이가 M인 수열을 모두 구하는 프로그램을 작성하시오.
1부터 N까지 자연수 중에서 M개를 고른 수열
같은 수를 여러 번 골라도 된다.
고른 수열은 비내림차순이어야 한다.
길이가 K인 수열 A가 A1 ≤ A2 ≤ ... ≤ AK-1 ≤ AK를 만족하면, 비내림차순이라고 한다.
첫째 줄에 자연수 N과 M이 주어진다. (1 ≤ M ≤ N ≤ 8)
한 줄에 하나씩 문제의 조건을 만족하는 수열을 출력한다.
중복되는 수열을 여러 번 출력하면 안되며, 각 수열은 공백으로 구분해서 출력해야 한다.
수열은 사전 순으로 증가하는 순서로 출력해야 한다.
백트래킹 유형의 문제

예제 및 실행결과

예제 1

3 1

실행결과 1

1
2
3

예제 2

4 2

실행결과 2

예제 3

3 3

실행결과 3

⌨️ 문제 풀이

N과 M (3)의 결과에서 수열이 오름차순인 것만 출력해주면 된다.
수열을 만들 때, res 배열의 마지막 원소가 현재 넣으려는 숫자보다 작거나 같을 때 넣어주는 코드를 넣는다.

소스 코드

from sys import stdin, setrecursionlimit

setrecursionlimit(10 ** 7)
n, m = map(int, stdin.readline().split())


def f(arr, cnt):
    if cnt == m:
        print(*arr)
        return

    for i in range(1, n + 1):
        if m > 1 and len(arr) > 0:
            if arr[-1] <= i:
                f(arr + [i], cnt + 1)
        else:
            f(arr + [i], cnt + 1)


f([], 0)

[백준] 15651 N과 M (3) with Python

형준_It's — Tue, 18 Apr 2023 15:52:36 +0900

BOJ 15651 N과 M (3)

조건

자연수 N과 M이 주어졌을 때, 아래 조건을 만족하는 길이가 M인 수열을 모두 구하는 프로그램을 작성하시오.
1부터 N까지 자연수 중에서 M개를 고른 수열
같은 수를 여러 번 골라도 된다.
첫째 줄에 자연수 N과 M이 주어진다. (1 ≤ M ≤ N ≤ 7)
한 줄에 하나씩 문제의 조건을 만족하는 수열을 출력한다.
한 줄에 하나씩 문제의 조건을 만족하는 수열을 출력한다.
중복되는 수열을 여러 번 출력하면 안되며, 각 수열은 공백으로 구분해서 출력해야 한다.
수열은 사전 순으로 증가하는 순서로 출력해야 한다.
백트래킹 유형의 문제

예제 및 실행결과

예제 1

3 1

실행결과 1

1
2
3

예제 2

4 2

실행결과 2

예제 3

3 3

실행결과 3

⌨️ 문제 풀이

재귀함수를 통해서 백트래킹을 한다.
함수 f에서는 파라미터를 아래와 같이 받는다.
- arr : 백트래킹을 수행하면서 f 함수를 재귀하며 자연수를 담을 배열
- cnt : arr에 담긴 수의 개수
cnt 와 m 이 같아지면 결과값을 담은 배열을 출력한다. 그리고 함수를 탈출.
(3)번의 조건이 맞지 않으면 1부터 n 까지 순환하면서 재귀 및 백트래킹을 진행한다.

소스 코드

from sys import stdin, setrecursionlimit

setrecursionlimit(10 ** 7)
n, m = map(int, stdin.readline().split())


def f(arr, cnt):
    if cnt == m:
        print(*arr)
        return

    for i in range(1, n + 1):
        f(arr + [i], cnt + 1)

f([], 0)

[백준] 15650 N과 M (2) with Python

형준_It's — Tue, 18 Apr 2023 15:41:01 +0900

BOJ 15650 N과 M (2)

조건

자연수 N과 M이 주어졌을 때, 아래 조건을 만족하는 길이가 M인 수열을 모두 구하는 프로그램을 작성하는 문제
1부터 N까지 자연수 중에서 중복 없이 M개를 고른 수열
고른 수열은 오름차순이어야 한다.
첫째 줄에 자연수 N과 M이 주어진다. (1 ≤ M ≤ N ≤ 8)
한 줄에 하나씩 문제의 조건을 만족하는 수열을 출력한다.
중복되는 수열을 여러 번 출력하면 안되며, 각 수열은 공백으로 구분해서 출력해야 한다.
수열은 사전 순으로 증가하는 순서로 출력해야 한다.
백트래킹 유형의 문제

예제 및 실행결과

예제 1

3 1

실행결과 1

1
2
3

예제 2

4 2

실행결과 2

예제 3

4 4

실행결과 3

1 2 3 4

⌨️ 문제 풀이

Itertools 라이브러리의 combinations 함수를 사용한다.

소스 코드

from sys import stdin
from itertools import combinations
n, m = map(int, stdin.readline().split())
ans = []
for comb in combinations(range(1, n + 1), m):
    ans.append(comb)
ans.sort()
for i in ans:
    print(*i)

[백준] 15649 N과 M (1) with Python

형준_It's — Tue, 18 Apr 2023 15:36:25 +0900

BOJ 15649 N과 M (1)

조건

자연수 N과 M이 주어졌을 때, 아래 조건을 만족하는 길이가 M인 수열을 모두 구하는 프로그램을 작성하는 문제
1부터 N까지 자연수 중에서 중복 없이 M개를 고른 수열
첫째 줄에 자연수 N과 M이 주어진다. (1 ≤ M ≤ N ≤ 8)
한 줄에 하나씩 문제의 조건을 만족하는 수열을 출력한다.
중복되는 수열을 여러 번 출력하면 안되며, 각 수열은 공백으로 구분해서 출력해야 한다.
수열은 사전 순으로 증가하는 순서로 출력해야 한다.
백트래킹 유형의 문제

예제 및 실행결과

예제 1

3 1

실행결과 1

1
2
3

예제 2

4 2

실행결과 2

예제 3

4 4

실행결과 3

⌨️ 문제 풀이

1부터 N 까지 자연수 중에서 중복없이 M 개를 고르는 법은 itertools 라이브러리 내의 permutations 함수를 사용하면 된다.

소스 코드

from sys import stdin
from itertools import permutations

n, m = map(int, stdin.readline().split())
for per in list(permutations([i for i in range(1, n + 1)], m)):
    print(*per)

[백준] 2702 초6 수학 with Python

형준_It's — Fri, 14 Apr 2023 14:26:51 +0900

BOJ 2702 초6 수학

조건

두 정수 a와 b 최소공배수는 두 수의 공통된 배수 중 가장 작은 수이고, 최대공약수는 두 수의 공통된 약수중 가장 큰 수이다.
a와 b가 주어졌을 때, 최소공배수와 최대공약수를 구하는 프로그램을 작성하는 문제.
첫째 줄에 테스트 케이스의 개수 T(1<=T<=1,000)가 주어진다.
각 테스트 케이스는 두 정수 a와 b로 이루어져 있고, 공백으로 구분되어 있다. (1 <= a,b <= 1,000)
수학, 브루트포스 유형의 문제

예제 및 실행결과

예제 1

실행결과 1

10 5
161 1
168 14

⌨️ 문제 풀이

math 라이브러리에 있는 lcm < 최소공배수 >, gcd <최대공약수> 함수를 사용했다.

소스 코드

from sys import stdin
from math import gcd, lcm

for _ in range(int(stdin.readline())):
    a, b = map(int, stdin.readline().split())
    print(lcm(a, b), gcd(a, b))

[백준] 4796 캠핑 with Python

형준_It's — Fri, 14 Apr 2023 14:23:02 +0900

BOJ 4796 캠핑

조건

등산가 김강산은 가족들과 함께 캠핑을 떠났다. 하지만, 캠핑장에는 다음과 같은 경고문이 쓰여 있었다.
캠핑장은 연속하는 20일 중 10일동안만 사용할 수 있습니다.
캠핑장을 연속하는 P일 중, L일동안만 사용할 수 있다.
강산이는 이제 막 V일짜리 휴가를 시작했다. 강산이가 캠핑장을 최대 며칠동안 사용할 수 있을까? (1 < L < P < V)
입력은 여러 개의 테스트 케이스로 이루어져 있다.
각 테스트 케이스는 한 줄로 이루어져 있고, L, P, V를 순서대로 포함하고 있다.
모든 입력 정수는 int범위이다. 마지막 줄에는 0이 3개 주어진다.
그리디 유형의 문제

예제 및 실행결과

예제 1

5 8 20
5 8 17
0 0 0

실행결과 1

Case 1: 14
Case 2: 11

⌨️ 문제 풀이

캠핑장을 이용할 수 있는 날을 꽉 채워서 사용하게 된다면 V // P 가 된다.
(1)번에서 만약 나머지가 있다면, 나머지 일 수를 다 더해주는 것이 아니라, 사용할 수 있는 날짜만큼 더해줘야한다.
예를 들어, 남은 일수가 5일이고 사용할 수 있는 날이 2일이면 2일만큼 더해주어야 한다는 것.
(1) ~ (3) 번을 종합해 식을 세워보면, (V // P) * L + min((V % P), L)) 이 된다.

소스 코드

from sys import stdin
c = 0
while 1:
    c += 1
    l, p, v = map(int, stdin.readline().split())
    if l == p == v == 0:
        break
    print('Case {}:'.format(c), (v // p) * l + min((v % p), l))

[백준] 17389 보너스 점수 with Python

형준_It's — Fri, 14 Apr 2023 11:47:17 +0900

BOJ 17389 보너스 점수

조건

OX표에 N개의 문제들이 있을 때, 1번 문제, 2번 문제, ..., N번 문제 순으로 채점된다.
문제는 뒤로 갈수록 어려워지기 때문에, i 번 문제의 기본 점수는 i 점이다.
문제를 맞히면 그 문제의 기본 점수(즉 i 번 문제의 경우 i 점)를 획득하며, 틀리면 얻지 못한다.
기본 점수와 별개로, '보너스 점수'라는 값이 존재한다. 이는 처음에는 0점이다.
문제를 맞히면 그 때의 '보너스 점수'를 획득하고, '보너스 점수'의 값이 1점 증가한다.
문제를 틀리면 '보너스 점수'를 얻지 못하고, '보너스 점수'의 값이 0점으로 초기화된다.
첫 번째 줄에 OX표의 길이인 자연수 N이 주어진다. (1 ≤ N ≤ 10,000)
두 번째 줄에 OX표를 의미하는 문자열 S가 주어진다.
S는 O(알파벳 대문자 O, ASCII 코드 79)와 X(알파벳 대문자 X, ASCII 코드 88)로만 구성되어 있으며, 길이는 N이다.
문자열 S의 i 번째 글자가 O이면 해당 참가자가 i 번째 문제를 맞혔음을 의미하고, X이면 틀렸음을 의미한다.
구현 유형의 문제

예제 및 실행결과

예제 1

8
XOOOXOOX

실행결과 1

⌨️ 문제 풀이

문제의 조건을 잘 살펴본 뒤, 예제를 살펴보자.
문제를 맞히면 그 문제의 기본 점수(즉 i 번 문제의 경우 i 점)를 획득하며, 틀리면 얻지 못한다.
기본 점수와 별개로, '보너스 점수'라는 값이 존재한다. 이는 처음에는 0점이다.

문제를 맞히면 그 때의 '보너스 점수'를 획득하고, '보너스 점수'의 값이 1점 증가한다.
문제를 틀리면 '보너스 점수'를 얻지 못하고, '보너스 점수'의 값이 0점으로 초기화된다.
예제에 대한 설명을 보며 구현을 하면 된다.

소스 코드

from sys import stdin

n = int(stdin.readline())
s = stdin.readline().rstrip()
ans = 0
cnt, flag = 0, 0

for i in range(len(s)):
    if s[i] == 'X':
        cnt = 0
    else:
        if flag:
            cnt += 1
            ans += (i + 1) + cnt
            continue

        ans += (i + 1) + cnt
        cnt += 1
print(ans)

[백준] 11383 뚊 with Python

형준_It's — Thu, 13 Apr 2023 15:08:51 +0900

BOJ 11383 뚊

조건

정우는 "뚊"과 "돌돔"을 의미하는 두 이미지를 받았다. 과연 두 그림이 같은지 검사해보자.
즉 N× M 크기의 이미지와 N ×2 M 크기의 이미지가 주어질 때
첫 번째 이미지를 가로로 두 배로 늘이면 두 번째 이미지가 되는지 검사하는 프로그램을 작성하는 문제.
입력의 첫 번째 줄에 N, M (1 ≤ N, M ≤ 10)이 주어진다.
다음 N개의 줄의 각 줄에는 M개의 문자가 주어진다.
다음 N개의 줄의 각 줄에는 2M개의 문자가 주어진다. 모든 문자는 영문 알파벳 대문자 혹은 소문자이다.
첫 번째로 주어진 이미지를 가로로 두 배로 늘렸을 때 두 번째 이미지가 된다면 "Eyfa"을 출력, 되지 않는다면 "Not Eyfa"을 출력
문자열, 구현 유형의 문제

예제 및 실행결과

예제 1

1 5
ABCDE
AABBCCDDEE

실행결과 1

Eyfa

예제 2

ABCDE
AABBCCDDEF

실행결과 2

Not Eyfa

예제 3

2 2
AB
CD
AABB
CCDD

실행결과 3

Eyfa

⌨️ 문제 풀이

입력을 받은 문자열을 관리할 리스트를 생성해, n개 만큼 입력을 받는다.
입력을 받은 문자열을 관리할 리스트에 넣기 전, 순회를 하면서 각 문자를 2개씩 이어붙인다.
(1)~(2) 번에서 제작한 문자열과 이후에 입력 받은 비교할 문자열을 비교해, 하나라도 틀렸을 시, Not Eyfa 를 출력한다.
함수를 하나 만들어 결과를 return 해주면 코드가 더 쉽다.

소스 코드

from sys import stdin

inp = stdin.readline
n, m = map(int, inp().split())
be, af = [], []

for i in range(n):
    res = ''
    s = stdin.readline().rstrip()
    for i in s:
        res += i * 2

    be.append(res)

for i in range(n):
    af.append(stdin.readline().rstrip())


def get_res():
    for i in range(n):
        if be[i] != af[i]:
            return 0

    return 1


print('Eyfa' if get_res() else 'Not Eyfa')

[백준] 4740 거울, 오! 거울 문자열 with Python

형준_It's — Thu, 13 Apr 2023 13:25:20 +0900

BOJ 12871 거울, 오! 거울 문자열

조건

문장을 입력하면 입력한 문장의 개별 단어들을 역순으로 배치하여
거꾸로 바뀐 문장을 출력하는 프로그램을 만들어 '거울 읽기' 연습을 하려고 마음먹었다.
하나 또는 그 이상의 줄에 각각 ASCII 글자로 나타낼 수 있는 단어들(알파벳, 숫자, 공백, 구두점 등)로 구성된 문장을 입력한다.
각 문장은 최소 1글자에서 최대 80글자로 이루어져 있으며, ***을 입력하면 프로그램이 종료된다.
한 문장의 입력이 끝난 뒤 바로 입력한 문장의 글자들이 역순으로 바뀌어 배치된 문장을 출력한다.
문자열, 구현 유형의 문제

예제 및 실행결과

예제 1

AMBULANCE
Evian
madam, i'm adam
***

실행결과 1

ECNALUBMA
naivE
mada m'i ,madam

⌨️ 문제 풀이

rstrip() 으로 문자열을 받으면 공백까지 지워지는 현상이 있다. 그러니, rstrip('\n')으로 받자.
reverse() 함수를 쓸 필요가 없다.
[::-1] 로 역순 출력이 가능하다.

소스 코드

from sys import stdin

while 1:
    s = stdin.readline().rstrip('\n')
    if s == '***':
        break
    print(s[::-1])

[백준] 12871 무한 문자열 with Python

형준_It's — Thu, 13 Apr 2023 11:42:16 +0900

BOJ 12871 무한 문자열

조건

문자열 s가 있을 때, f(s)는 s를 무한번 붙인 문자열로 정의한다.
예를 들어, s = "abc" 인 경우에 f(s) = "abcabcabcabc..."가 된다.
다른 문자열 s와 t가 있을 때, f(s)와 f(t)가 같은 문자열인 경우가 있다.
예를 들어서, s = "abc", t = "abcabc"인 경우에 f(s)와 f(t)는 같은 문자열을 만든다.
s와 t가 주어졌을 때, f(s)와 f(t)가 같은 문자열을 만드는지 아닌지 구하는 문제.
첫째 줄에 s, 둘째 줄에 t가 주어진다.
두 문자열 s와 t의 길이는 50보다 작거나 같은 자연수이고, 알파벳 소문자로만 이루어져 있다.
첫째 줄에 f(s)와 f(t)가 같으면 1을, 다르면 0을 출력한다.
문자열, 구현 유형의 문제

예제 및 실행결과

예제 1

ab
abab

실행결과 1

예제 2

abc
bca

실행결과 2

⌨️ 문제 풀이

각 문자의 길이를 구하고, 그 길이들의 최소 공배수를 구했다.
최소공배수만큼 문자열의 길이를 늘리고 비교했다.

소스 코드

from sys import stdin
from math import lcm

a = stdin.readline().rstrip()
b = stdin.readline().rstrip()
al, bl = len(a), len(b)
length = lcm(al, bl)
print(1 if a * (length // al) == b * (length // bl) else 0)

[백준] 5363 요다 with Python

형준_It's — Thu, 13 Apr 2023 11:30:10 +0900

BOJ 5363 요다

조건

어린 제다이들은 요다와 대화하는 법을 배워야 한다. 요다는 모든 문장에서 가장 앞 단어 두 개를 제일 마지막에 말한다.
어떤 문장이 주어졌을 때, 요다의 말로 바꿔 출력하는 문제.
첫째 줄에 문장의 수 N이 주어진다. 둘째 줄부터 N개의 줄에는 각 문장이 주어진다.
문장의 길이는 100글자 이내이다. 단어의 개수는 3개 이상이다.
문자열, 구현 문제

예제 및 실행결과

예제 1

4
I will go now to find the Wookiee
Solo found the death star near planet Kessel
I'll fight Darth Maul here and now
Vader will find Luke before he can escape

실행결과 1

go now to find the Wookiee I will
the death star near planet Kessel Solo found
Darth Maul here and now I'll fight
find Luke before he can escape Vader will

⌨️ 문제 풀이

[:2]에 해당하는 문자를 [2:] 에 해당하는 문자열 뒤에 붙여주면 된다.

소스 코드

from sys import stdin

for _ in range(int(stdin.readline())):
    a = list(stdin.readline().rstrip().split())
    print(*(a[2:] + a[:2]))

[백준] 1124 언더프라임 with Python

형준_It's — Tue, 11 Apr 2023 15:20:44 +0900

BOJ 1124 언더프라임

조건

자연수 X를 소인수분해하면, 곱해서 X가 되는 소수의 목록을 얻을 수 있다.
예를 들어, 12 = 2 × 2 × 3이다. 1은 소수가 아니다.
어떤 수 X를 소인수분해 해서 구한 소수의 목록의 길이가 소수이면, 그 수를 언더프라임 이라고 한다.
12는 목록에 포함된 소수의 개수가 3개이고, 3은 소수이니 12는 언더프라임이다.
두 정수 A와 B가 주어졌을 때, A보다 크거나 같고, B보다 작거나 같은 정수 중에서 언더프라임인 것의 개수를 구하는 문제
2 ≤ A ≤ B ≤ 100,000
에라토스테네스의 체, 수학, 소수판정 유형의 문제

예제 및 실행결과

예제 1

2 10

실행결과 1

예제 2

100 105

실행결과 2

예제 3

17 17

실행결과 3

예제 4

123 456

실행결과 4

⌨️ 문제 풀이

에라토스테네스의 체를 이용해 소수를 판단할 수 있는 is_prime 리스트와 판정된 소수를 담을 primes 리스트를 만든다.
0과 1은 소수가 아니기에, is_prime 리스트에서 반드시 0 값을 넣어줘야 한다.
A 부터 B 까지의 범위를 순회하면서, 만들어 놓은 primes 배열도 순회한다.
A 부터 B 까지의 범위의 숫자를 primes 배열의 숫자로 나누면서 1을 제외한 소수의 개수를 센다.
(3)에서 나온 숫자가 is_prime에서 소수로 판별이 된다면 res += 1
A 부터 B 까지 순회가 끝났다면, res 를 반환한 후 출력한다.

소스 코드

from sys import stdin

a, b = map(int, stdin.readline().split())
is_prime = [1 for i in range(100001)]
primes = []
is_prime[0:1] = 0, 0


def prime_checker():
    for i in range(2, 100000):
        if is_prime[i] == 1:
            primes.append(i)
            temp, length = i + i, len(is_prime)
            while length > temp:
                is_prime[temp] = 0
                temp += i


def check_under_prime(a, b):
    prime_checker()

    res = 0
    for i in range(a, b + 1):
        cnt, idx = 0, 0
        while 1:
            if i % primes[idx] == 0:
                cnt += 1
                i //= primes[idx]

                if i == 1:
                    break
            else:
                idx += 1
        if is_prime[cnt] == 1:
            res += 1

    return res


print(check_under_prime(a, b))

[백준] 7600 문자가 몇갤까 with Python

형준_It's — Tue, 11 Apr 2023 15:11:37 +0900

BOJ 7600 문자가 몇갤까

조건

각 케이스마다 문장에서 공백, 숫자, 특수 문자를 제외하고 얼마나 다양한 알파벳이 나왔는지를 구하는 문제.
대소문자는 하나의 문자로 처리한다. ex) 'A' == 'a'
입력은 250자를 넘지 않는 문장이 주어진다.
각 문장은 적어도 하나의 공백이 아닌 문자를 포함한다. (알파벳이 아닐 수 있다)
마지막 줄에는 '#'이 주어진다.
문자열, 구현 유형의 문제

예제 및 실행결과

예제 1

The quick brown fox jumped over the lazy dogs.
2 + 2 = 4
New Zealand Programming Contest.
#

실행결과 1

26
0
16

⌨️ 문제 풀이

입력받은 문장을 모두 소문자로 변환한 뒤 계산하면 편하다.
알파벳이 나왔는지 체크할 방문처리 배열을 만들고, 문자열을 순회하면서 체크한다.
체크를 1로 해두고 문자열 순회가 끝난 뒤 방문처리 배열을 sum() 한 결과값을 출력한다.

소스 코드

from sys import stdin

while 1:
    s = stdin.readline().rstrip().lower()
    a = [0 for _ in range(26)]
    if s == '#':
        break
    for i in s:
        n = ord(i)
        if 97 <= n <= 122:
            if a[n - 97] == 0:
                a[n - 97] = 1

    print(sum(a))

[백준] 24480 알고리즘 수업 - 깊이 우선 탐색 2 with Python

형준_It's — Mon, 10 Apr 2023 17:23:28 +0900

BOJ 24480 알고리즘 수업 - 깊이 우선 탐색 2

조건

N개의 정점과 M개의 간선으로 구성된 무방향 그래프(undirected graph)가 주어진다.
정점 번호는 1번부터 N번이고 모든 간선의 가중치는 1이다.
정점 R에서 시작하여 깊이 우선 탐색으로 노드를 방문할 경우 노드의 방문 순서를 출력하자.
깊이 우선 탐색 의사 코드는 다음과 같다. 인접 정점은 내림차순으로 방문한다.
첫째 줄에 정점의 수 N (5 ≤ N ≤ 100,000), 간선의 수 M (1 ≤ M ≤ 200,000), 시작 정점 R (1 ≤ R ≤ N)이 주어진다.
다음 M개 줄에 간선 정보 u v가 주어지며 정점 u와 정점 v의 가중치 1인 양방향 간선을 나타낸다.
(1 ≤ u < v ≤ N, u ≠ v) 모든 간선의 (u, v) 쌍의 값은 서로 다르다.
첫째 줄부터 N개의 줄에 정수를 한 개씩 출력한다. i번째 줄에는 정점 i의 방문 순서를 출력한다.
시작 정점의 방문 순서는 1이다. 시작 정점에서 방문할 수 없는 경우 0을 출력한다.
DFS, 정렬 유형의 문제

예제 및 실행결과

예제 1

실행결과 1

⌨️ 문제 풀이

문제의 지문을 먼저 잘 살펴보자.
무방향 그래프(undirected graph), 인접 정점은 내림차순으로 방문,
무방향 그래프는 양방향 그래프이기 때문에 간선 정보를 그래프에 저장할 때 a에서 b, b에서 a를 저장해줘야 한다.
인접 정점은 내림차순으로 방문한다고 했기 때문에, 방문이 가능한 다음 노드는 내림차순 정렬을 해주어야 한다.
(3), (4)번을 유의해야하며, 파이썬의 경우 setrecursionlimit을 하는게 안전하다.
방문을 하면서 방문한 순서를 visited(방문처리배열)에 적어 출력해주면 된다.

소스 코드

from sys import stdin, setrecursionlimit

setrecursionlimit(10 ** 7)

n, m, r = map(int, stdin.readline().split())
graph = [[] for _ in range(n + 1)]
visited = [0 for _ in range(n + 1)]
cnt = 1

for _ in range(m):
    a, b = map(int, stdin.readline().split())
    graph[a].append(b)
    graph[b].append(a)


def dfs(r):
    global cnt
    visited[r] = cnt
    graph[r].sort(reverse=True)
    for node in graph[r]:
        if visited[node] == 0:
            cnt += 1
            dfs(node)


dfs(r)
for i in visited[1:]:
    print(i)

[백준] 10707 수도요금 with Python

형준_It's — Mon, 10 Apr 2023 17:05:33 +0900

BOJ 10707 수도요금

조건

JOI군이 살고 있는 지역에는 X사와 Y사, 두 개의 수도회사가 있다.
두 회사의 수도요금은 한 달간 수도의 사용량에 따라 (2)번과 같이 정해진다.
X사 : 1리터당 A엔.
Y사 : 기본요금은 B엔이고, 사용량이 C리터 이하라면 요금은 기본요금만 청구된다.
용량이 C리터가 넘었을 경우 기본요금 B엔에 더해서 추가요금이 붙는다.
추가요금은 사용량이 C리터를 넘었을 경우 1리터를 넘었을 때마다 D엔이다.
JOI군의 집에서 한 달간 쓰는 수도의 양은 P리터이다.
수도요금이 최대한 싸게 되도록 수도회사를 고를 때, JOI군의 집의 1달간 수도요금을 구하여라.
입력되는 정수 A,B,C,D,P는 전부 1 이상 10000 이하이다.
수학, 사칙연산 유형의 문제

예제 및 실행결과

예제 1

실행결과 1

예제 2

실행결과 2

⌨️ 문제 풀이

JOI군이 사용한 수도의 양 P 가 상한 C 보다 높다면, min(a * p, (p - c) * d + b))
- a * p : X 사 요금
- (p - c) * d : 상한 이상으로 사용한 수도의 양 * 추가요금
JOI군이 사용한 수도의 양 P 가 상한 C 보다 낮다면, min(a * p, b)

소스 코드

from sys import stdin

a, b, c, d, p = [int(stdin.readline()) for _ in range(5)]
ans = min(a * p, (p - c) * d + b) if p > c else min(a * p, b)
print(ans)

[백준] 10025 게으른 백곰 with Python

형준_It's — Mon, 10 Apr 2023 14:07:47 +0900

BOJ 10025 게으른 백곰

조건

앨버트가 가장 적은 거리만 움직이고도 최대한 많은 얼음으로 더위를 식힐 수 있도록 도와주자.
우리 안은 1차원 배열로 생각하며, 총 N개의 얼음 양동이들이 xi좌표마다 놓여 있고 각 양동이 안에는 gi씩의 얼음이 들어 있다.
(1 ≤ N ≤ 100000)
(0 ≤ xi ≤ 1,000,000)
(1 ≤ gi ≤ 10,000)
앨버트가 자리를 잡으면 그로부터 좌우로 K(1 ≤ K ≤ 2,000,000) 만큼 떨어진 양동이까지 닿을 수 있다.
앨버트는 양동이가 놓여 있는 자리에도 자리잡을 수 있다.
모든 얼음 양동이의 위치는 다르다.
앨버트가 최적의 자리를 골랐을 때 얼음의 합을 구하는 문제. 즉, 얼음들의 합의 최댓값을 구해야 한다.
첫 줄에 정수 N과 K가 들어온다.
둘째 줄부터 N째 줄까지, 공백을 사이에 두고 각 양동이의 얼음의 양을 나타내는 gi와 양동이의 좌표를 나타내는 xi가 주어진다.
누적합, 슬라이딩 윈도우 유형의 문제

예제 및 실행결과

예제 1

실행결과 1

⌨️ 문제 풀이

이 문제는 두 가지 풀이를 할 수 있는데, 나는 슬라이딩 윈도우로 풀이했다.
누적합 풀이는 아래의 링크를 참고하면 좋을 것 같다.
10025 누적합 풀이
슬라이딩 윈도우로 문제를 풀이하기 위해서 얼음양동이들이 놓여질 배열을 만들어준다.
1,000,000 개의 배열을 만들어두고, N개의 얼음양동이를 X의 위치에 G를 저장한다.
(3)번을 진행하면서, 불필요한 연산을 줄이기 위해 양동이가 놓여진 맨 나중 좌표를 구한다.

현재 위치로부터 좌우로 K 만큼 닿을 수 있기 때문에 0 좌표를 기준으로 식 다음 위치를 계산하면 아래와 같다.
p = k * 2 + 1
얼음들의 최대값을 저장할 res 의 초기값은 0~p 까지의 값이고, (3)에서 구한 맨 나중 좌표까지 순회하면서 res의 값을
갱신해주면 된다.

소스 코드

from sys import stdin

n, k = map(int, stdin.readline().split())
length, ans = 0, 0
arr = [0 for _ in range(10000001)]

for _ in range(n):
    g, x = map(int, stdin.readline().split())
    length = max(length, x)
    arr[x] = g

p = k * 2 + 1
res = sum(arr[:p])
ans = res

for i in range(p, length + 1):
    # 여기 p 값 안넣고 수식 넣을 떄 괄호 안 넣어서 틀렸음
    res += (arr[i] - arr[i - p])
    ans = max(ans, res)

print(ans)

[백준] 15792 A/B - 2 with Python

형준_It's — Mon, 10 Apr 2023 13:03:41 +0900

BOJ 15792 A/B - 2

조건

두 정수 A와 B를 입력받은 다음, A/B 의 값을 출력하는 문제.
첫째 줄에 A와 B가 주어진다. (0 < A, B ≤ 10,000)
이 문제는 서브태스크가 있다.

구현, 수학 유형의 문제

예제 및 실행결과

예제 1

1 3

실행결과 1

0.33333333333333333333333333333333

예제 2

4 5

실행결과 2

0.8

⌨️ 문제 풀이

해당 문제의 서브태스크 10번을 보면, 절대/상대 오차 허용 범위가 10**-1000 이다.
이는 소수점 1000자리까지의 수의 오차범위를 허용해준다는 것이니, 이를 생각하고 구현을 하면된다.
실수에는 정수부와 소수부가 있다. 이를 따로 나누어 계산을 해주고 문자열로 붙여서 출력하면 편하다.

소스 코드

from sys import stdin
a, b = map(int, stdin.readline().split())
ans = '' + str(a // b) + '.'
a %= b
a *= 10

for _ in range(1000):
    temp = a // b
    ans += str(temp)
    a %= b
    a *= 10

print(ans)

[백준] 2455 지능형 기차 with Python

형준_It's — Mon, 10 Apr 2023 11:36:22 +0900

BOJ 2455 지능형 기차

조건

기차에는 타거나 내리는 사람 수를 자동으로 인식할 수 있는 장치가 있다.
이 장치를 이용하여 출발역에서 종착역까지 가는 도중 기차 안에 사람이 가장 많을 때의 사람 수를 계산하려고 한다.
기차를 이용하는 사람들은 질서 의식이 투철하여, 역에서 기차에 탈 때, 내릴 사람이 모두 내린 후에 기차에 탄다고 가정한다.

이 기차는 다음 조건을 만족하면서 운행된다고 가정한다.
- 기차는 역 번호 순서대로 운행한다.
- 출발역에서 내린 사람 수와 종착역에서 탄 사람 수는 0이다.
- 각 역에서 현재 기차에 있는 사람보다 더 많은 사람이 내리는 경우는 없다.
- 기차의 정원은 최대 10,000명이고, 정원을 초과하여 타는 경우는 없다.

4개의 역에 대해 기차에서 내린 사람 수와 탄 사람 수가 주어졌을 때, 기차에 사람이 가장 많을 때의 사람 수를 계산하는 문제

각 역에서 내린 사람 수와 탄 사람 수가 빈칸을 사이에 두고 첫째 줄부터 넷째 줄까지 역 순서대로 한 줄에 하나씩 주어진다.

구현, 수학 유형의 문제

예제 및 실행결과

예제 1

실행결과 1

⌨️ 문제 풀이

기차는 역 번호 순서대로 운행되고 있으니 따로 정렬을 해주지 않아도 된다.
각 역마다 몇 명의 인원이 기차를 타고 있는지 계산하는 식은 아래와 같다.
res += -1 * leave + on
leave 변수는 내린 사람의 수, on 은 탄 사람의 수이다.
res 계산이 끝날 때마다, ans 갑과 비교해 갱신해준다.

소스 코드

from sys import stdin

ans, res = 0, 0
for i in range(4):
    leave, on = map(int, stdin.readline().split())
    res += -1 * leave + on
    ans = max(res, ans)

print(ans)

[백준] 1072 게임 with Python

형준_It's — Fri, 7 Apr 2023 15:18:12 +0900

BOJ 1072 게임

조건

형택이는 잠시 코딩을 하는 사이에 자신의 게임 실력이 눈에 띄게 향상된 것을 알았다.

형택이는 앞으로의 모든 게임에서 지지 않는다.
형택이는 게임 기록을 삭제 할 수 없기 때문에, 자신의 예전 기록이 현재 자신의 엄청난 실력을 증명하지 못한다고 생각했다.

게임 기록은 다음과 같이 생겼다.
- 게임 횟수 : X
- 이긴 게임 : Y (Z%)
- Z는 형택이의 승률이고, 소수점은 버린다. 예를 들어, X=53, Y=47이라면, Z=88이다.

X와 Y가 주어졌을 때, 형택이가 게임을 최소 몇 번 더 해야 Z가 변하는지 구하는 문제
첫째 줄에 형택이가 게임을 최소 몇 판 더 해야하는지 출력한다. 만약 Z가 절대 변하지 않는다면 -1을 출력한다.

1 ≤ X ≤ 1,000,000,000
0 ≤ Y ≤ X

수학, 이분탐색 유형의 문제

예제 및 실행결과

예제 1

10 8

실행결과 1

예제 2

100 80

실행결과 2

예제 3

47 47

실행결과 3

-1

예제 4

99000 0

실행결과 4

예제 5

1000000000 470000000

실행결과 5

19230770

⌨️ 문제 풀이

게임을 몇 판을 하면 승률이 변할지 구하는 문제이다.
X의 범위를 보면 하나하나 계산해서 찾을 수 없고, 이분탐색을 통해서 결과를 도출해야 한다는 것을 알 수 있다.
또한 승률을 구하려면 당연히 소숫점 계산이 필요하다고 생각할 수 있지만, b 에 100을 곱하면 그렇게 하지 않아도 된다.
이분탐색을 처음 시작할 때, left 에 해당되는 변수는 0으로 시작하고 right 에 해당되는 변수는 X, Y 중 큰 것을 골라 넣는다.

소스 코드

from sys import stdin

a, b = map(int, stdin.readline().split())
z = b * 100 // a

ans = int(1e11)
start, end = 0, max(a, b)

while start <= end:
    mid = (start + end) // 2
    res = (b + mid)  * 100 // (a + mid)

    if res != z:
        ans = min(ans, mid)
        end = mid - 1
    else:
        start = mid + 1

print(ans if ans != int(1e11) else -1)

[백준] 9658 돌 게임 4 with Python

형준_It's — Fri, 7 Apr 2023 15:07:26 +0900

BOJ 9658 돌 게임 4

조건

탁자 위에 돌 N개가 있다. 상근이와 창영이는 턴을 번갈아가면서 돌을 가져가며, 돌은 1개, 3개 또는 4개 가져갈 수 있다.
마지막 돌을 가져가는 사람이 게임을 지게 된다.
두 사람이 완벽하게 게임을 했을 때, 이기는 사람을 구하는 문제.
게임은 상근이가 먼저 시작한다.
첫째 줄에 N이 주어진다. (1 ≤ N ≤ 1000)
상근이가 게임을 이기면 SK를, 창영이가 게임을 이기면 CY을 출력한다.
다이나믹 프로그래밍 유형의 문제

예제 및 실행결과

예제 1

실행결과 1

SK

⌨️ 문제 풀이

돌 게임 3 와의 상황을 반대로 계산하면 된다.

소스 코드

from sys import stdin

n = int(stdin.readline())

dp = [0, 0, 1, 0, 1, 1, 1, 1] + [0] * (n - 7)

for i in range(8, n + 1):
    if 0 in [dp[i - 1], dp[i - 3], dp[i - 4]]:
        dp[i] = 1
    else:
        dp[i] = 0

print("SK" if dp[n] == 1 else "CY")

[백준] 9657 돌 게임 3 with Python

형준_It's — Tue, 4 Apr 2023 17:46:34 +0900

BOJ 9657 돌 게임 3

조건

탁자 위에 돌 N개가 있다. 상근이와 창영이는 턴을 번갈아가면서 돌을 가져가며, 돌은 1개, 3개 또는 4개 가져갈 수 있다.
마지막 돌을 가져가는 사람이 게임을 이기게 된다.
두 사람이 완벽하게 게임을 했을 때, 이기는 사람을 구하는 문제.
게임은 상근이가 먼저 시작한다.
첫째 줄에 N이 주어진다. (1 ≤ N ≤ 1000)
상근이가 게임을 이기면 SK를, 창영이가 게임을 이기면 CY을 출력한다.
다이나믹 프로그래밍 유형의 문제

예제 및 실행결과

예제 1

실행결과 1

SK

⌨️ 문제 풀이

상근이를 기준으로 DP 배열을 구성할 것이다. 그렇다면, 어떻게하면 상근이가 이길 수 있을지에 대해서 생각해보면 좋다.
"완벽하게 게임을 한다" 라는 구절을 통해서 어떻게든 상근이가 이길 방법이 있다면,
DP 배열에서 그 개수는 상근이가 이기는 판으로 기록을 해두는것이 옳다.
문제에서 돌을 네개까지 가져 갈 수 있으니 dp[4]까지 직접 계산하며 살펴보자.
돌이 1개일 때, 상근이는 1개를 가져갈 수 있으며 이기게 된다. -> 1
돌이 2개일 때, 상근이는 1개를 가져갈 수 있으며 지게 된다. -> 0
돌이 3개일 때, 상근이는 1, 3개를 가져갈 수 있으며, 두 경우 모두 이길수 있다. -> 1
돌이 4개일 때, 상근이는 1, 3, 4개를 가져갈 수 있으며, 4개를 가져가면 이길 수 있다. -> 1
(2)번과 같이 계산했을 때, DP 리스트는 아래와 같이 구성된다.
0 ~ 4까지 계산한 결과 + 입력받은 n - 4개의 0으로 초기화한 리스트

dp = [0, 1, 0, 1, 1] + [0] * (n - 4)

dp[가져갈 돌의 개수]로 보면 1 혹은 0의 값이 있다.
1의 값일 때를 살펴보면 상근이가 먼저 시작을 했을 때 이길 수 있고, 그게 아니라면 진다.
반대로 0의 값일 때는 무조건 이길 수 있다.
(4)번에서 알아본 것을 토대로 보면, 돌 한개, 세개, 네개 가져갔을 때의 dp값에 0이 있다면 무조건 상근이가 이긴다는 것이다.
반복문을 통해서 n번 째 리스트까지 계산하여 값을 정한 뒤, dp[n] 을 출력하면 된다.

소스 코드

from sys import stdin

n = int(stdin.readline())
arr = [0, 1, 0, 1, 1] + [0] * (n - 4)

for i in range(5, n + 1):
    if 0 in [arr[i - 1], arr[i - 4], arr[i - 3]]:
        arr[i] = 1
    else:
        arr[i] = 0

print('SK' if arr[n] else 'CY')

[백준] 9656 돌 게임2 with Python

형준_It's — Tue, 4 Apr 2023 17:31:10 +0900

BOJ 9656 돌 게임2

조건

탁자 위에 돌 N개가 있다. 상근이와 창영이는 턴을 번갈아가면서 돌을 가져가며, 돌은 1개 또는 3개 가져갈 수 있다.
마지막 돌을 가져가는 사람이 게임을 지게 된다.
두 사람이 완벽하게 게임을 했을 때, 이기는 사람을 구하는 문제.
게임은 상근이가 먼저 시작한다.
첫째 줄에 N이 주어진다. (1 ≤ N ≤ 1000)
상근이가 게임을 이기면 SK를, 창영이가 게임을 이기면 CY을 출력한다.
다이나믹 프로그래밍 유형의 문제

예제 및 실행결과

예제 1

실행결과 1

SK

⌨️ 문제 풀이

BOJ 9655 돌 게임 의 문제 풀이와 매우 비슷하다.
9655 돌 게임 문제 풀이 를 참고하여 아이디어를 얻어보자.

소스 코드

from sys import stdin

print('SK' if int(stdin.readline()) % 2 == 0 else 'CY')

[백준] 9655 돌 게임 with Python

형준_It's — Tue, 4 Apr 2023 17:19:25 +0900

BOJ 9655 돌 게임

조건

탁자 위에 돌 N개가 있다. 상근이와 창영이는 턴을 번갈아가면서 돌을 가져가며, 돌은 1개 또는 3개 가져갈 수 있다.
마지막 돌을 가져가는 사람이 게임을 이기게 된다.
두 사람이 완벽하게 게임을 했을 때, 이기는 사람을 구하는 문제.
게임은 상근이가 먼저 시작한다.
첫째 줄에 N이 주어진다. (1 ≤ N ≤ 1000)
상근이가 게임을 이기면 SK를, 창영이가 게임을 이기면 CY을 출력한다.
다이나믹 프로그래밍 유형의 문제

예제 및 실행결과

예제 1

실행결과 1

SK

⌨️ 문제 풀이

상근이를 기준으로 DP 배열을 구성할 것이다. 그렇다면, 어떻게하면 상근이가 이길 수 있을지에 대해서 생각해보면 좋다.
"완벽하게 게임을 한다" 라는 구절을 통해서 어떻게든 상근이가 이길 방법이 있다면,
DP 배열에서 그 개수는 상근이가 이기는 판으로 기록을 해두는것 이 옳다.
문제의 예제로 나온 5까지 직접 써보면서 어떻게 승부가 갈리는지 보자.
돌이 1개일 때, 상근이는 1개를 가져갈 수 있으며 이기게 된다. -> 1
돌이 2개일 때, 상근이는 1개를 가져갈 수 있으며 지게 된다. -> 0
돌이 3개일 때, 상근이는 1, 3개를 가져갈 수 있으며, 두 경우 모두 이길수 있다. -> 1
돌이 4개일 때, 상근이는 1, 3개를 가져갈 수 있으며, 두 경우 모두 지게 된다. -> 0
돌이 5개일 때, 상근이는 1, 3개를 가져갈 수 있으며, 두 경우 모두 이길 수 있다. -> 1

(2)번을 통해서 생긴 DP 배열은 아래와 같이 볼 수 있다.
dp = [0, 1, 0, 1, 0, 1]
위 규칙을 보면, 상근이는 짝수 일 때 지고 홀 수 일 때 이길 수 있다.
(4)번에서 결론을 내렸으니, N 이 짝수인지 홀수인지 판별해 문자를 출력하면 된다.

소스 코드

from sys import stdin
print('SK' if int(stdin.readline()) % 2 != 0 else 'CY')

[백준] 3943 헤일스톤수열 with Python

형준_It's — Tue, 4 Apr 2023 17:09:46 +0900

BOJ 3943 헤일스톤수열

조건

헤일스톤 수열은 아래와 같이 정의한다.
- n이 짝수라면, 2로 나눈다.
- n이 홀수라면, 3을 곱한 뒤 1을 더한다.
헤일스톤 추측은 임의의 양의 정수 n으로 수열을 시작한다면, 항상 4, 2, 1, 4, 2, 1,...로 끝난다는 추측이다.
이 문제에서는 1이 나오면 수열이 끝난 것으로 처리한다.
n이 주어졌을 때, 이 수열에서 가장 큰 값을 찾아 출력하는 문제
첫째 줄에 테스트 케이스의 개수 T(1 ≤ T ≤ 100,000)가 주어진다.
다음 줄부터 T개의 줄에는 헤일스톤 수열의 시작값 n이 주어진다. (1 ≤ n ≤ 100,000)
구현, 시뮬레이션 유형읨 문제

예제 및 실행결과

예제 1

실행결과 1

⌨️ 문제 풀이

이 문제에서는 헤일스톤 수열을 만들기 위해 계산하면서 나온 결과값이 1이 나오면 반복문을 종료하면 된다.
n으로 입력 받은 수를 헤일스톤 수열을 저장할 리스트에 넣고, 결과값을 계속 넣어준다.
n 이 결국 1이 되었을 때, 반복문을 종료하고, 헤일스톤 수열로 만들어 놓은 리스트에서 가장 큰 수를 출력한다.

소스 코드

from sys import stdin

for _ in range(int(stdin.readline())):
    n = int(stdin.readline())
    arr = [n]

    while n != 1:
        if n % 2 == 0:
            n //= 2
        else:
            n = n * 3 + 1

        arr.append(n)

    print(max(arr))

[백준] 1652 누울 자리를 찾아라 with Python

형준_It's — Mon, 3 Apr 2023 16:40:04 +0900

BOJ 1652 누울 자리를 찾아라

조건

코레스코 콘도에 있는 방은 NxN의 정사각형모양으로 생겼다.
방 안에는 옮길 수 없는 짐들이 이것저것 많이 있어서 영식이의 누울 자리를 차지하고 있었다.
영식이가 누울 수 있는 자리에는 조건이 있다.
똑바로 연속해서 2칸 이상의 빈 칸이 존재하면 그 곳에 몸을 양 옆으로 쭉 뻗으면서 누울 수 있다.
가로로 누울 수도 있고 세로로 누울 수도 있다.
누울 때는 무조건 몸을 쭉 뻗기 때문에 반드시 벽이나 짐에 닿게 된다. (중간에 어정쩡하게 눕는 경우가 없다.)
방의 크기 N과 방의 구조가 주어졌을 때, 가로로 누울 수 있는 자리와 세로로 누울 수 있는 자리의 수를 구하는 문제
N은 1이상 100이하의 정수이다. '.'은 아무것도 없는 곳을 의미하고, 'X'는 짐이 있는 곳을 의미한다.
구현, 문자열 유형의 문제

예제 및 실행결과

예제 1

5
....X
..XX.
.....
.XX..
X....

실행결과 1

5 4

⌨️ 문제 풀이

가로, 세로로 누울 수 있는 자리에 대한 좌표값을 방문처리 리스트에 체크하여 여러번 카운팅 하지 않게 했다.
이 문제에서 중요하게 생각해야할 점은, 누울 때는 무조건 몸을 쭉 뻗기 때문에 반드시 벽이나 짐에 닿게 된다.
이다.
누울 수 있는 자리를 방문처리 리스트에 체크할 때, 짐이 등장한다면 거기서 방문처리를 멈춰야한다.
(3)번이 지켜지지 않을 경우, 극초반 테스트 케이스에서 틀렸습니다 가 나올 것이다.

소스 코드

from sys import stdin

n = int(stdin.readline())
board = []

for _ in range(n):
    board.append(list(stdin.readline().rstrip()))
g_v = [[1] * n for _ in range(n)]
s_v = [[1] * n for _ in range(n)]
g, s = 0, 0


def check(x, y, mode):
    global g, s

    if mode == 1:
        if board[x][y] == board[x][y + 1] and (g_v[x][y] == 1 and g_v[x][y + 1] == 1):
            g += 1
            for j in range(y, n):
                if board[x][j] == 'X':
                    break
                g_v[x][j] = 0
            for j in range(y, -1, -1):
                if board[x][j] == 'X':
                    break
                g_v[x][j] = 0

    elif mode == 2:
        if board[x][y] == board[x + 1][y] and (s_v[x][y] == 1 and s_v[x + 1][y] == 1):
            s += 1
            for i in range(x, n):
                if board[i][y] == 'X':
                    break
                s_v[i][y] = 0

            for i in range(x, -1, -1):
                if board[i][y] == 'X':
                    break
                s_v[i][y] = 0


for i in range(n):
    for j in range(n):
        if board[i][j] == '.':
            if j + 1 < n:
                check(i, j, 1)

            if i + 1 < n:
                check(i, j, 2)

print(g, s)

[백준] 1789 수들의 합 with Python

형준_It's — Mon, 3 Apr 2023 16:26:56 +0900

BOJ 1789 수들의 합

조건

서로 다른 N개의 자연수의 합이 S라고 한다. S를 알 때, 자연수 N의 최댓값은 얼마일까?
첫째 줄에 자연수 S(1 ≤ S ≤ 4,294,967,295)가 주어진다.
첫째 줄에 자연수 N의 최댓값을 출력한다.
수학, 그리디 알고리즘 유형의 문제

예제 및 실행결과

예제 1

실행결과 1

⌨️ 문제 풀이

계산하고 있는 계산값(A), 정답(B), 더할 수(C)를 각각 변수로 만든다.
while를 이용해 반복적인 계산을 한다.
A += C 후, C += 1, B += 1
(2)번의 반복문은 A가 입력 받은 S 보다 작을때만 반복한다.
while 의 조건에 해당되지 않아 반복문이 종료되었으면 조건에 맞게 출력한다.
만약 A가 S와 값이 같다면 ans를, 그게 아니라면 ans -1 을 출력한다.

소스 코드

from sys import stdin

s = int(stdin.readline())
ans, res, num = 0, 0, 1

while res < s:
    res += num
    num += 1
    ans += 1

print(ans if res == s else ans - 1)

[백준] 10419 지각 with Python

형준_It's — Mon, 3 Apr 2023 16:14:01 +0900

BOJ 10419 지각

조건

교수님의 지각시간 0이상의 정수 t와 수업을 일찍 마쳐주는 시간 s 사이에는 s = t**2 의 관계가 있다.
창영이가 궁금한 경우의 수 T(1 ≤ T ≤ 100)가 첫 번째 줄에 주어지고,
이어서 T 개의 줄에 수업시간 d(1 ≤ d ≤ 10,000, d는 정수)가 차례대로 주어진다.
수업시간에 따른 교수님이 지각할 수 있는 최대 시간 t를 정수로 구해서 출력한다.
지각할 수 있는 최대의 시간을 알아보는 문제
브루트포스 유형의 문제

예제 및 실행결과

예제 1

실행결과 1

⌨️ 문제 풀이

지각할 수 있는 최대시간을 구하려면, 수업시간 d의 최대값이 얼마인지 확인해봐야한다.
지각할 수 있는 최대시간은 100부터 -1씩 줄여나가 i * 1 ** 2의 값이 d보다 같거나 작아질 때를 찾으면 된다.
만약 d = 1 이라면 0이 출력되어야 하기 때문에 ans의 값은 0으로 초기화를 한 뒤 계산한다.

소스 코드

from sys import stdin

for _ in range(int(stdin.readline())):
    d = int(stdin.readline())
    ans = 0
    for i in range(100, 0, -1):
        if i + i ** 2 <= d:
            ans = i
            break
    print(ans)

[백준] 5692 팩토리얼 진법 with Python

형준_It's — Mon, 3 Apr 2023 16:04:14 +0900

BOJ 5692 팩토리얼 진법

조건

팩토리얼 진법에서는 i번 자리의 값을 ai×i!로 계산한다.
즉, 팩토리얼 진법에서 719는 10진법에서 53과 같다. 그 이유는 7×3! + 1×2! + 9×1! = 53이기 때문이다.
입력은 여러 개의 테스트 케이스로 이루어져 있다.
각 테스트 케이스는 한 줄로 이루어져 있고, 길이가 최대 5자리인 팩토리얼 진법 숫자가 주어진다.
입력의 마지막 줄에는 0이 하나 주어진다.
각 테스트 케이스에 대해서, 입력으로 주어진 팩토리얼 진법 숫자를 10진법으로 읽은 값을 출력한다.
수학 유형의 문제

예제 및 실행결과

예제 1

실행결과 1

⌨️ 문제 풀이

입력 받은 숫자를 문자열로 변경한 뒤, 길이(l)를 구한다.
숫자를 한자리씩 순회하면서(i) i * l! 를 계산해 ans 에 더해준다.

소스 코드

from sys import stdin
from math import factorial as fa

while 1:
    n = int(stdin.readline())
    if n == 0:
        break

    l = len(str(n))
    ans = 0

    for i in str(n):
        ans += fa(l) * int(i)
        l -= 1

    print(ans)

[백준] 5988 홀수일까 짝수일까 with Python

형준_It's — Mon, 3 Apr 2023 15:52:06 +0900

BOJ 5988 홀수일까 짝수일까

조건

N개의 정수가 주어지면 홀수인지 짝수인지를 출력하는 프로그램을 작성하는 문제.
N(1 <= N <= 100)
N+1번째 줄에 걸쳐 홀수인지 짝수인지 확인할 정수 K (1 <= K <= 10^60)가 주어진다.
N개의 줄에 걸쳐 한 줄씩 정수 K가 홀수라면 'odd'를, 짝수라면 'even'을 출력한다.
수학 유형의 문제

예제 및 실행결과

예제 1

2
1024
5931

실행결과 1

even
odd

⌨️ 문제 풀이

각 숫자를 2로 나누어 나온 나머지가 0이면 even, 아니면 odd를 출력한다.

소스 코드

from sys import stdin

for _ in range(int(stdin.readline())):
    if int(stdin.readline()) % 2 == 0:
        print('even')
    else:
        print('odd')

[백준] 1676 팩토리얼 0의 개수 with Python

형준_It's — Sat, 1 Apr 2023 22:49:45 +0900

BOJ 1676 팩토리얼 0의 개수

조건

N!에서 뒤에서부터 처음 0이 아닌 숫자가 나올 때까지 0의 개수를 구하는 프로그램을 작성하는 문제.
첫째 줄에 N이 주어진다. (0 ≤ N ≤ 500)
수학 유형의 문제

예제 및 실행결과

예제 1

실행결과 1

예제 2

실행결과 2

⌨️ 문제 풀이

리스트에 팩토리얼 계산 값을 미리 넣어놓으면 쉽게 해결할 수 있다.
N에 해당하는 값을 꺼내 맨 우측부터 좌측 방향으로 이동하며 0이 아닌 수가 나올 때까지 0의 개수가 몇 개인지 세면 된다.

소스 코드

from sys import stdin

arr = [1, 2, 6, 24, 120]

n = int(stdin.readline())
if n < 5:
    print(0)
else:
    for i in range(6, 501):
        arr.append(arr[-1] * i)

    ans = 0
    s = str(arr[n-1])
    for i in range(len(s)-1, -1, -1):
        if s[i] == '0':
            ans += 1
        else:
            print(ans)
            break

[백준] 14469 소가 길을 건너간 이유 3 with Python

형준_It's — Sat, 1 Apr 2023 22:41:58 +0900

BOJ 14469 소가 길을 건너간 이유 3

조건

N마리의 소가 이 농장에 방문하러 왔다. 소가 도착한 시간과 검문받는 데 걸리는 시간은 소마다 다르다. (물론 같을 수도 있다.)

두 소가 동시에 검문을 받을 수는 없다. 예를 들어, 한 소가 5초에 도착했고 7초 동안 검문을 받으면,
8초에 도착한 그 다음 소는 12초까지 줄을 서야 검문을 받을 수 있다.

모든 소가 농장에 입장하려면 얼마나 걸리는지 구하는 문제.

첫 줄에 100 이하의 양의 정수 N이 주어진다.

다음 N줄에는 한 줄에 하나씩 소의 도착 시각과 검문 시간이 주어진다. 각각 1,000,000 이하의 양의 정수이다.

정렬, 그리디 유형의 문제

예제 및 실행결과

예제 1

실행결과 1

⌨️ 문제 풀이

기본 아이디어는 정렬부터 시작을 했다. 모든 소가 입장하려면 얼마나 걸리는지, 최소시간을 출력하는 문제이다.

소가 모두 입장하는데에 걸리는 최소 시간을 찾으려면, 입장하는 번호를 기준으로 정렬을 해야한다.

소가 도착한 시간과 검문 받는데 걸리는 시간은 같을 수 있으므로, lambda 로 정렬 시켰다.
기준은 (소가 도착한 시간, 검문 받는 시간) 을 각각 오름차순으로 정렬했다.

정렬된 리스트를 순회하면서, 만약 현재 흐른 시간(ans)가 소가 도착한 시간(s) 보다 작거나 같다면 ans에 s를 넣어준다.
그 후 ans에 검문시간을 더해준다.
(4)번에 예외되는 조건이라면 그냥 ans에 c를 더해주고 출력한다.

소스 코드

from sys import stdin

n = int(stdin.readline())
arr = []

for _ in range(n):
    a, b = map(int, stdin.readline().split())
    arr.append((a, b))

arr.sort(key=lambda x: (x[0], x[1]))

ans = 0

for i in range(n):
    s, c = arr[i][0], arr[i][1]
    if ans <= s:
        ans = s
        ans += c

    else:
        ans += c

print(ans)

[백준] 1992 쿼드트리 with Python

형준_It's — Fri, 31 Mar 2023 17:57:53 +0900

BOJ 1992 쿼드트리

조건

주어진 영상이 모두 0으로만 되어 있으면 압축 결과는 "0"이 되고, 모두 1로만 되어 있으면 압축 결과는 "1"이 된다.
만약 0과 1이 섞여 있으면 전체를 한 번에 나타내지를 못한다.
왼쪽 위, 오른쪽 위, 왼쪽 아래, 오른쪽 아래, 이렇게 4개의 영상으로 나누어 압축하게 된다.
이 4개의 영역을 압축한 결과를 차례대로 괄호 안에 묶어서 표현.
N 은 언제나 2의 제곱수로 주어지며, 1 ≤ N ≤ 64의 범위를 가진다.
N ×N 크기의 영상이 주어질 때, 이 영상을 압축한 결과를 출력하는 프로그램을 작성하는 문제.
분할정복, 재귀 유형의 문제.

예제 및 실행결과

예제 1

실행결과 1

((110(0101))(0010)1(0001))

⌨️ 문제 풀이

분할정복의 개념으로 해결을 할 수 있는 문제이다.
n 을 2씩 나누어 재귀를 통해 큰 단위에서 작은 단위로 가는 방식으로 해결했다.
check() 함수로 각 좌표를 기준으로 mode 만큼 떨어진 좌표까지 숫자가 같은지 탐색한다.
만약 같지 않다면, 괄호를 넣고 재귀한다.
같다면 1혹은 0을 넣어준다.
좌표는 네 방향이다. 재귀를 할 때마다 mode는 두 배씩 줄어든다.

소스 코드

from sys import stdin, setrecursionlimit

setrecursionlimit(10 ** 6)

n = int(stdin.readline())
arr, ans = [], ''
for i in range(n):
    arr.append(list(map(int, list(stdin.readline().rstrip()))))


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


def solve(x, y, mode):
    global ans

    if check(x, y, mode):
        if arr[x][y] == 1:
            ans += '1'
        else:
            ans += '0'

    else:
        ans += '('
        solve(x, y, mode // 2)
        solve(x, y + mode // 2, mode // 2)
        solve(x + mode // 2, y, mode // 2)
        solve(x + mode // 2, y + mode // 2, mode // 2)
        ans += ')'


solve(0, 0, n)
print(ans)

최소 비용 신장트리

형준_It's — Tue, 9 Aug 2022 18:41:33 +0900

최소 비용 신장트리

정의
- 가중치가 부여된 무방향 그래프에서 신장 트리의 비용
  가중치 : 두 vertex 사이의 거리 혹은 연결하는 비용
  = 신장트리를 구성하는 에지들의 비용의 합
- 최소 비용 신장트리 : 가장 비용이 적은 신장 트리

응용 분야
- 도로 건설 : 도시를 모두 연결하면서 도로의 길이가 최소가 되도록 하는 문제
  ex) 통신, 배관

최소 비용 신장트리 알고리즘
- 최소 비용 신장트리 알고리즘
  1) 그래프 내에 존재하는 Edge들만 사용한다.
  2) 정점의 개수가 n일 때, n - 1개의 Edge들만 사용한다.
  3) 사이클을 형성하는 edge는 사용불가하다.
- 최소 비용 신장트리를 구하기 위한 알고리즘들
  1) 크루스칼
  2) 프림
  3) 솔린

크루스칼 알고리즘(Kruskal Algorithm)

E log E 의 시간 복잡도를 가진다.
Heap 을 이용하여 구현하는 것이 필요하다.

알고리즘의 개요
- Edge들을 비용의 오름차순으로 정렬한다.
- 가장 비용이 적은 Edge부터 하나씩 선택한다.
- 선택된 Edge는 기존에 선택된 Edge들과 사이클을 형성하지 않을 경우에만 신장트리 T에 포함된다.
- 그래프 G가 연결되어 있으며, N(> 0)개의 정점이 존재하는 경우, 정확히 N-1개의 Edge가 선택된다.

프림 알고리즘(Prim Algorithm)

이미 선택된 것에서 나머지로 가는 것만 체크한다.
Prim 알고리즘에서는 사이클 검사가 따로 필요하지 않는다.

알고리즘의 개요
- 하나의 정점만 갖는 트리 T에서 시작한다.
- T에 포함된 정점과 포함되지 않는 정점을 연결하는 Edge들 중에서 비용이 최소인 Edge를 T에 추가한다.
- 추가된 Edge의 vertex를 T에 포함한다.
  O(n * n)

희소 그래프 = 크루스칼 = 정점이 몇 개 없다면 사용
완전 그래프 = 프림 = 정점이 많다면 사용

솔린(Sollin) 알고리즘

알고리즘의 개요
- 단계별로 T에 포함시킬 여러 Edge들을 동시에 선택한다.
- 각 단계에서 선택된 엣지들은 그래프의 "신장 숲(Spanning Forest)" 구성
- 초기에는 Edge가 없으므로, forest에 정점 수만큼의 트리가 존재한다.
- 각 단계에서 forest에 있는 각 트리에 대해 하나의 에지를 선택한다.
  선택 기준 = 최소비용
- 두 개의 트리에서 동일한 edge를 선택할 수 있으므로, 중복된 Edge를 제거하는 절차가 필요하다.
- 하나의 트리만 남거나 혹은 추가할 Edge가 없을 경우 종료한다.

기초적인 그래프 연산들

형준_It's — Tue, 9 Aug 2022 18:18:46 +0900

기초적인 그래프 연산들

깊이 우선 탐색(Depth First Search)

DFS 알고리즘
- 출발 정점, v의 인접리스트부터 방문한다.
- v에 인접하면서 아직 방문하지 않은 정점 w를 선택한다.
- w를 시작점으로 하여 다시 DFS를 시작한다.
- 순환 알고리즘을 이용하여 구현한다.(재귀)

너비 우선 탐색(Breath First Search)

BFS 알고리즘
- 출발 정점, v의 인접 리스트부터 방문한다.
- v에 인접한 모든 vertex부터 방문한다.
- 그 다음, v에 인접한 첫번째 vertex에 인접한 vertex 중에서
  아직 방문하지 않은 vertex 들을 차례대로 다시 방문한다.
  -> Queue 자료구조를 사용하여 구현

연결요소(Connected Component)

무방향성 그래프가 연결되어 있는지 검사한다.
- DFS, BFS를 호출하여 방문하지 않은 정점이 있는지 검사한다.

신장트리(Spanning Tree)

신장트리 : 그래프 G에 포함된 예시들로 구성되며, G의 모든 정점을 포함한 트리이다.
* 싸이클 제외, 정점 N개 -> 엣지 (N - 1)개

DFS or BFS로 신장트리를 구성한다.
- DFST(깊이 우선 신장 트리)
- BFST(너비 우선 신장 트리)

단절점(Articulation Points)

그래프 G의 정점 V에 연결된 Edge들을 모두 삭제할 경우,
G가 두 개 이상의 연결요소로 분할되는 V

이중 연결 그래프(Biconnected Graph)
- 단절점이 없는 Connectd Graph

이중 연결 요소(Biconnected component)
- 연결 그래프 G에서 Maximal Biconnected Subgraph, H
- Maxiaml : 이중연결 되었으면서, H를 완전히 포함하는 부분 그래프가
  G에 존재하지 않는다.

어떤 노드를 연결했을 때, 단절점이 생길 수 있다.

[백준] 1890 점프 with Python

형준_It's — Tue, 9 Aug 2022 17:33:37 +0900

BOJ 1890 점프

조건

N×N 게임판에 수가 적혀져 있다.
N (4 ≤ N ≤ 100)

이 게임의 목표는 가장 왼쪽 위 칸에서 가장 오른쪽 아래 칸으로 규칙에 맞게 점프를 해서 가는 것이다.
각 칸에 적혀있는 수는 현재 칸에서 갈 수 있는 거리를 의미한다.
칸에 적혀있는 수는 0보다 크거나 같고, 9보다 작거나 같은 정수이며, 가장 오른쪽 아래 칸에는 항상 0이 주어진다.

반드시 오른쪽이나 아래쪽으로만 이동해야 한다.
0은 더 이상 진행을 막는 종착점이며, 항상 현재 칸에 적혀있는 수만큼 오른쪽이나 아래로 가야 한다.

한 번 점프를 할 때, 방향을 바꾸면 안 된다.
즉, 한 칸에서 오른쪽으로 점프를 하거나, 아래로 점프를 하는 두 경우만 존재한다.

가장 왼쪽 위 칸에서 가장 오른쪽 아래 칸으로 규칙에 맞게 이동할 수 있는 경로의 개수를 구하는 문제.

DP 유형의 문제

예제 및 실행결과

예제

실행결과

⌨️ 문제 풀이

경로의 개수를 구하는 문제이다. 이 문제는 하나하나 경로를 살펴보기 위해서 dfs를 사용할 경우, 시간복잡도가 매우 크게 나온다.

다이나믹프로그래밍 알고리즘을 이용하여 문제를 해결해야하는데, 우리는 문제에서 아래와 같은 조건에 주목을 해서 풀면 쉽게 생각해볼 수 있는 문제이다.
칸에 적혀있는 수는 0보다 크거나 같고, 9보다 작거나 같은 정수이며, 가장 오른쪽 아래 칸에는 항상 0이 주어진다.
반드시 오른쪽이나 아래쪽으로만 이동해야 한다.
0은 더 이상 진행을 막는 종착점이며, 항상 현재 칸에 적혀있는 수만큼 오른쪽이나 아래로 가야 한다.

(0, 0)에서 시작해 (n - 1, n - 1) 까지 가는 경우의 수를 DP 리스트에 저장해나가면서 반복문을 통해 문제를 해결한다면,
시간복잡도는 약 O(N * N) 이 나온다. 최악의 경우를 고려하더라도 최대 약 10,000 정도밖에 안걸린다.
DP 리스트는 n * n 크기의 리스트로 만들고, (0, 0)은 1로 초기화한다.

2중 for 문을 사용하여, 만약 현재 위치한 곳이 (n - 1, n - 1) 이라면 dp[i][j]를 출력하면 된다.

(4)번의 경우가 아니라면, (i, j)에 해당하는 arr의 값을 cur 라는 변수에 저장한다.
현재 위치인 (i, j) 에서 우측으로 cur 만큼 이동을 할 수 있다면, dp[i][j + cur]에 dp[i][j]를 더해준다.
현재 위치인 (i, j) 에서 하단으로 cur 만큼 이동을 할 수 있다면, dp[i + cur][j]에 dp[i][j]를 더해준다.

소스 코드

from sys import stdin

n = int(stdin.readline())
arr = []
for _ in range(n):
    arr.append(list(map(int, stdin.readline().split())))

dp = [[0] * n for _ in range(n)]
dp[0][0] = 1


for i in range(n):
    for j in range(n):
        if i == n - 1 and j == n - 1:
            print(dp[i][j])
            break

        cur = arr[i][j]

        if j + cur < n:
            dp[i][j + cur] += dp[i][j]

        if i + cur < n:
            dp[i + cur][j] += dp[i][j]

[백준] 1722 순열의 순서 with Python

형준_It's — Tue, 9 Aug 2022 17:18:04 +0900

BOJ 1722 순열의 순서

조건

1부터 N까지의 수를 임의로 배열한 순열은 총 N! = N×(N-1)×…×2×1 가지가 있다.

임의의 순열은 정렬을 할 수 있다.
예를 들어 N=3인 경우 {1, 2, 3}, {1, 3, 2}, {2, 1, 3}, {2, 3, 1}, {3, 1, 2}, {3, 2, 1}의 순서로 생각할 수 있다.

N이 주어지면, 아래의 두 소문제 중에 하나를 풀어야 한다.
k가 주어지면 k번째 순열을 구하고, 임의의 순열이 주어지면 이 순열이 몇 번째 순열인지를 출력하는 문제

첫째 줄에 N(1 ≤ N ≤ 20)이 주어진다.

1인 경우 k(1 ≤ k ≤ N!)를 입력받고, 2인 경우 임의의 순열을 나타내는 N개의 수를 입력받는다.
N개의 수에는 1부터 N까지의 정수가 한 번씩만 나타난다.

수학, 조합론 유형의 문제

예제 및 실행결과

예제 1

4
1 3

실행결과 1

1 3 2 4

예제 2

4
2 1 3 2 4

실행결과 2

⌨️ 문제 풀이

N이 최대 20까지라면, 브루트포스로 풀이했을 때 시간복잡도가 최악의 경우 20! = 2,432,902,008,176,640,000 가지의 경우의 수가 나온다.
무조건 시간초과가 날 수 밖에 없다.

입력 순열이 만약 [3, 4, 1, 2]가 입력되었다고 가정해보자.
1로 시작하는 [1, ?, ? ,?]와 같은 순열의 경우의 개수는 3!이다.
2로 시작하는 [2, ?, ? ,?]와 같은 순열의 경우의 개수는 3!이다.

입력을 받은 순열은 3으로 시작한다. 따라서
[3, 1, ?, ?]로 시작하는 순열의 경우의 개수는 2!이다.
[3, 2, ?, ?]로 시작하는 순열의 경우의 개수는 2!이며, 3도 마찬가지이다.

이 후의 개수는 [3, 4, 1, ?] 1개.
2번 부터 4번의 과정을 더하면 몇 번째 순열인지 알 수가 있다.

이와 같은 과정을 반대로 진행하면 K번째 순열을 출력할 수 있다.

소스 코드

from sys import stdin

n = int(stdin.readline())
data = list(map(int, stdin.readline().split()))
cache = {}


def find_permutations(n):
    if n in cache:
        return cache[n]

    elif n <= 1:
        return 1

    else:
        cache[n] = n * find_permutations(n - 1)
        return cache[n]


if data[0] == 1:
    k = data[1]
    arr = [x for x in range(1, n + 1)]
    ans = []

    for i in range(n):
        x = find_permutations(n - 1 - i)
        step = (k - 1) // x
        ans.append(arr[step])
        arr.remove(arr[step])
        k -= x * step

    print(*ans)

else:
    input_permu = data[1:]
    sort_permu = sorted(data[1:])
    ans = 1

    for i in range(n):
        step = sort_permu.index(input_permu[i])
        sort_permu.remove(input_permu[i])
        x = find_permutations(n - 1 - i)
        ans += x * step

    print(ans)

[백준] 1081 합 with Python

형준_It's — Fri, 22 Jul 2022 20:06:15 +0900

BOJ 1081 합

조건

L보다 크거나 같고, U보다 작거나 같은 모든 정수의 각 자리의 합을 구하는 문제.
0 ≤ L ≤ U ≤ 2,000,000,000

수학 유형의 문제

예제 및 실행결과

예제

24660 308357171

실행결과

11379854844

⌨️ 문제 풀이

가장 먼저 문제를 보며 주목해야할 부분은 L과 U의 범위이다.
L과 U의 범위는 최대 20억까지로, 일일히 검사했을 때 최악의 경우에는 0부터 20억까지의 모든 수를 검사해야하기 때문에
문제에서 주어진 2초라는 시간 안에 절대 해결할 수가 없다.

(1)번에서 정리한대로, 우리는 L과 U의 범위를 입력받아 일일히 숫자 하나씩 검사하는 방법을 피해 각 숫자의 자릿수를 더해 답을 출력해야 한다.
L, U 를 입력받아 L보다 크거나 같고, U보다 작거나 같은 모든 정수의 각 자리의 합을 구하는 것은 어느 일정 구간에 대한 합을 구하는 것과 같다.
구간합의 개념으로 생각을 해보자.

L - 1 까지 등장한 0~9의 개수를 K, U까지 등장한 0-9 의 개수를 P 라고 했을 때,
(P - K) 는 L 부터 U 의 범위에 해당하는 0-9의 개수라는 것을 의미한다.

L = 1000, U = 1234 라고 가정했을 때, 접근 방법은 두가지가 있다.
- 1의 자리에서부터 0~9까지의 등장 횟수를 count 할 것인가?
- 가장 높은 자리에서부터 0-9까지의 등장 횟수를 count 할 것인가?
  일단 본인의 풀이는 1의 자리에서부터 0~9까지의 숫자를 count 했다.

먼저, 1의 자리에 어떤 숫자가 몇 번 등장하는지에 대해서 살펴보자. 먼저 0부터 살펴보자.
10 ~ 90 : 10
100 ~ 190, 200 ~ 290, ... ,900~990 : 90
1000 ~ 1090, 1100 ~ 1190 : 20
1200 ~ 1230 : 4
총 124 회

1의 자리에서 5가 몇번 등장할까?
15 ~ 95 : 10
105 ~ 195, 205 ~ 295, ... ,905 ~ 995 : 90
1005 ~ 1095, 1105 ~ 1195 : 20
1205 ~ 1225 : 3
총 123 회

10의 자리에서 4는 몇 번 등장할까?
40 ~ 49 : 10
140 ~ 149, 240 ~ 249, ..., 940 ~ 949 : 90
1040 ~ 1049, 1140 ~ 1149 : 20
총 120 회.

여기서 알 수 있는 것은, 우리는 이렇게 숫자의 자릿수 별로 각 숫자가 몇번씩 등장하는지 계산할 수 있다는 것이다.
또한, 10의 자리에서 4가 몇 번 등장하는지를 셀 때에는 1234를 넘을 수 없기 때문에 1149까지 세어 120회가 나왔다.
이제 소스코드 로직을 따라서 이해하면 쉽다.

n_arr 은 입력받은 n - 1 까지 0 부터 9의 등장횟수를 저장한다.
m_arr 은 입력받은 m까지 0 부터 9의 등장횟수를 저장한다.

가장 먼저 1의 자리수에서 0~9까지의 등장횟수를 저장할 것이기 때문에 point 를 1로, n을 -1 해준뒤 n이 0이 아닐 때까지 while 반복을 한다.
- n % 10 이 9가 아닌 경우, n 의 각 자릿수의 숫자에 해당하는 n_arr 원소값에 point를 더해준다.
  예를 들면, 입력받은 n이 1234 부터 시작하여 1233, 1232, 1231, 1230 까지 각 자릿수에 해당하는 숫자를 point 만큼 올려준다.

- n < 10 인 경우는 오른쪽 끝 부터 확인하여 n //= 10 을 반복해 한자리수가 남았을 때 처리해주는 로직이다. 
  이 경우는 거의 마지막에 해당하는 로직이니 이후에 알아볼 것이다.


- n >= 10 인 경우는 만약 1234 라면 1의 자리를 볼 때, 4 이하는 124번이 등장하며, 5 이상은 123번이 등장한다.
  이는 `(n // 10 + 1) * point` 로 표현할 수 있다.


- 다시 n < 10 인 경우를 보자면, 0부터 n까지의 각 자리에 대해서 point 만큼씩 더해주고, 0인 경우는 point 를 빼준다.
  다른 숫자는 약 130회 등장하는 경우, 0은 120회 등장한다. 직접 계산해보자.

0부터 n - 1 까지 0~~9까지의 등장횟수를 n_arr에 저장했다면, 이제 0부터 m까지 0~~9 등장횟수를 m_arr 에 같은 로직으로 저장한다.

이후는 각자리의 합을 더하는 작업이다.
n_arr, m_arr 을 순회하면서 각 등장횟수 (m_arr[i] - n_arr[i]) 에 i 를 곱해 ans 에 더해준다.
이는 각 자리수를 더해주는 것과 같다.

소스 코드

from sys import stdin

n, m = map(int, stdin.readline().split())

n_arr = [0 for _ in range(10)]
m_arr = [0 for _ in range(10)]

n -= 1
point = 1
while n != 0:
    while n % 10 != 9:
        for i in str(n):
            n_arr[int(i)] += point
        n -= 1
    if n < 10:
        for i in range(n + 1):
            n_arr[i] += point
        n_arr[0] -= point
        break
    else:
        for i in range(10):
            n_arr[i] += (n // 10 + 1) * point
    n_arr[0] -= point
    point *= 10
    n //= 10


point = 1
while m != 0:
    while m % 10 != 9:
        for i in str(m):
            m_arr[int(i)] += point
        m -= 1
    if m < 10:
        for i in range(m + 1):
            m_arr[i] += point
        m_arr[0] -= point
        break
    else:
        for i in range(10):
            m_arr[i] += (m // 10 + 1) * point
    m_arr[0] -= point
    point *= 10
    m //= 10


ans = 0
for i in range(10):
    ans += (m_arr[i] - n_arr[i]) * i

print(ans)

배운점

수학적 사고능력이 필요한 문제였다. 스스로는 이해하기 어려워, 나에게 알고리즘 적으로 도움을 주는 스승이자 동생에게 도움을 받아 이해했다.

각 자리수 별로 0~9의 숫자가 몇 번 등장하는지 계산하는 것은 매우 헷갈리는 작업이었다.

0의 등장횟수는 반드시 다시한번 체크하고 계산해보아야한다. 그렇지 않으면 1019 번 문제를 틀리게 된다.

[백준] 1005 ACM Craft with Python

형준_It's — Sun, 17 Jul 2022 22:33:36 +0900

BOJ 1005 ACM Craft

조건

서기 2012년! 드디어 2년간 수많은 국민들을 기다리게 한 게임 ACM Craft (Association of Construction Manager Craft)가 발매되었다.

이 게임은 지금까지 나온 게임들과는 다르게 ACM크래프트는 다이나믹한 게임 진행을 위해 건물을 짓는 순서가 정해져 있지 않다.
즉, 첫 번째 게임과 두 번째 게임이 건물을 짓는 순서가 다를 수도 있다.
매 게임시작 시 건물을 짓는 순서가 주어진다. 또한 모든 건물은 각각 건설을 시작하여 완성이 될 때까지 Delay가 존재한다.

프로게이머 최백준은 애인과의 데이트 비용을 마련하기 위해 서강대학교배 ACM크래프트 대회에 참가했다!
최백준은 화려한 컨트롤 실력을 가지고 있기 때문에 모든 경기에서 특정 건물만 짓는다면 무조건 게임에서 이길 수 있다.

매 게임마다 특정건물을 짓기 위한 순서가 달라지므로 최백준은 좌절하고 있었다.
백준이를 위해 특정건물을 가장 빨리 지을 때까지 걸리는 최소시간을 알아내는 문제.

첫째 줄에는 테스트케이스의 개수 T가 주어진다.
첫째 줄에 건물의 개수 N과 건물간의 건설순서 규칙의 총 개수 K이 주어진다. (건물의 번호는 1번부터 N번까지 존재한다)

둘째 줄에는 각 건물당 건설에 걸리는 시간 D1, D2, ..., DN이 공백을 사이로 주어진다.
셋째 줄부터 K+2줄까지 건설순서 X Y가 주어진다. (이는 건물 X를 지은 다음에 건물 Y를 짓는 것이 가능하다는 의미이다)
마지막 줄에는 백준이가 승리하기 위해 건설해야 할 건물의 번호 W가 주어진다.

2 ≤ N ≤ 1000
1 ≤ K ≤ 100,000
1 ≤ X, Y, W ≤ N
0 ≤ Di ≤ 100,000, Di는 정수

BFS, 그래프탐색 유형의 문제

소스 코드

from collections import deque
from sys import stdin


def topology_sort(w):
    q = deque()
    dp = [0 for _ in range(n + 1)]
    for i in range(1, n + 1):
        if indegree[i] == 0:
            q.append(i)
            dp[i] = arr[i]

    while q:
        now = q.popleft()

        for node in graph[now]:
            indegree[node] -= 1
            dp[node] = max(dp[now] + arr[node], dp[node])
            if indegree[node] == 0:
                q.append(node)

    return dp[w]


for tc in range(int(stdin.readline())):
    n, m = map(int, stdin.readline().split())
    indegree = [0] * (n + 1)
    graph = [[] for _ in range(n + 1)]
    arr = [0] + list(map(int, stdin.readline().split()))
    for _ in range(m):
        a, b = map(int, stdin.readline().split())
        graph[a].append(b)
        indegree[b] += 1

    w = int(stdin.readline())
    print(topology_sort(w))

예제 및 실행결과

예제

2
4 4
10 1 100 10
1 2
1 3
2 4
3 4
4
8 8
10 20 1 5 8 7 1 43
1 2
1 3
2 4
2 5
3 6
5 7
6 7
7 8
7

실행결과

120
39

⌨️ 문제 풀이

문제를 요약해보자면, 아래와 같다.
- 각 테스트 케이스마다 건물을 지을 수 있는 순서는 다르다.
- 백준이가 이기기 위해서는 특정 건물을 지어야 승리가 가능하다.
- 특정 건물을 짓기 위해서는 선행되는 건물을 지을 필요가 있다.

간단하게 정리를 해보면 우리는 건설순서가 정해져 있는 건물을 차례로 건설하면서, W번 건물을 지을 때까지의 최소 시간을 구해야한다.
이러한 문제에 사용할 수 있는 알고리즘은 위상정렬인데, 위상정렬의 개념고 위에 써놓은 것과 개념이 크게 다르지 않다.
위상정렬이란, 순서가 정해져있는 작업을 차례로 수행해야할 때 그 순서를 결정해주기 위해서 사용하는 알고리즘이다.

건물의 개수 N과 건물간의 건설순서 규칙의 총 개수 K 를 입력받아, 위상정렬 알고리즘에 필요한 indegree 리스트를 n + 1 개 만들어준다.
또한 N + 1개의 노드를 가진 그래프도 생성한다.
각 건물을 건설하는데에 필요한 시간을 입력받은 후, 건설순서를 입력받아 그래프에 입력한다.
만약 a, b를 입력 받았다면, graph[a].append(b) 이며 indegree[b] += 1 이다.
b 건물을 건설하기 위해서는 a 건물을 건설해야한다는 뜻이기 때문에 +1 이 되는 것이다.

이후, W 를 입력받아 위상정렬 알고리즘의 로직이 있는 topology_sort() 함수에 W를 넘겨준다.
위상정렬 알고리즘에서는, indegree 리스트에서의 값이 0인 것을 q에 먼저 넣고 처리를 한다.
indegree 리스트에서의 값은 해당 건물이 지어지기 위해서는 먼저 지어져야할 건물이 있다는 것을 의미하기 때문이다.

위상정렬 함수에서는 DP 리스트를 만들어 사용자가 어떤 건물을 지었을 때의 소요시간을 체크한다.
큐에서 뺀 건물 번호(now) 를 기준으로 그래프를 따라 순회하면서, 순회하는 건물의 번호(node)에 해당하는 indegree의 값을 1씩 빼준다.
그리고 DP[node] 에 해당하는 값을 DP[now] + 건설에 필요한 시간[node] 값과 비교해 가장 큰 값으로 갱신한다.

이후, indegree[node] 의 값이 0 이라면 queue에 추가하고 반복한다.
queue 가 모두 빌 때까지 순회를 마쳤다면, DP[W] 의 값을 반환하고 출력한다.
DP[W]의 값은 W 번 건물이 지어지는 최소 시간을 의미한다.

배운점

위상정렬이란, 순서가 정해져있는 작업을 차례로 수행해야할 때 그 순서를 결정해주기 위해서 사용하는 알고리즘.
이를 어떻게 사용하고, 응용해야할지 더 연습이 필요할 것 같다. 복잡해보이지만, 개념과 필요한 상황을 잘 이해한다면
충분히 잘 사용할 수 있을 것 같은 느낌이다.

[백준] 17086 아기 상어 2 with Python

형준_It's — Sun, 17 Jul 2022 22:03:22 +0900

BOJ 17086 아기 상어 2

조건

N×M 크기의 공간에 아기 상어 여러 마리가 있다. 공간은 1×1 크기의 정사각형 칸으로 나누어져 있다. 한 칸에는 아기 상어가 최대 1마리 존재한다.
N과 M(2 ≤ N, M ≤ 50)

어떤 칸의 안전 거리는 그 칸과 가장 거리가 가까운 아기 상어와의 거리이다.
두 칸의 거리는 하나의 칸에서 다른 칸으로 가기 위해서 지나야 하는 칸의 수이고, 이동은 인접한 8방향(대각선 포함)이 가능하다.

0은 빈 칸, 1은 아기 상어가 있는 칸이다.

빈 칸과 상어의 수가 각각 한 개 이상인 입력만 주어진다.

안전 거리가 가장 큰 칸을 구하는 문제.

heapq, 우선순위 큐 유형의 문제

소스 코드

from sys import stdin
import heapq

n, m = map(int, stdin.readline().split())
arr, shark = [], []
dx, dy = [1, 0, 0, -1, 1, -1, 1, -1], [0, 1, -1, 0, 1, -1, -1, 1]
ans = -1

for i in range(n):
    data = list(map(int, stdin.readline().split()))
    arr.append(data)
    for j in range(m):
        if data[j] == 1:
            shark.append((i, j))


def solve(x, y):
    q = []
    heapq.heappush(q, (0, x, y))
    visited = set()
    visited.add((x, y))

    while q:
        dist, x, y = heapq.heappop(q)
        if arr[x][y] == 1:
            return dist

        for i in range(8):
            nx, ny = dx[i] + x, dy[i] + y
            if 0 <= nx < n and 0 <= ny < m:
                if (nx, ny) not in visited:
                    heapq.heappush(q, (dist + 1, nx, ny))
                    visited.add((nx, ny))


for i in range(n):
    for j in range(m):
        if arr[i][j] == 0:
            res = solve(i, j)
            if res > ans:
                ans = res

print(ans)

예제 및 실행결과

예제 1

실행결과 1

예제 2

실행결과 2

⌨️ 문제 풀이

문제에서 보면, N과 M이 각각 최대 50이기 때문에 최대 50 * 50 짜리 2차원 배열을 사용할 수 있다.

1은 아기 상어이며, 0은 안전한 칸이다. 이 문제의 핵심은 우선순위 큐를 사용하는 것인데, 우선순위 큐란 무엇인가?
우선순위 큐는 먼저 들어오는 데이터가 아니라, 우선순위가 높은 데이터가 먼저 나가는 형태의 자료구조이다.

안전거리의 값을 우선순위로 두어 큐에 저장하면서 8 방향으로, 방문하지 않은 칸을 큐에 넣어준다.
파이썬의 heapq 에서는 최소 힙(Min Heap)의 형태로 데이터를 저장한다.
최소 힙의 루드 노드는 모든 노드보다 작은 값을 가지고 있다.

ans 의 값을 -1로 초기화하고, board를 한칸씩 순회하면서 0인 경우에 solve() 함수에 좌표값을 넘겨준다.
solve() 함수에서는 heapq 를 사용해 BFS를 수행하면서, 8 방향을 탐색한다.
안전거리는 어떤 칸의 안전 거리는 그 칸과 가장 거리가 가까운 아기 상어와의 거리 이다.

(4)번처럼 탐색을 하면 가장 가까운 아기 상어의 칸을 탐색할 수 있으며, 힙 큐에서 뽑은 좌표의 값이 아기 상어일 경우, dist를 반환한다.

반환된 dist를 ans와 비교해 더 큰 값으로 갱신한 후, board 를 모두 순회했다면 ans를 출력한다.

배운점

BFS 알고리즘을 Heapq를 사용해 8방향으로 탐색하고 결과를 도출하는 것에 대해 좋은 경험을 쌓을 수 있는 문제였던 것 같다.

그래프의 개념과 표현

형준_It's — Sun, 17 Jul 2022 18:51:42 +0900

그래프의 개념과 표현

그래프 소개

그래프(Graph)란?
1. 연결되어 있는 객체 간의 관계를 표현하는 자료구조
  - 지하철 노선도, SNS 친구 관계, 컴퓨터 네트워크

그래프 데이터 타입

그래프 G의 두가지 구성요소
1. V(G) : G에 포함된 Vertex(정점)들의 집합
2. E(G) : G에 포함된 Edge(간선)들의 집합

무방향성 그래프(Undirected Graph)
1. Vertex 의 쌍을 나타내는 Edge가 방향성이 없다.
2. (u, v), (v, u) 는 동일한 Edge 를 표현하는 것이다.
  EX) 지하철 노선도

방향성 그래프(Directed Graph)
1. 각 Edge에 방향성이 존재하는 그래프
2. (u, v) : v -> v 인 Edge를 표현하는 것이다.
  u : Tail
  v : Head

그래프에서 사용되는 용어들 - 1

완전 그래프(Complete Graph)
1. Edge의 수가 최대인 그래프
2. Vertex 의 개수가 N개 일 때, 최대 엣지 수는 N(N - 1)/2 개이다.
  각 정점마다 나머지 모든 노드들에 대해 방향성 엣지를 가질 수 있다.

부분 그래프(Sub Graph)
1. V(G') <= V(G) and E(G') <= E(G) 일 경우,
  G' 은 G의 부분그래프이다.

Vertex u 에서 v 까지의 경로(Path)
* path : Edge를 몇 개나 거쳐갔는가?
1. 그래프의 Edge를 통해 두 정점을 연결하는 경로이다.
  1에서 3으로 가는 경로는 다음과 같다.
  (1,3), (1,0,3), (1,0,2,3) ...

경로의 길이는 경로 상에 있는 Edge의 수 와 같다.

단순 경로(Simple Path)
1. 처음과 마지막을 제외한 Vertex가 다른 경로

사이클(Cycle)
1. 처음과 마지막이 동일한 단순경로

그래프에서 사용되는 용어들 - 2

연결(Connected)
1. Vertex u 와 v 사이에 경로가 존재할 경우, u와 v는 연결되어 있다고 한다.
2. 방향성 그래프로 연결되어 있다면, "Strongly Connected"

연결 요소(Connected Component)
1. Maximal Connected Subgraph
2. 방향성 그래프로 연결되어 있다면 "Strongly Connected Component"

트리(Tree) = Connected Acyclic Graph
- 그래프 중, 싸이클이 없는 그래프를 말한다.

Vertex v의 차수(Degree)
1. v 에 연결된 Edge의 수
2. 방향성 그래프
  - in-degree : v 가 head가 되는 edge의 수
  - out-degree : v 가 tail이 되는 edge의 수

그래프의 표현

두가지의 표현이 있다.
1. 인접 행렬(Adjacency Matrix)
2. 인접 리스트(Adjacency List)
  - 각 edge를 표현하는 방법에 따라서 구분된다.

인접 행렬(Adjacency Matrix)

2차원 행렬로 그래프를 표현
1. 정점이 N개일 경우 : A[N][N]
  - (u, v)가 edge 목록에 있다면, A[u][v] = 1
  - (u, v)가 edge 목록에 없다면, A[u][v] = 0
2. 무방향성 그래프 : A[][] 는 대칭 행렬
  A[n(n - 1)/2]로 구현가능
3. 방향성 그래프 : A[][] 는 비대칭 행렬

인접 리스트(Adjacency List)

인접 행렬의 N행들을 N개의 연결 리스트로 표현한다.
- 즉, 그래프 G의 각 Vertex에 대해 한 개의 연결 리스트가 존재하는 것이다.

그래프 표현 방법들의 분석

G에 존재하는 Edge 의 수 혹은 G가 연결되었는지 검사한다.
1. 인접 행렬 : n(n-1)/2 개의 항을 조사한다.
  O(n^2)
2. 인접 리스트 : O(N + E)
  전체 Vertex 수 : N
  Edge 수 : e
  1. Good if e << n^2/2 (Sparse Graphs)
    희소 그래프 : Edge가 매우 적은 그래프

Digraph 에서 Vertex의 in-degree를 조사
1. 인접 행렬 : O(N)
2. 인접 리스트 : O(N + E)
  - 역인접 리스트(Inverse Adjacency List) 를 별도로 유지한다.
    역인접 리스트 : 들어오는 Edge에 대한 것만 표현한 리스트

이진 검색 트리

형준_It's — Sun, 17 Jul 2022 16:46:39 +0900

이진 검색 트리

이진 검색 트리(Binary Search Trees)

히프의 문제점
1. 임의의 데이터를 갖는 노드를 삭제할 경우의 시간 복잡도 : O(N)
2. 트리에서 특정 데이터를 갖는 노드를 검색하는 시간 복잡도 : O(N)

이진 검색 트리란?
1. 트리 내에서 특정 데이터(Key 값) 을 갖는 노드를 효율적으로 검색
  - O(Log N), 하지만 정렬된 상태를 유지해야한다.

이진 검색 트리의 정의
1. 모든 노드는 유일한 키 값을 가지고 있다.
2. 왼쪽 서브 트리에 저장된 키 값 < 루트 노드의 키 값
3. 오른쪽 서브 트리에 저장된 키 값 > 루트 노드의 키 값
4. 양쪽 서브 트리도 이진 검색 트리이다.

검색 연산

기본 개념
1. if(key == root -> data) return
2. if(key < root -> data) search(root -> left_child)
3. if(key > root -> data) search(root -> right_child)
4. 순환 알고리즘 혹은 반복문을 이용하여 구현한다.
  - 시간 복잡도는 O(트리의 Depth)

이진 검색 트리에 노드 추가

기본 개념
1. 추가할 키 값이 이미 트리에 존재하는지 확인한다.
  - 트리의 유일성을 보장한다.
2. 검색 알고리즘 수행 후, 알고리즘이 종료되는 곳에 새로운 노드를 추가한다.

modified_search(root, key)
1. key 가 존재할 경우, return NULL
2. 검색 알고리즘에서 방문한 마지막 노드에 대한 Pointer return
3. 검색 성능은 O(Log N) 이 보장되는 것이 장점이다.

이진 검색트리에서 노드 삭제

중위 순회를 이용하면, 오름차순으로 출력이 가능하다.

리프 노드 삭제
1. parent -> left_child = NULL

child 가 하나밖에 없는 노드의 삭제
1. 삭제된 자리에 child node 를 위치하게 한다.

두개의 children 을 갖는 노드를 삭제
1. 왼쪽 서브트리에서 가장 큰 노드
  or
2. 오른쪽 서브트리에서 가장 작은 노드를 삭제된 자리에 위치 시킨다.

이진 검색 트리의 깊이

데이터가 정렬된 순서로 입력 : O(N)
- 1,2,3,4 : 편향 이진 트리
데이터가 무작위 순서로 입력 : O(Log N)
균형 이진 검색 트리 : AVL Tree, Red-Black Tree
- 정렬된 데이터가 들어와도 O(Log N)을 보장한다.

히프의 개념과 응용

형준_It's — Sun, 17 Jul 2022 03:18:16 +0900

히프의 개념과 응용

히프(Heap)의 정의

최대 트리와 최대 히프
1. 최대 트리(Max Tree)
  1. 트리의 모든 노드에 대해서 노드의 데이터 값이 자식 노드의 데이터 값보다 크거나 같은 트리
2. 최대 히프(Max Heap)
  1. 최대트리 이면서, 완전 이진트리.

최소 트리와 최소 히프
1. 최소 트리(Min Tree)
  1. 트리의 모든 노드에 대해서 노드의 데이터 값이 자식 노드의 데이터 값다 작거나 같은 트리
2. 최소 히프(Min Heap)
  1. 최소트리 이면서, 완전 이진트리.

최대 히프의 root 노드는 항상 모든 노드들보다 큰 값을 가지고 있다.
최소 히프의 root 노드는 항상 모든 노드들보다 작은 값을 가지고 있다.

이는 가장 큰 값과 가장 작은 값을 찾기 쉬운 자료구조이다.

우선 순위 큐(Priority Queue)

우선 순위 큐의 특징
1. 일반적인 큐의 특징인 선입 선출 방식이 아닌, 우선 순위의 순서대로 처리되는 큐이다.
  - 비행기 탑승 대기, OS의 작업스케쥴링 등
2. 우선 순위 큐의 구현 방법 비교

최대 히프에 노드를 추가

시간복잡도 : O(Log N)
최대 히프를 배열로 구현하는 이유
1. 배열의 끝에 노드를 추가한다.
2. 추가된 위치의 부모노드부터 루트노드까지 기존 노드들의 데이터와 비교하면서 최대 히프를 재구성한다.
  - [i]에 저장된 노드의 부모노드의 위치 : i // 2
- Depth 가 중요하게 된다.
- Depth 가 K 인 트리에서 노드 수는 2 ** K - 1개 이다.

최대 히프에서 노드를 삭제

개념
1. 히프에서의 노드 삭제는 항상 루트 노드에서만 발생한다.
2. 루트 노드를 삭제한 후, 히프를 재구성한다.

최소 히프를 재구성하는 방법
1. 루트 노드를 삭제한 후, 마지막 노드를 루트로 변경한다.
  - 일단 루트로 올리고, 값을 비교하면서 그 값을 교체하는 방식.
  - 마지막 노드의 값이 아닌 다른 값이 들어가면 이진트리가 아니게 되는 수가 있다.
2. 루트 노드부터 아래로 순회하면서 노드의 값을 비교하며 히프를 재구성한다.

스레드 이진트리

형준_It's — Sun, 17 Jul 2022 02:41:07 +0900

스레드 이진트리

스레드 이진트리(Threaded Binary Tree)

스레드 이진트리의 기본 개념
1. n개의 노드를 갖는 이진 트리에는 2n 개의 링크가 존재한다.
2. 2n 개의 링크 중에 n+1 개의 링크 값은 null이다.
3. null 링크를 다른 노드에 대한 pointer 로 대체한다. (= Threads)
4. 니는 루트를 제외한 모든 노드는 부모 노드가 있기 때문에 트리의 링크 수는 n-1 개이다.
스레드의 이용
1. ptr -> left_child = NULL 일 경우, ptr -> left_child 를 ptr의 중위행선자를 가리키도록 변경한다.
  - 중위행선자(inorder predecessor) : 중위 순회에서 현재 노드 바로 앞에 나오는 노드
2. ptr -> right_child = NULL 일 경우, ptr -> right_child 를 ptr의 중위후속자를 가리키도록 변경한다.
  - 중위후속자(inorder successor) : 중위 순회에서 현재 노드 바로 뒤에 나오는 노드
3. 노드의 구조

struct thread_tree{
        short int left_thread; # True or False
        struct thread_tree *left_child; # left_child = true : 스레드
                                        # left_child = false : 왼쪽 자식 노드
        char data;
        struct thread_tree *right_child; # right_thread 에 따라 결정된다.
        short int right_thread; # true or false
   }

헤드노드(Head Node)

헤드노드의 역할
1. 가장 왼쪽 노드의 Inorder predecessor
2. 가장 오른쪽 노드의 Inorder successor

스레드를 이용한 중위순회

ptr이 현재 노드를 가리킨다고 가정한다.

   # 중위순회에서 ptr 다음 노드 = ptr -> right_child
   if ptr -> right_thread == TRUE
   
   otherwise
   # ptr 의 right_child 로 이동한 후, left_child 를 따라 내려간다.
   # >> left_thread == TRUE 인 노드를 만날 때까지 내려간다.

중위 후속자 발견 알고리즘(insucc)

   struct thread_tree *insucc(struct thread_tree *ptr){
        # 스레드 이진 트리에서 ptr이 가리키는 노드의 inorder success를 반환
        struct thread_tree *temp = ptr -> right_child;
        
        # right_child 가 자식 노드
        if (!ptr -> right_child){
   
            # 왼쪽 끝에 도달할 때까지 반복한다.
            while(!temp -> left_child){
                temp = temp -> left_child;
            }
        }
        return temp;
   }

중위 순회 알고리즘(tinorder)

   void tinorder(struct thread_tree *tree){
        // 스레드 이진트리를 중위순회, 헤드 노드부터 시작한다.
        struct thread_tree *temp = tree;

        for(;;){
            temp = insucc(temp);
            if(temp==tree){
                break;
            }
            printf("%3c", temp -> data);
        }
   }

스레드 이진트리에서 노드를 추가

문제 정의
1. 새로운 노드를 parent 노드의 right_child 로 추가한다.
2. parent -> right_thread 의 값이 true 인 경우
3. parent -> right_thread 의 값이 false 인 경우

[백준] 14495 피보나치 비스무리한 수열 with Python

형준_It's — Sun, 17 Jul 2022 01:39:51 +0900

BOJ 14495 피보나치 비스무리한 수열

조건

피보나치 비스무리한 수열은 f(n) = f(n-1) + f(n-3)인 수열이다.
f(1) = f(2) = f(3) = 1이며 피보나치 비스무리한 수열을 나열하면 다음과 같다.

자연수 n을 입력받아 n번째 피보나치 비스무리한 수열을 구하는 문제.

자연수 n의 범위는 (1 ≤ n ≤ 116) 이다.

DP 유형의 문제

소스 코드

from sys import stdin

dp = [0 for _ in range(120)]
dp[0:3] = [1, 1, 1, 2]

for x in range(4, 117):
    dp[x] = (dp[x - 3] + dp[x - 1])

print(dp[int(stdin.readline()) - 1])

예제 및 실행결과

예제

실행결과

⌨️ 문제 풀이

문제에 점화식이 주어졌다.

[백준] 10159 저울 with Python

형준_It's — Sun, 17 Jul 2022 01:25:55 +0900

BOJ 10159 저울

조건

무게가 서로 다른 N 개의 물건이 있다. 각 물건은 1부터 N 까지 번호가 매겨져 있다.
우리는 일부 물건 쌍에 대해서 양팔 저울로 어떤 것이 무거운 것인지를 측정한 결과표를 가지고 있다.
이 결과표로부터 직접 측정하지 않은 물건 쌍의 비교 결과를 알아낼 수도 있고 알아내지 못할 수도 있다.
예를 들어, 총 6개의 물건이 있고, 다음 5개의 비교 결과가 주어졌다고 가정하자. ([1]은 1번 물건의 무게를 의미한다.)
[1]>[2], [2]>[3], [3]>[4], [5]>[4], [6]>[5]

우리는 [2]>[3], [3]>[4]로부터 [2]>[4]라는 것을 알 수 있다.
하지만, 물건 2와 물건 6을 비교하는 경우, 앞서의 결과만으로는 어느 것이 무거운지 알 수 없다.
이와 같이, 물건 2는 물건 1, 3, 4와의 비교 결과는 알 수 있지만, 물건 5, 6과의 비교 결과는 알 수 없다.
물건 4는 모든 다른 물건과의 비교 결과를 알 수 있다.

비교 결과가 모순되는 입력은 없다고 가정한다. 위 예제의 기존 측정 결과에 [3]>[1]이 추가되었다고 가정하자.
이 경우 [1]>[2], [2]>[3]이므로 우리는 [1]>[3]이라는 것을 예측할 수 있는데,
이는 기존에 측정된 결과 [3]>[1]과 서로 모순이므로 이러한 입력은 가능하지 않다.

첫 줄에는 물건의 개수 N 이 주어지고, 둘째 줄에는 미리 측정된 물건 쌍의 개수 M이 주어진다.
단, 5 ≤ N ≤ 100 이고, 0 ≤ M ≤ 2,000이다. 다음 M개의 줄에 미리 측정된 비교 결과가 한 줄에 하나씩 주어진다.
각 줄에는 측정된 물건 번호를 나타내는 두 개의 정수가 공백을 사이에 두고 주어지며, 앞의 물건이 뒤의 물건보다 더 무겁다.

물건의 개수 N 과 일부 물건 쌍의 비교 결과가 주어졌을 때,
각 물건에 대해서 그 물건과의 비교 결과를 알 수 없는 물건의 개수를 출력하는 문제

플로이드 와샬 알고리즘 유형의 문제

소스 코드

from sys import stdin

n = int(stdin.readline())
m = int(stdin.readline())

arr = [[False] * (n + 1) for _ in range(n + 1)]

for _ in range(m):
    a, b = map(int, stdin.readline().split())
    arr[a][b] = True


for k in range(1, n + 1):
    for i in range(1, n + 1):
        for j in range(1, n + 1):
            if arr[i][k] and arr[k][j]:
                arr[i][j] = True

for i in range(1, n + 1):
    cnt = 0
    for j in range(1, n + 1):
        if not arr[i][j] and not arr[j][i]:
            cnt += 1
    print(cnt - 1)

예제 및 실행결과

예제

실행결과

⌨️ 문제 풀이

플로이드 와샬 알고리즘을 사용하여 푸는 문제이다. 문제를 참고해보면, N의 범위가 최대 100, M은 최대 2000 이다.
(1) 번을 다른 말로 해보자면, 노드가 최대 100개, 간선의 개수가 최대 2000개 입력을 받을 수 있다는 것이다.
플로이드 와샬의 시간복잡도는 O(N^3) 이며, 이 문제에서는 최대 100 * 100 * 100 만큼의 연산이 필요하다는 것을 알 수 있다.
물건 쌍의 비교결과를 입력받아 그래프에 입력하고, 이를 플로이드 와샬 알고리즘을 통해 서로 비교결과를 알 수 없는 것들을 출력하면 된다.

이진트리의 추가 연산

형준_It's — Fri, 15 Jul 2022 00:57:17 +0900

이진트리의 추가 연산

추가 연산의 종류
1. 이진트리의 복사
2. 이진트리가 동일한지 검사
3. 이진트리의 노드 수 계산
4. 이진트리의 단말 노드 수 계산
  이진트리의 모든 노드들을 모두 한번씩 다 방문해야 한다.

트리의 모든 노드들을 방문할 필요성
1. 이진트리의 순회 알고리즘 등을 응용한다.

이진트리의 복사

문제 설명
1. 입력 이진트리의 노드 구조와 동일한 새로운 이진트리를 생성하고 루트 노드의 주소 반환
2. 후위순회 알고리즘을 사용한다.

이진트리의 복사 알고리즘

struct node *copy(struct node *original){
    # original 트리를 복사한 새로운 이진트리를 반환한다.
    struct node *temp;

    if(original != NULL){
        temp = (struct node *) malloc(sizeof(struct node));
        temp -> left_child = copy(original -> left_child);
        temp -> right_child = copy(original -> right_child);
        temp -> data = original -> data;
        return temp;
    }
    return NULL;
}

이진 트리의 동일성 검사

문제 설명
1. 두 개의 이진 트리가 동일한 데이터와 동일한 구조를 갖는지 검사한다.
2. 여기서 구조란 부모-자식, 형제 노드 등을 말한다.
3. 전위 순회 알고리즘을 응용한다.

이진 트리의 동일성 검사 알고리즘

int queal(struct node *first, struct node *second){
    # first 와 second 트리가 다를 경우 False, 트리가 동일할 경우 True 를 반환한다.
    return (
        (!first && !second)                                         # 1 
            || (first && second && (first -> data == second -> first) # 2 
                && equal(first -> left_child, second -> left_child) 
                && qeual(first -> right_child, second -> right_child))); # 3
}

#1 : first 와 second가 둘 다 NULL 일 경우 True
#2 : first 와 second가 둘 다 NULL 이 아니고, 각 노드의 데이터가 같다면?
#3 : 노드의 왼쪽 자식, 오른쪽 자식이 같다면 재귀 호출

이진트리의 노드 수 계산

접근 방법
1. 루트 노드가 NULL dlaus 0 반환
2. NULL 이 아니면 1 + 왼쪽 서브트리의 노드 수 + 오른쪽 서브트리의 노드 수 를 반환
  1. 서브트리의 노드 수 는 순환 알고리즘으로 구할 수 있다.
```
int get_node_cnt(struct node *ptr){
   int cnt = 0;
   if(ptr != NULL){
       cnt = 1 + get_node_cnt(ptr -> left_child) + get_node_cnt(ptr -> right_child);
   }
   return cnt
}
```

이진트리의 단말 노드 수 계산

접근 방법
1. 루트 노드가 NULL 이면 0을 반환
2. 단말 노드이면 1 반환
3. 자식이 있을 경우, 왼쪽 서브트리의 단말 노드 수 + 오른쪽 서브트리의 단말 노드 수 를 반환한다.
  1. 서브트리의 단말 노드 수는 순환알고리즘으로 구할 수 있다.

이진트리의 단말 노드 수 계산 알고리즘

int get_leaf_cnt(struct node *ptr){
    int cnt = 0;
    if (ptr != NULL){
        if(ptr -> left_child == NULL && ptr -> right_child == NULL){
            return 1;
        } 
    }
    else{
        cnt = get_leaf_cnt(ptr -> left_child) + get_leaf_cnt(ptr -> right_child);
    }
    return cnt;
}