카테고리: boj

• $1000 ≤ x_1, y_1, x_2, y_2, c_y, c_x ≤ 1000$
• $1 ≤ r ≤ 1000$
• $1 ≤ n ≤ 50$
• 좌표와 반지름은 모두 정수

행성계를 꼭 통과해야 하는 조건을 먼저 찾는. 출발점이나 도착점이 행성계 안에 있을 경우 무조건 그 항성계를 통과해야 한다. 출발점이나 도착점을 포함하지 않고 있는 행성계는 어떻게든 피해갈 수 있기 때문이다.

한 점이 원 안에 포함되어있는지 확인하려면, 원의 반지름과 원의 중심과 그 점 사이의 거리를 비교하면 된다. 원의 반지름이 더 크다면 그 점은 무조건 원 안에 위치하게 되고, 원의 중심과 그 점 사이의 거리를 비교하면 그 점은 원 밖에 위치하게 된다.

t = int(input())
for _ in range(t):
    cnt = 0
    x1, y1, x2, y2 = map(int, input().split())
    n = int(input())
    for _ in range(n):
        c_x, c_y, r = map(int, input().split())
        r = r ** 2
        dis1 = (c_x - x1) ** 2 + (c_y - y1) ** 2
        dis2 = (c_x - x2) ** 2 + (c_y - y2) ** 2
        if (dis1 < r and dis2 < r) or (dis1 > r and dis2 > r):
            continue
        else:
            cnt += 1
    print(cnt)

div = list(map(int, input().split()))
min, max = float('inf'), float('-inf')
for d in div:
    if min > d : min = d
    if max < d : max = d
print(min * max)

print = sys.stdout.write

n = int(input())
cnt_list = [[] for i in range(200002)]
for _ in range(n):
    x, y = map(int, input().split())
    cnt_list[x + 100000].append(y)

for x, ys in enumerate(cnt_list):
    if ys:
        if len(ys) == 1:
            print(f"{x - 100000} {ys[0]}\n")
        else:
            for y in sorted(ys):
                print(f"{x - 100000} {y}\n")

2번 문제도 마찬가지로 진행하되 y를 기준으로 배열을 만들어 x좌표를 append해준다.

import sys
input = sys.stdin.readline
print = sys.stdout.write

n = int(input())
cnt_list = [[] for i in range(200002)]
for _ in range(n):
    x, y = map(int, input().split())
    cnt_list[y + 100000].append(x)

for y, xs in enumerate(cnt_list):
    if xs:
        if len(xs) == 1:
            print(f"{xs[0]} {y - 100000}\n")
        else:
            for x in sorted(xs):
                print(f"{x} {y - 100000}\n")

print = sys.stdout.write

n = int(input())
len_cnt = [set() for i in range(51)]
for _ in range(n):
    word = input().strip()
    len_cnt[len(word)].add(word)

for words in len_cnt:
    if words:
        if len(words) == 1:
            print(f"{list(words)[0]}\n")
        else:
            for w in sorted(list(words)):
                print(f"{w}\n")

num = input().strip()
cnt_dict = {str(n):0 for n in range(9, -1, -1)}
for i in num:
    cnt_dict[i] += 1
ans = ''
for i in cnt_dict:
    for _ in range(cnt_dict[i]):
        ans += i

print(ans)

9~0까지의 수를 key로 가지고 value가 0인 dictionary를 만들고 수가 얼마나 나왔는지 count 한다. 이후 dictionary의 key 순서대로(내림차순) count 된 수만큼 문자를 붙여가며 답을 완성한다.

print = sys.stdout.write

n = int(input())
nums = []
d = defaultdict(int)

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

for num in sorted(d):
    for _ in range(d[num]):
        print(f'{str(num)}\n')

예를 들어, A = { 1, 2, 4 } 이고, B = { 2, 3, 4, 5, 6 } 라고 할 때,  A-B = { 1 } 이고, B-A = { 3, 5, 6 } 이므로, 대칭 차집합의 원소의 개수는 1 + 3 = 4개이다.

첫째 줄에 집합 A의 원소의 개수와 집합 B의 원소의 개수가 빈 칸을 사이에 두고 주어진다. 둘째 줄에는 집합 A의 모든 원소가, 셋째 줄에는 집합 B의 모든 원소가 빈 칸을 사이에 두고 각각 주어진다. 각 집합의 원소의 개수는 200,000을 넘지 않으며, 모든 원소의 값은 100,000,000을 넘지 않는다.

첫째 줄에 대칭 차집합의 원소의 개수를 출력한다.

대칭 차집합의 정의에 따라 그대로 코드로 작성하면 되는 문제다. 대칭 차집합의 각 차집합 (A-B)와 (B-A)는 교집합이 무조건 공집합이므로 각 차집합의 원소 개수를 더하는 것으로 대칭 차집합의 원소 개수를 구할 수 있다.

input()
a = set(map(int, input().split()))
b = set(map(int, input().split()))
print(len(a - b) + len(b - a))

위 표에서 C보다 더 큰 덩치의 사람이 없으므로 C는 1등이 된다. 그리고 A, B, D 각각의 덩치보다 큰 사람은 C뿐이므로 이들은 모두 2등이 된다. 그리고 E보다 큰 덩치는 A, B, C, D 이렇게 4명이므로 E의 덩치는 5등이 된다. 위 경우에 3등과 4등은 존재하지 않는다. 여러분은 학생 N명의 몸무게와 키가 담긴 입력을 읽어서 각 사람의 덩치 등수를 계산하여 출력해야 한다.

첫 줄에는 전체 사람의 수 N이 주어진다. 그리고 이어지는 N개의 줄에는 각 사람의 몸무게와 키를 나타내는 양의 정수 x와 y가 하나의 공백을 두고 각각 나타난다.

여러분은 입력에 나열된 사람의 덩치 등수를 구해서 그 순서대로 첫 줄에 출력해야 한다. 단, 각 덩치 등수는 공백문자로 분리되어야 한다.

merge_sort(A[p..r]) { # A[p..r]을 오름차순 정렬한다.
    if (p < r) then {
        q <- ⌊(p + r) / 2⌋;       # q는 p, r의 중간 지점
        merge_sort(A, p, q);      # 전반부 정렬
        merge_sort(A, q + 1, r);  # 후반부 정렬
        merge(A, p, q, r);        # 병합
    }
}

# A[p..q]와 A[q+1..r]을 병합하여 A[p..r]을 오름차순 정렬된 상태로 만든다.
# A[p..q]와 A[q+1..r]은 이미 오름차순으로 정렬되어 있다.
merge(A[], p, q, r) {
    i <- p; j <- q + 1; t <- 1;
    while (i ≤ q and j ≤ r) {
        if (A[i] ≤ A[j])
        then tmp[t++] <- A[i++]; # tmp[t] <- A[i]; t++; i++;
        else tmp[t++] <- A[j++]; # tmp[t] <- A[j]; t++; j++;
    }
    while (i ≤ q)  # 왼쪽 배열 부분이 남은 경우
        tmp[t++] <- A[i++];
    while (j ≤ r)  # 오른쪽 배열 부분이 남은 경우
        tmp[t++] <- A[j++];
    i <- p; t <- 1;
    while (i ≤ r)  # 결과를 A[p..r]에 저장
        A[i++] <- tmp[t++];
}