정리와 기록의 습관화

[백준] 3980 : 선발 명단

bconfiden2 — Thu, 29 Jul 2021 12:14:48 +0900

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

3980번: 선발 명단

각각의 테스트 케이스에 대해서, 모든 포지션의 선수를 채웠을 때, 능력치의 합의 최댓값을 출력한다. 항상 하나 이상의 올바른 라인업을 만들 수 있다.

www.acmicpc.net

선수는 11명 고정이지만, 하나의 포지션당 최대 5명 선수들까지밖에 들어가지 않는다.
따라서 가능한 경우의 수는 5^6 * 5! 가지가 되므로, 모든 경우의 수를 탐색하더라도 시간이 충분하다.
하나의 테스트케이스를 수행하기 위해 선수들을 백트래킹을 통해 각 포지션별로 뽑아주고, 테케마다 정답을 초기화시켜줘야 다음 테케에 영향을 미치지 않는다.

C = int(input())
answer = 0

# idx 번째 포지션에 적합한 선수를 고르고, 다음 포지션을 재귀적으로 탐색
def select(idx, mat, pos, visit, value):
    # 모든 선수들을 다 고를 수 있는 경우에만 최대값 갱신
    if idx == 11:
        global answer
        if value > answer:
            answer = value
        return
    # 해당 포지션에 적합한 모든 선수들을 탐색하는데
    for candidate in pos[idx]:
        # 이미 앞에서 다른 포지션에 선택된 선수는 제외시키고
        if visit[candidate]: continue
        visit[candidate] = True
        # value 에 해당 선수의 해당 포지션 능력치를 더해주면서 다음 포지션 재귀호출
        select(idx+1, mat, pos, visit, value+mat[candidate][idx])
        visit[candidate] = False

# 각 테스트케이스에 대해
for _ in range(C):
    mat = [list(map(int, input().split())) for r in range(11)]
    # 각 포지션에 적합한 선수들의 목록을 관리(0번 포지션에 적합한 선수들, ...)
    pos = [[] for i in range(11)]
    for i, player in enumerate(mat):
        for idx, val in enumerate(player):
            if val != 0:
                pos[idx].append(i)
    # 포지션을 차례대로 선택해나가는 백트래킹 과정
    select(0, mat, pos, [False for i in range(11)], 0)
    print(answer)
    # 테케가 여러개이기 때문에 정답 값 초기화 필요
    answer = 0

[백준] 3151 : 합이 0

bconfiden2 — Wed, 28 Jul 2021 10:44:58 +0900

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

3151번: 합이 0

Elly는 예상치 못하게 프로그래밍 대회를 준비하는 학생들을 가르칠 위기에 처했다. 대회는 정확히 3명으로 구성된 팀만 참가가 가능하다. 그러나 그녀가 가르칠 학생들에게는 큰 문제가 있었다.

www.acmicpc.net

중복되지 않게 3명을 뽑아서 0 을 맞춰야 하는 문제이므로, 2명의 값이 정해지면 3번째 값은 자동으로 정해진다.
2명의 값을 정하기 위해 N * N 번 탐색을 하게 되면, 3번째 값을 찾기 위해선 이분탐색이더라도 logN 번이 필요하다.
그러나 투 포인터를 활용하면 N * N * logN 보다 더 빠른, N * N 으로 끝낼 수 있다.
첫번째 사람의 값을 고정해놓고(N), 나머지 두 학생의 값을 양쪽에 포인터를 두고 0 에 수렴하도록 옮겨주면 N 번이 걸린다.
이 때 값은 같더라도 다른 사람일 경우에 대해서는 세심한 예외처리가 필요하다.

N = int(input())
st = sorted(list(map(int, input().split())))
answer = 0

# 첫번째 수를 고정적으로 뽑아놓고 나머지 두 수 결정
for idx in range(N-2):
    # 두 수를 결정하기 위해 투 포인터를 써서 앞뒤로 범위를 줄여 O(N) 에 탐색
    target, l, r = -st[idx], idx + 1, N-1
    while l < r:
        cur = st[l] + st[r]
        # 만약 두 수가 우리가 원하던 값이라면
        if cur == target:
            curl, curr = st[l], st[r]
            # 그리고 두 수가 같은 수라면 그 수들로부터 2개를 뽑는 경우의 수만큼 팀 구성 가능(정렬되어있기 때문)
            if curl == curr:
                # 조합 계산식
                answer += (r-l+1)*(r-l)//2
                break
            # 두 수가 다른 수라면, 왼쪽포인터가 가리키는 수의 갯수 * 오른쪽포인터가 가리키는 수의 갯수
            else:
                dl, dr = 0, 0
                # 왼쪽 수의 개수를 구함
                while st[l] == curl:
                    dl += 1
                    l += 1
                # 오른쪽 수의 개수
                while st[r] == curr:
                    dr += 1
                    r -= 1
                answer += dl * dr
        elif cur < target:
            l += 1
        elif cur > target:
            r -= 1
print(answer)

[백준] 20208 : 진우의 민트초코우유

bconfiden2 — Tue, 27 Jul 2021 16:15:20 +0900

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

20208번: 진우의 민트초코우유

첫번째 줄에 민초마을의 크기인 N과 진우의 초기체력 M, 그리고 민트초코우유를 마실때 마다 증가하는 체력의 양 H가 공백을 두고 주어진다. N, M, H는 모두 10보다 작거나 같은 자연수이다. 두번째

www.acmicpc.net

민트초코우유를 몇개 마실 수 있냐에 대한 문제이고, 맵은 민트초코를 마시러 가기 위한 길일 뿐이다.
따라서 우유를 노드들로 보고, 우유 사이의 거리를 각 에지의 거리라고 볼 수 있다.
어떤 우유를 마시러 갈 때 마다 현재 위치에서 소모되는 체력을 고려하여 마실 수 있는 모든 우유를 검사한다.
다음 우유를 마시러 간 이후에, 마시러 갈 수 있는 또다른 모든 우유들을 재귀적으로 검사할 수 있다.
각 우유를 마시러 갈 때마다 시작 지점으로 돌아갈 수 있는지 검사하면서 마실 수 있는 우유의 최대값을 갱신한다.
또한 한 번 마시고 나면 또 마실 수 없기 때문에, 다음에 선택할 수 있는 우유들이 줄어들게 되어 최대 10! 개이다.
모든 우유를 다 마신 경우에는 남은 우유가 없기 때문에 자연스럽게 재귀호출되지 않는다.

N, M, H = map(int, input().split())
start = (0,0)
mcm = []

# 민트초코우유들의 위치를 리스트로 관리
for r in range(N):
    line = list(map(int, input().split()))
    for c, w in enumerate(line):
        if w == 2:
            mcm.append((r,c))
        if w == 1:
            start = (r,c)

L = len(mcm)
# 민초우유들 간의 거리를 미리 2차원배열로 구해놓음(시작 지점도 포함)
distance = [[abs(n1[0]-n2[0])+abs(n1[1]-n2[1]) for n2 in mcm+[start]] for n1 in mcm+[start]]
# 백트래킹 시 사용해줄 방문여부에 대한 배열
visited = [False for i in range(L)]
answer = 0

# 백트래킹으로 가능한 민초 방문들 탐색(최대 10개로 10 팩토리얼)
def select(num, cur, health):
    global answer
    # 만약 현재 위치에서 시작 지점으로 돌아갈 수 있으면, 최대값 갱신
    if num > answer:
        if health >= distance[cur][L]:
            answer = num
    for i in range(L):
        # 마시지 않은 민초우유들 중에서 하나를 골라 마시러 출발할건데
        if not visited[i]:
            # 해당 위치까지 체력이 뒷받침될 경우에만 마시러 감
            if health >= distance[cur][i]:
                visited[i] = True
                # 마시러 갔다고 재귀적으로 처리
                select(num+1, i, health+H-distance[cur][i])
                visited[i] = False

select(0, L, M)
print(answer)

[백준] 2342 : Dance Dance Revolution

bconfiden2 — Sun, 25 Jul 2021 12:29:58 +0900

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

2342번: Dance Dance Revolution

입력은 지시 사항으로 이루어진다. 각각의 지시 사항은 하나의 수열로 이루어진다. 각각의 수열은 1, 2, 3, 4의 숫자들로 이루어지고, 이 숫자들은 각각의 방향을 나타낸다. 그리고 0은 수열의 마

www.acmicpc.net

눌러야 할 발판의 개수가 최대 10만개이기 때문에 완전 탐색 등으로는 절대 불가능하다.
DP 배열을 [i번째발판눌렀을때][왼발위치][오른발위치] 의 최소값을 갖는 3차원 배열로 설정한다면, 각 단계마다의 최소값을 구해나갈 수 있다.
이전 단계에서 눌릴 수 없는 (왼발, 오른발) 위치에 대해서는 검사하지 않는다.
또한 발을 눌렀을 때 양발이 같은 위치에 있는 경우도 검사하지 않는다.
i-1 번째의 모든 (왼발,오른발) 쌍에 대해서, i 번째의 (다음발,오른발) 과, i 번째의 (왼발,다음발) 의 경우를 고려해준다.

arr = list(map(int, input().split()))[:-1]

# DP 배열은 [i번째][왼발][오른발] 일 때 드는 힘의 최소 크기
dp = [[[[] for c in range(5)] for r in range(5)] for i in range(len(arr)+1)]

# 커맨드 상 존재할 수 없는 위치는 -1 로 초기화
for lft in range(5):
        for rgt in range(5):
            dp[0][lft][rgt] = -1
# 0번째 커맨드(시작 전)에서는 시작위치가 왼발 0 오른발 0 이므로 드는 힘을 0 으로 초기화
dp[0][0][0] = 0

# 발의 이전 위치와 움직일 위치가 주어졌을 때 추가되는 힘을 구해주는 함수
def p(pair):
    if pair[0] == pair[1]:
        return 1
    if 0 in pair:
        return 2
    if pair in ((1,3),(3,1),(2,4),(4,2)):
        return 4
    else:
        return 3

# 각 커맨드마다 가능한 발의 위치쌍에 대해 최소값 검사
for idx, cur in enumerate(arr):
    for lft in range(5):
        for rgt in range(5):
            # 불가능한 발들은 확인하지 않음
            if dp[idx][lft][rgt] == -1:
                continue
            # 왼쪽 발을 옮겼을 때, 오른발과 겹치지 않을 경우 다음 위치에 후보로써 추가해놓음
            if cur != rgt:
                dp[idx+1][cur][rgt].append(dp[idx][lft][rgt] + p((lft, cur)))
            # 오른쪽 발을 옮길 때
            if cur != lft:
                dp[idx+1][lft][cur].append(dp[idx][lft][rgt] + p((rgt, cur)))
    # 한번 돌고나면, 각 위치쌍마다 왼쪽이든 오른쪽이든 발을 옮기고 난 뒤 드는 힘들이 모여있으므로, 그 중 최소값을 선택
    for lft in range(5):
        for rgt in range(5):
            dp[idx+1][lft][rgt] = -1 if len(dp[idx+1][lft][rgt]) == 0 else min(dp[idx+1][lft][rgt])

print(min(dp[len(arr)][r][c] for r in range(5) for c in range(5) if dp[len(arr)][r][c] != -1))

[백준] 9020 : 골드바흐의 추측

bconfiden2 — Sat, 24 Jul 2021 09:09:41 +0900

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

9020번: 골드바흐의 추측

1보다 큰 자연수 중에서 1과 자기 자신을 제외한 약수가 없는 자연수를 소수라고 한다. 예를 들어, 5는 1과 5를 제외한 약수가 없기 때문에 소수이다. 하지만, 6은 6 = 2 × 3 이기 때문에 소수가 아

www.acmicpc.net

1부터 10000까지 존재하는 소수들을 에라토스테네스의 체를 사용하여 모두 구해준다. (약 1200개)
골드바흐 파티션을 정할 때, 1~10000 까지 각 짝수마다 가능한 소수 조합을 전부 돌려보기에는 10000 * 1200(소수1) * 1200(소수2) 번의 연산이 필요하므로 시간초과가 발생한다.
소수1 과 소수2 를 전부 탐색하는 과정에서, 두 소수로 짝수가 만들어지면 해당 수의 골드바흐 파티션으로 지정해준다.
소수1 이 항상 소수2 보다 작게끔 탐색을 돌린다면 여러 파티션들 중 가장 가까운 파티션이 최종적으로 할당된다.

import sys

rn = [True for i in range(10001)]
prime = []
pt = [(0,0) for i in range(20000)]

# 에라토스테네스의 체로 10000 이하의 모든 소수들 구함
for i in range(2, 10001):
    if rn[i]:
        prime.append(i)
        tmp = i + i
        while tmp <= 10000:
            rn[tmp] = False
            tmp += i

# 모든 조합을 살펴보며 골드바흐 파티션을 구함
for i1 in range(len(prime)):
    for i2 in range(i1, len(prime)):
        # 첫번째 수와 두번째 수를 뽑아 가능한 값들에 해당 쌍을 저장
        # 여러 쌍이 있을 경우 자연스럽게 뒤쪽에서 두 값이 더 가까운 쌍으로 갱신됨
        pt[prime[i1] + prime[i2]] = (prime[i1], prime[i2])

# 골드바흐 파티션을 메모이제이션 해놨으므로 답 출력
input()
for line in sys.stdin:
    line = int(line.strip())
    print(pt[line][0], pt[line][1])

[백준] 10421 : 수식 완성하기

bconfiden2 — Fri, 23 Jul 2021 10:31:33 +0900

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

10421번: 수식 완성하기

입력의 첫 번째 줄에 연산식에 있는 줄의 총 개수 N이 주어지고, 그 다음줄에는 각 줄의 별 개수를 나타내는 N개의 정수 S1, S2, S3, …, SN N이 공백으로 구분되어 주어진다. 그 다음 줄에는 사용할

www.acmicpc.net

첫번째 숫자는 최대 5자리, 두번째 숫자는 최대 3자리이고, 각 자릿수마다 가능한 값은 1~9 까지 최대 9개가 있다.
따라서 모든 숫자에 대한 경우의 수도 최대 9^8 가지가 있으므로, 전부 탐색을 해서 유효한지 검사해줄 수 있다.
각 숫자마다 백트래킹을 통해 자릿수를 하나씩 뽑아가며 모든 경우의 수를 확인한다.
21.7.23 현재 BOJ 의 입력 데이터 형식에 문제가 있다고 보여진다.
문제의 설명에서는 총 4줄에 걸쳐 값들이 들어오는데, 입력 데이터 중 그 형식을 지키지 않는 것들이 존재한다. (참고) https://www.acmicpc.net/board/view/69371
실제로 동일한 로직의 파이썬 코드를 제출할 시, input 에서 입력을 받지 못해 EOFError 가 발생한다.

#include <iostream>
#include <string>
#include <cmath>

using namespace std;

int N, K, answer, tmp;
int digits[7];
int numbers[10];

// 특정 위치의 값이 주어지면 수식을 완성시킬 수 있는 값인지 검사
bool is_valid(string tmp, int idx)
{
    // 해당 값의 자릿수가 수식의 자릿수와 같은지
    if(tmp.size() != digits[idx]) return false;
    // 해당 값이 모두 주어진 값들로만 구성이 되어있는지
    for(int i = 0 ; i < tmp.size() ; i++)
    {
        bool exist = false;
        for(int k = 0 ; k < K ; k++)
        {
            if((tmp[i]-'0')==numbers[k]) exist = true;
        }
        if(!exist) return false;
    }
    return true;
}

// 두 숫자가 주어졌을 때, 현재 수식을 만족하는지 검사
bool able(int a, int b)
{
    // 두 숫자를 곱한 정답이 유효한지
    if(!is_valid(to_string(a * b), N-1)) return false;
    // 첫번째 숫자와, 두번째 숫자의 각 자릿수들을 곱한 중간값들이 유효한지
    for(int i = 0 ; i < digits[1] ; i++)
    {
        if(!is_valid(to_string(a * (to_string(b)[i]-'0')), N-2-i)) return false;
    }
    return true;
}

// 두번째 숫자(최대 3자리) 백트래킹으로 가능한 모든 경우의 수 탐색
void selectB(int blen, int bval, int aval)
{
    // 두번째 숫자도 다 뽑았으면, 첫번째 숫자와 함께 수식을 완성시킬 수 있는지 검사
    if(blen == digits[1])
    {
        answer += able(aval, bval);
        return;
    }
    // 1의자리부터 하나씩 뽑아나감
    for(int i = 0 ; i < K ; i++)
    {
        selectB(blen+1, bval+(numbers[i])*(pow(10,blen)), aval);
    }
}

// 첫번째 숫자(최대 5자리) 백트래킹으로 가능한 모든 경우의 수 탐색
void selectA(int alen, int aval)
{
    // 첫번째 숫자를 다 뽑았으면, 두번째 숫자를 뽑기 시작
    if(alen == digits[0])  
    {
        selectB(0, 0, aval);
        return;
    }
    // 1의자리부터 하나씩 뽑아나감
    for(int i = 0 ; i < K ; i++)
    {
        selectA(alen+1, aval+(numbers[i])*(pow(10,alen)));
    }
}

int main(void)
{
    cin >> N;
    for(int i = 0 ; i < N ; i++)
    {
        cin >> tmp;
        digits[i] = tmp;
    }
    cin >> K;
    for(int i = 0 ; i < K ; i++)
    {
        cin >> tmp;
        numbers[i] = tmp;
    }

    selectA(0, 0);
    cout << answer << endl;    
}

[리눅스] 쉘 환경

bconfiden2 — Wed, 21 Jul 2021 10:00:32 +0900

쉘 세션이 진행되는 동안 쉘은 환경이라는 걸 통해 정보들을 관리한다.

대부분의 프로그램은 각자의 환경 설정 파일을 참조하지만, 일부 프로그램은 쉘의 환경 값을 찾아보기도 한다.

이를 위해서 사용자에게 맞게 환경을 설정할 수 있어야 한다.

환경에는 어떤 것들이 저장될까?

쉘은 크게 두 가지 형식을 환경에 저장하는데, 환경 변수와 쉘 변수이다.

쉘 변수는 bash 에 저장된 작은 데이터이고, 환경변수는 그 밖의 모든 것들을 지칭한다.

환경 검증하기

환경에 저장된 것들을 확인하기 위해서 set 혹은 printenv 를 사용할 수 있다.

set 은 쉘 변수와 환경 변수 모두를 보여주지만, printenv 는 환경 변수들을 보여준다.

printenv 를 사용할 경우 수많은 환경 변수들에 대한 목록이 출력되는데, 변수명=값 의 형태를 갖고 있다.

printenv 변수명 과 같이 특정 변수의 값만을 출력할 수도 있다.

set 의 경우는 쉘 변수와 환경 변수, 쉘 함수 등을 문자열 정렬하여 보여주는데, 별칭(alias) 는 출력하지 않는다.

별칭들에 대해서는 alias 명령어로 따로 확인 가능하다.

printenv
printenv USER
set
alias

아래는 대표적인 몇 가지 환경 변수들에 대한 테이블이다.

변수	설명
DISPLAY	그래픽 환경 사용자일 경우 디스플레이명
EDITOR	기본 텍스트 편집기 프로그램명
SHELL	사용자 쉘 프로그램명
HOME	홈 디렉토리 경로
LANG	사용자 언어의 문자셋과 정렬 방식
OLD_PWD	이전 작업 디렉토리
PAGER	페이지 출력에 사용되는 프로그램명
PATH	실행 프로그램을 찾는 경로 목록
PS1	프롬프트 문자열 1, 쉘 프롬프트 내용 정의
PWD	현재 작업 디렉토리
TERM	사용자 터미널 타입
TZ	사용자 시간대 설정,
USER	사용자 이름

환경은 어떻게 설정할까?

시스템에 로그인하면, 기본적인 환경 설정 값을 구성하는 시작 파일이라는 환경 설정 스크립트를 읽는다.

시작 파일은 모드 사용자에게 공유되는 파일이며, 이를 읽은 후에 개인 사용자의 환경을 정의하는 홈디렉토리 내의 시작 파일을 다시 읽는다.

홈 디렉토리에 있는 .bashrc 파일이 개인 사용자의 시작 파일이 된다.

거의 항상 참조되기 때문에 일반적으로 가장 중요한 파일이라고 생각하면 된다.

쉘 세션은 크게 로그인 쉘 세션과 비로그인 쉘 세션으로 나뉘는데, 일반적으로 GUI 환경에서 터미널을 실행할 때 나타나는 것이 비로그인 쉘 세션이다.

로그인 쉘 세션은 가상 콘솔 세션 등이 시작할 때로, 사용자의 이름과 비밀번호를 입력해야 한다.

로그인 쉘 세션용 시작 파일에는 /etc/profile 이나 홈디렉토리의 .bash_profile, .bash_login, .profile 등이 있다.

위에서 언급한 .bashrc 파일은 비로그인 쉘 세션의 시작파일이지만, 로그인 쉘용의 시작파일이 이를 참조하도록 만들어지기 때문에 중요한 것이다.

이외에도 .bash_history 에는 쉘에서 사용한 명령어들이 저장되는데, history 명령을 내릴 때 참조하는 파일이 된다.

커맨드라인에 명령을 내릴 때 쉘은 다양한 경로들로부터 실행파일을 찾아서 실행시키는 방식인데, 이 경로들의 목록을 저장해놓는 변수가 PATH 이다.

이 때 PATH 변수에 대한 설정은 /etc/profile 혹은 ./.profile 등에 존재한다.

# set PATH so it includes user's private bin if it exists
if [ -d "$HOME/bin" ] ; then
    PATH="$HOME/bin:$PATH"
fi

# set PATH so it includes user's private bin if it exists
if [ -d "$HOME/.local/bin" ] ; then
    PATH="$HOME/.local/bin:$PATH"
fi

export PATH

이는 PATH 변수의 앞부분에 ~/bin 경로와 ~/.local/bin 경로를 추가하는 코드이다.

$HOME 이나 $PATH 등을 통해 확장을 사용하는 것도 같이 확인할 수 있다.

이렇게 bin 경로들을 추가함으로써 명령어가 입력될 때 해당 경로에 있는 파일들도 같이 탐색을 하게끔 만든다.

마지막으로 export 를 통해 쉘과 자식 프로세스들에게 PATH 의 내용을 업데이트 시킨다.

[백준] 20529 : 가장 가까운 세 사람의 심리적 거리

bconfiden2 — Wed, 21 Jul 2021 09:38:44 +0900

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

20529번: 가장 가까운 세 사람의 심리적 거리

각 테스트 케이스에 대한 답을 정수 형태로 한 줄에 하나씩 출력한다.

www.acmicpc.net

사람의 수가 최대 10만명이기 때문에 모든 사람에 대해 탐색하는 것은 불가능하지만, mbti 유형은 최대 16개이기 때문에 모든 가능한 유형에 대해서 탐색하는 것은 간단하다.
완전탐색을 돌리기에 앞서, 한가지 유형이 3번 이상 중복해서 나오는 경우에 대해서는 최소 거리가 0 이 되므로 제외시킨다.
또한 각 유형별로 뽑을 때, 한가지 유형이 2번 중복해서 나오는 경우에 대해서도 고려해줘야 한다.
같은 유형을 2개 뽑고 나머지 하나의 유형을 뽑는 경우와, 세 가지를 전부 다른 유형으로 뽑을 때의 최소값을 확인해야 한다.
문제에서 예시로 들어준 3번 케이스 같은 경우 INFP 가 두 명 있음에도 불구하고 나머지 3명을 뽑는 것이 최소값이 된다.

def distance(a, b, c):
    return sum(int(a[i]!=b[i]) + int(b[i]!=c[i]) + int(c[i]!=a[i]) for i in range(4))

T = int(input())
for _ in range(T):
    N = int(input())
    # 전체 사람들 중 MBTI 유형이 몇개씩 나왔는지 확인
    mbti = {}
    for m in input().split():
        mbti[m] = mbti.get(m, 0) + 1
    answer = -1

    sets = [[],[]]
    for key, val in mbti.items():
        # 만약 같은 MBTI 인 사람이 3명 이상 있을 경우, 무조건 0 을 뽑을 수 있음
        if val >= 3:
            answer = 0
        # 그 외로는 완전탐색을 통해 가장 가까운 거리를 갖는 세 사람을 구함
        else:
            sets[val-1].append(key)
            if val == 2:
                sets[0].append(key)

    if answer == 0:
        print(answer)
    else:
        # 모든 MBTI 에 대해 유형별로 하나씩 뽑아서 가능한 최소 거리를 구함
        tmp = [distance(sets[0][a], sets[0][b], sets[0][c]) for a in range(len(sets[0])-2) for b in range(a+1, len(sets[0])-1) for c in range(b+1, len(sets[0]))]
        # 만약 같은 MBTI 를 2명 이상 갖는 그룹이 없을 경우 == 모든 사람이 다른 MBTI 를 갖고 있는 경우이므로 그대로 최소값 출력
        if len(sets[1]) == 0:
            print(min(tmp))
        # 같은 MBTI 를 갖는 그룹이 있을 경우(ex. ISTJ,ISTJ,ENTP), 해당 그룹에서 2개를 뽑고 나머지 한 유형을 뽑는 경우의 수도 같이 고려
        else:
            print(min(tmp + [distance(a, a, c) for a in sets[1] for c in sets[0] if a!= c]))

[백준] 1025 : 제곱수 찾기

bconfiden2 — Tue, 20 Jul 2021 13:40:52 +0900

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

1025번: 제곱수 찾기

첫째 줄에 세로 크기 N과 가로 크기 M이 주어진다. 둘째 줄부터 N개의 줄에 직사각형 격자판에 쓰여 있는 수가 주어진다. 모두 한자리이다. N과 M은 9보다 작거나 같은 자연수 또는 0이다.

www.acmicpc.net

풀이보다는 문제를 이해하는 것이 난해한 문제다.
주어진 수열들(행렬)에서 임의의 수들을 뽑아 만든 수 중 가장 큰 제곱수를 찾는 것인데, 수를 뽑는 기준에 조건이 걸린다.
수를 뽑는 위치에 대해서 행의 인덱스와 열의 인덱스가 등차수열을 이뤄야 한다는 점이다.
N 과 M 이 최대 9 이기 때문에, 가능한 시작지점의 개수는 9 * 9 개이고, 등차수열을 이루기 위한 차이값은 -8 ~ 8 까지 17개로 17 * 17 이며, 가능한 수열의 길이는 최대 9 개라 모든 경우의 수를 탐색해봐도 문제 없다.
각 경우의 수마다 설정된 조건에 따라 숫자를 만들어 제곱수임을 확인하는 것은 구현의 문제

n, m = map(int, input().split())
mat = [[int(c) for c in input()] for i in range(n)]
answer = -1

# 제곱수인지 확인하는 함수
def is_squared(x):
    return (int(int(x**0.5+0.1)**2) == x) if hex(x)[-1] in ('0','1','4','9') else False

# 설정한 조건에 맞게 재귀호출로 값 만들어주는 함수
def select(cur_size, target_size, r, c, dr, dc):
    value = mat[r][c]
    # 설정한 수열 크기를 채웠을 경우 마지막 자리 반환
    if cur_size == target_size:
        return value
    nr, nc = r+dr, c+dc
    # 등차수열을 이루는 다음 위치가 인덱스를 벗어날 경우 불가능
    if nr < 0 or nr >= n or nc < 0 or nc >= m:
        return 2
    # 다음 등차수열 위치로 이동
    tmp = select(cur_size+1, target_size, nr, nc, dr, dc)
    # 불가능한 수열(2) 일 경우 그대로 불가능 처리, 가능한 수열이면 문자열로 한자리씩 차근차근 쌓아서 값 완성
    return 2 if tmp == 2 else (str(value) + str(tmp))

# 완전탐색으로 만들 수 있는 모든 조합을 탐색
for size in range(1, max(n,m)+1):
    for r in range(n):
        for c in range(m):
            # 행과 열 인덱스가 등차수열을 이루기 위한 차이값들
            for dr in range(-n+1, n):
                for dc in range(-m+1, m):
                    # 수열의 길이가 1일 때는 dr과 dc가 0 이어도 상관 없음
                    if (dr != 0 or dc != 0) or size == 1:
                        # 조건에 맞는 값을 찾은 뒤
                        tmp = int(select(1, size, r, c, dr, dc))
                        # 제곱수일 경우 최대값 갱신
                        if is_squared(tmp):
                            if tmp > answer:
                                answer = tmp

# 최대값 출력
print(answer)

[백준] 16457 : 단풍잎 이야기

bconfiden2 — Mon, 19 Jul 2021 09:51:07 +0900

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

16457번: 단풍잎 이야기

첫째 줄에 키의 개수 n, 퀘스트의 개수 m, 퀘스트 당 사용해야 하는 스킬의 수 k가 주어진다. n은 10 이하, k는 n 이하의 양의 정수이며, m은 100 이하의 양의 정수이다. 둘째 줄부터 m개의 줄에는 각각

www.acmicpc.net

최대 20개의 스킬들 중 n 개를 뽑아 확인해야 하는 문제이다.
스킬을 등록한 위치가 중요한 것은 아니기 때문에, 순열이 아닌 조합으로 풀면 경우의 수가 훨씬 줄어들게 된다.
가능한 모든 조합에 대하여 해당 조합으로 몇개의 퀘스트를 수행할 수 있는지 검사하여 최대값을 구하는 완전탐색으로 푼다.

n, m, k = map(int, input().split())
skills = [tuple(map(int, input().split())) for i in range(m)]
batch = [0 for i in range(n)]
answer = 0

def pick(prev, idx):                # 2n 중 n 개를 재귀를 통해 중복 없이 뽑아 확인하는 함수(조합)
    if idx == n:                    # n 개를 다 뽑았다면 몇개의 퀘스트 수행 가능한지 확인
        tmp = set(batch)
        cnt = 0
        for sk in skills:           # 모든 요구 스킬을 확인하며
            for s in sk:            # 하나라도 사용하지 못하는 스킬이 포함되면 넘어감
                if s not in tmp:
                    break
            else:                   # 퀘스트 수행 가능시 +1
                cnt += 1
        global answer               # 최댓값 갱신
        if cnt > answer:
            answer = cnt
        return
    for i in range(prev+1, 2*n+1):  # 정렬된 순서대로 재귀 확인
        batch[idx] = i
        pick(i, idx+1)

pick(0, 0)
print(answer)