Splinters of Life

Google Code Jam 2020 Qualification Round - Indicium

2020-04-04T06:50:00+00:00

올해 퀄 라운드의 마지막 문제는 라틴 스퀘어를 만드는 문제였다. 라틴 스퀘어를 만드는 것 자체는 어렵지 않은 문제이지만, 이번에는 주 대각선의 합(trace)이 특정한 값이 되어야 한다는 조건이 있어서 상당히 어려웠다.

관찰
1. N+1, N²-1
2. 그 외의 경우
라틴 스퀘어 채우기
1. 대각선 찾기
2. 다른 방법

문제 링크
라틴 스퀘어는 각 행과 열에 1..N 이 각각 한 번씩만 등장하는 N x N 행렬이다.

관찰

문제를 보고 자연스레 떠오르는 접근은 “대각선을 먼저 채운 다음 나머지 칸을 채워보자” 이다. 다만 일부가 채워져 있는 라틴 스퀘어를 완성하는 것은 일반적으로 NP-Complete¹에 속한다는 문제가 있다. 해법이 보이지 않으니 우선 Test Set 1 (2 ≤ n ≤ 5)을 해결하는 완전 탐색 코드를 작성하고 출력을 살펴보자.

N+1, N²-1

N ≥ 4일 때의 출력을 살펴보면 trace가 N+1, N²-1 인 경우를 제외하고는 모두 라틴 스퀘어가 존재함을 알 수 있다. trace = N+1 인 경우부터 살펴보면, 대각선이 다음과 같아서 마지막 행에 1을 둘 수 없으므로 완성이 불가능하다.

1
  1
   ...
      1
        2 <-- 1이 들어갈 자리는?

그리고 같은 이유로 trace = N²-1 인 경우에도 라틴 스퀘어가 존재하지 않는다.

N
  N
   ...
      N
        N-1 <-- N이 들어갈 자리는?

즉 1 ≤ x ≤ N 인 x가 대각선에 N-1번 등장할 경우 라틴 스퀘어를 완성할 수 없다.

그 외의 경우

그렇다면 나머지 경우에는 항상 라틴 스퀘어를 완성할 수 있을까? 일단 한 가지 수가 N-1번 등장하는 것은 피할 수 있다:

N+2   = 1, ..., 1, 1, 3  # x = 1, y = 3
      = 1, ..., 1, 2, 2

3N+2  = 3, ..., 3, 3, 5  # x = 3, y = 5
      = 3, ..., 3, 4, 4
      = 3, ..., 3, 2, 6

N^2-2 = N, ..., N, N,   N-2  # x = N, y = N-2
      = N, ..., N, N-1, N-1

N+1 < K < N²-1 인 K에 대해서 K = (N-1)x + y (1 ≤ x, y ≤ N, x ≠ y) 라고 하자.
조건으로부터 항상 y < N-1 이거나 x < N 임을 알 수 있고,
K = (N-3)x + (x-1) + (x-1) + (y+2) 혹은 K = (N-2)x + (x+1) + (y-1) 으로 다시 쓸 수 있다.
따라서 같은 수가 N-1번 등장하는 표현을 N-2번 등장하는 표현으로 바꿀 수 있다.

그리고 대각선 위에 같은 수가 N-1번 등장하지 않는 경우 항상 라틴 사각형을 완성할 수 있다².

물론 대회에서 선행 연구를 찾을 수 있는 것도 아니고, 이를 직접 증명하는 것은 무리이다. 실제로는 답이 존재할 경우 아래에서 설명할 알고리즘의 연산이 빠르게 완료된다는 사실을 이용, 몇 가지 크기에 대해 모든 입력을 직접 수행해보면서 확인했다.

라틴 스퀘어 채우기

라틴 스퀘어의 특징으로는 “라틴 스퀘어의 어느 두 행을 교환해도 라틴 스퀘어”라는 점이 있다. 여기서 직관적으로 라틴 스퀘어를 위에서부터 한 줄씩 만들어도 괜찮을 것이란 생각이 떠오른다³.

라틴 스퀘어의 각 행을 채우는 방법은 여러 가지가 있겠지만, 대회중에는 구현은 조금 길지만 아이디어가 간단한 이분 매칭을 이용했다. 각 열에 대해 해당하는 칸에 들어갈 수 있는 수 모두와 간선을 이어주고 이분 매칭을 수행하면 끝!

예를 들어 5 x 5 에서 trace = 7 인 경우를 살펴보자.

5 1 2 3 4  # 대각선은 5, 5, 1, 1, 1
1 5 3 4 2
2 4 1 5 3  # 여기까지 채운 상태
? ? ? 1 ?
? ? ? ? 5

위와 같이 3번째 행까지 채워져 있는 상태에서 4번째 행의 각 열을 왼쪽부터 (4,1), (4,2), … 로 표현하면 4번째 행을 채우기 위한 이분 그래프는 다음과 같이 구성된다:

(4,1)은 첫 번째 열에 1, 2, 5가 올 수 없으므로 3, 4와 연결
(4,2)는 두 번째 열에 1, 4, 5가 올 수 없으므로 2, 3과 연결
(4,3)은 세 번째 열에 1, 2, 3이 올 수 없으므로 4, 5와 연결
(4,4)는 대각선 위의 칸이므로 1과 연결
(4,5)는 다섯 번째 열에 2, 3,4가 올 수 없으며 1은 (4,4)에 들어가야 하므로 5와 연결

이렇게 만든 그래프에 이분 매칭을 수행하여 행을 완성할 수 있고, 이를 반복하면 라틴 스퀘어가 완성된다.

대각선 찾기

size = 5, trace = 7

diagonal: 1,1,1,2,2    2,2,1,1,1
  result: FAIL         SUCCESS
          1 2 3 4 5    2 1 3 4 5
          2 1 4 5 3    1 2 4 5 3
          5 4 1 3 ?    3 5 1 2 4
                2      4 3 5 1 2
                  2    5 4 2 3 1

사실 대각선을 미리 채워둔 상태에서는 단순히 위에서부터 한 행씩 그리디하게 채우는 방법으로는 채우지 못하는 경우가 존재한다. 하지만 이런 경우에도 대각선 위 원소들의 순서만 바꾸면 해결할 수 있고, 대부분의 순서에 대해서는 이 방법을 통해 문제 없이 채울 수 있으므로 대각선을 채우는 부분은 완전 탐색으로 구현했다.

코드

#include<cstdio>
#include<set>
#include<queue>
using namespace std;

int n, trace;
vector<vector<int>> square;
vector<set<int>> row_missing;
vector<set<int>> col_missing;

void print_square() {
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            printf("%d ", square[i][j]);
        }
        puts("");
    }
}

vector<vector<int>> graph;
vector<int> row_match, col_match;

bool find_match(int source)
{
    vector<int> from(row_match.size(), -1);
    int now, match;
    from[source] = source;
    queue<int> q;
    q.emplace(source);
    bool found_path = false;
    while (!found_path && !q.empty()) {
        now = q.front(); q.pop();
        for (int i: graph[now]) {
            match = i;
            int next = col_match[match];
            if (now != next) {
                if (next == -1) {
                    found_path = true;
                    break;
                }
                if (from[next] == -1) {
                    q.emplace(next);
                    from[next] = now;
                }
            }
        }
    }

    if (!found_path) return false;

    while (from[now] != now) {
        int aux = row_match[now];
        row_match[now] = match;
        col_match[match] = now;
        now = from[now];
        match = aux;
    }

    row_match[now] = match;
    col_match[match] = now;
    return true;
}

void fill_row(int i) {
    graph.clear();
    row_match.clear();
    col_match.clear();

    graph.resize(n + 10);
    row_match.resize(n + 10, -1);
    col_match.resize(n + 10, -1);

    for (int j = 1; j <= n; j++) {
        if (square[i][j]) continue;

        for (int k = 1; k <= n; k++) {
            if (!row_missing[i].count(k)) continue;
            if (!col_missing[j].count(k)) continue;

            graph[j].emplace_back(k);
        }
    }

    for (int j = 1; j <= n; j++) {
        if (square[i][j]) continue;
        if (!find_match(j)) throw 0;
    }

    for (int j = 1; j <= n; j++) {
        if (square[i][j]) continue;
        square[i][j] = row_match[j];
    }
}

bool fill_square()
{
    auto bak_square = square;
    auto bak_row_missing = row_missing;
    auto bak_col_missing = col_missing;

    try {
        for (int i = 1; i <= n; i++) {
            fill_row(i);
            for (int j = 1; j <= n; j++) {
                col_missing[j].erase(square[i][j]);
                row_missing[i].erase(square[i][j]);
            }
        }
        return true;
    } catch (...) {
        square = bak_square;
        row_missing = bak_row_missing;
        col_missing = bak_col_missing;
        return false;
    }
}

bool fill_diag(int i, int sum)
{
    if (i > n) return sum == trace && fill_square();

    for (int k = min(n, trace-sum-(n-i)); k > 0; --k) {
        if (!row_missing[i].count(k)) continue;
        if (!col_missing[i].count(k)) continue;

        int nsum = sum + k;
        row_missing[i].erase(k);
        col_missing[i].erase(k);
        square[i][i] = k;
        if (fill_diag(i + 1, nsum)) return true;
        square[i][i] = 0;
        col_missing[i].emplace(k);
        row_missing[i].emplace(k);
    }

    return false;
}

void build_latin_square()
{
    if (trace == n * n - 1 || trace == n * n + 1) throw 0;

    square.clear();
    row_missing.clear();
    col_missing.clear();

    square.resize(n+1, vector<int>(n+1, 0));
    row_missing.resize(n+1);
    col_missing.resize(n+1);

    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            row_missing[i].emplace(j);
            col_missing[i].emplace(j);
        }
    }

    if (!fill_diag(1, 0)) throw 0;
}

int main()
{
    int T;
    for (int C = scanf("%d", &T); T--; C++) {
        printf("Case #%d: ", C);
        scanf("%d%d", &n, &trace);
        try {
            build_latin_square();
            puts("POSSIBLE");
            print_square();
        } catch (...) {
            puts("IMPOSSIBLE");
        }
    }
    return 0;
}

다른 방법

사실 이 문제는 케이스를 잘 나누고 규칙에 따라 채우는 방법[4][5]으로도 깔끔하게 해결할 수 있다.

C / C++ 메모리 디버깅

2019-05-19T01:15:30+00:00

C나 C++로 프로그램을 작성할 경우, 아무리 신경을 써도 메모리 접근에서 예상치 못한 버그가 발생하고는 한다. 해제한 메모리를 다시 이용하거나(use after free), 할당한 공간을 넘어서 접근한다거나(heap / stack overflow).. 그렇다고 메모리 해제를 소극적으로 하다가는 해제되지 않고 메모리 누수가 일어나서 또 다른 문제를 일으킨다. 물론 이를 해결하기 위한 방법으로 가장 추천하는 것은 Rust처럼 안전한 언어를 이용하는 것이지만, 어쩔 수 없이 C / C++을 이용해야 하는 경우, 디버깅에 도움을 주는 도구를 적극적으로 이용하면 비교적 안전한 코드를 작성할 수 있다.

Static Analysis
- clang static analyzer
  - Compilation Database
Runtime Analysis

Static Analysis

clang static analyzer

clang에서 기본으로 제공하는 정적 분석 툴로, 소스 코드를 분석하여 NULL 포인터 접근, 잘못된 비교문(예: 쓰레기 값과 비교), 포인터의 free 이후 접근 등 중요한 오류를 빠르게 찾아준다. 다만 정적 분석이므로 False positive도 꽤 나오는 편이고, 많은 버그를 찾기에는 어려움이 따르기 때문에 뒤에서 이야기 할 런타임 분석 툴과 함께 이용하는 것을 추천한다.

Compilation Database

bear, 혹은 intercept-build를 이용하면 CMake를 이용하는 프로젝트는 물론, Makefile과 같은 레거시 빌드 시스템을 이용하는 프로젝트의 경우에도 쉽게 clang-check를 이용할 수 있다. 위의 툴을 이용하여 intercept-build make 와 같이 빌드를 수행하면 빌드 커맨드와 옵션이 자동으로 compile_commands.json 파일에 쓰여지는데, 이를 clang-check의 인자로 주면 각 소스 파일을 분석할 수 있다.

# http://btorpey.github.io/blog/2015/04/27/static-analysis-with-clang
export COMPILE_DB=$(/bin/pwd);
grep file compile_commands.json |
awk '{ print $2; }' |
sed 's/\"//g' |
while read FILE; do
  (cd $(dirname ${FILE});
   clang-check -analyze -p ${COMPILE_DB} $(basename ${FILE})
  );
done

Runtime Analysis

Valgrind :: Memcheck

C / C++을 이용하는 사람들 사이에서는 가장 유명한 런타임 분석 툴이다. 프로그램의 모든 인스트럭션을 바이너리 레벨에서 수정해서 수행하는 형태로 동작하므로 컴파일을 새로 할 필요도 없고, 따라서 코드를 갖고있지 않은 라이브러리의 버그도 찾을 수 있다는 장점을 갖고 있다.

Valgrind는 메모리 디버깅 외에도 여러 기능을 지원하지만 여기서는 메모리 디버깅을 담담하는 Memcheck만 살펴보자. Memcheck는 기본적으로 힙 영역 메모리에 대한 잘못된 접근을 찾아주며, 초기화가 되지 않을 값을 이용하는 경우나 메모리 누수가 일어나는 경우도 찾아준다.

여기까지 보면 정말 좋은 기능을 가지고 있는 툴인데, 몇 가지 문제가 존재한다:

동시에 한 개의 쓰레드만 수행한다 (마치 파이썬의 쓰레드 처럼 글로벌 락이 존재한다)
- 스케줄링 문제 (starvation), 퍼포먼스 문제, race condition과 관련된 버그 발견의 어려움을 초래
심각한 속도 저하 (20x 이상 느려진다)
심각한 메모리 사용량

그럼에도 불구하고 앞서 살펴본 장점으로 인해 여전히 많이 사용되고 있으며, 사용 방법 또한 간단하다.

$ valgrind --tool=memcheck --leak-check=full --trace-children=yes --show-reachable=yes --max-threads=2000 --error-limit=no ./a.out

Sanitizers :: AddressSanitizer

Valgrind와 비슷하게 Sanitizer에도 여러 분석 툴이 존재하지만 여기서는 메모리 접근에 대한 분석 툴인 AddressSanitizer(이하 Asan)만 살펴보자. 우선 AddressSanitizer는 컴파일 타임에 메모리 관리와 접근 부분의 코드를 수정하는 방법을 이용하며, Asan 자신이 라이브러리 형태로 해당 실행 파일에 링크되어 동작하므로 Asan을 통해 컴파일되지 않은 라이브러리의 경우 디버깅을 할 수 없다.

대신 이러한 방법을 이용하여 Valgrind보다 기본적으로 10배 빠르고(비교 결과), 멀티 쓰레드 환경을 제대로 지원하며(동시에 여러 쓰레드가 동작 한다), 특이한 기능으로 힙 영역 뿐만 아니라 스택 영역의 메모리 침범과 같은 문제도 발견하는 기능을 갖추었다.

실제로 이러한 속도와 기능으로 Chromium 프로젝트 또한 Valgrind에서 AddressSanitizer로 디버깅 툴을 바꾸었을 만큼 잘 만들어졌다. 다만 단점도 몇 가지 있는데, 대부분은 다른 Sanitizer(MemorySanitizer, LeakSanitizer)를 이용하여 해결할 수 있다.

비교

보통 2배 느려진다
메모리 사용량이 늘어나지만 Valgrind보다는 부담이 적다 (경험상 실제로 비교했을 때 2배 이하)
메모리 누수를 찾는 기능이 부실하다
초기화 하지 않은 값을 이용하는 경우를 찾지 못한다
컴파일을 새로 해야 한다
- 소스 코드를 가지고 있지 않은 라이브러리의 경우 적용 불가능

AddressSanitizer를 이용해서 컴파일 할 때에는 몇 가지 옵션을 주어야 하고, 보통 정적 링크를 추천한다. gcc의 경우 4.8 버전부터 지원하며, clang의 경우 3.1 버전부터 지원한다(compiler-rt).

# clang
$ clang++ -fsanitize=address -fno-omit-frame-pointer -g main.cc
# gcc
$ g++ -fsanitize=address -fno-omit-frame-pointer -g main.cc -static-libasan

Importance of Negative Tests

런타임 디버깅 툴은 훌륭한 기능을 제공하지만, 해당하는 코드가 실제로 수행되었을 경우에만 문제를 발견할 수 있다. 따라서 테스트 코드가 항상 정상 동작을 가정하고 작성(positive tests)되어 있을 경우에는 테스트 환경에서 문제를 발견하기 어렵다. 이를 완화하기 위해서는 정상 동작이 아닌 경우에 대한 테스트(negative tests)를 작성하는 것을 잊어선 안 된다.

Google Code Jam 2019 Round 1C

2019-05-05T10:15:30+00:00

GCJ R1C는 안 망했다!! 다행히 Round 2에 진출 가능한 등수를 받았다. C 라지를 고민하다가 결국 스몰만 풀고 던진 다음 나머지를 급하게 풀어서 A, B는 라지까지 맞았다. 야호! 대회 난이도를 돌아보면, C는 그런디 정리¹를 알면 쉽지만 모르면 풀 수 없는 문제였고, B는 올해 출제된, 즉 R1A나 R1B, 그리고 QR에 나온 인터랙티브 문제들에 비해 굉장히 쉬웠으며, A는 문제만 잘 해석하면 정말 아무렇게나 풀어도 라지까지 맞는 낚시 문제였다.

Robot Programming Strategy
Power Arrangers
Bacterial Tactics

Robot Programming Strategy

가위바위보 로봇들이 토너먼트에 출전하고, 각각의 로봇이 자신의 프로그램(차례로 낼 수)를 공개해 두었을 때, 토너먼트의 대진표가 어떻든간에 항상 우승하는 가위바위보 프로그램을 작성하는 문제이다.

언뜻 보면 토너먼트 때문에 복잡해 보이지만, 대진표를 적절히 바꾸어 모든 경우를 만들 수 있기 때문에 결국 모든 상대를 이기는 프로그램을 만들어야 한다. 이러한 프로그램은 사실 단순하게 시뮬레이션을 통해 만들어도 각 단계에서 패배하지만 않으면 된다는 특성 덕분에 이전 단계로 돌아가서 탐색을 다시 시작하는 back-tracking이 거의 일어나지 않아서 빠르게 수행된다.

#!/usr/bin/env python3
counters = {
    'R': 'P',
    'P': 'S',
    'S': 'R'
}

def solve(cur, ss, win):
    idx = len(cur)
    if idx >= 500: return '', False

    for k in ['R', 'P', 'S']:
        okay = True
        nxtmoves, nxtwins = cur + k, win[:]

        for j, s in enumerate(ss):
            if nxtwins[j]: continue
            elif s[idx] == counters[k]: okay = False
            elif counters[s[idx]] == k: nxtwins[j] = True

        if not okay: continue

        for j, s in enumerate(ss):
            if nxtwins[j]: continue
            nxt, npos = solve(cur + k, ss, nxtwins)
            if not npos: okay = False
            nxtmoves = nxt
            break

        if okay: return nxtmoves, True

    return '', False

T = int(input().strip())
for C in range(1, T + 1):
    n = int(input().strip())
    ss = [input().strip() for _ in range(n)]
    zz = [(t * (999 // len(t)))[:500] for t in ss]

    ans, possible = solve('', zz, [False] * len(zz))
    print("Case #{}: {}".format(C, ans if possible else 'IMPOSSIBLE'))

쉬운 문제를 어렵게 꼬아서 풀어보는 방법으로는 트라이를 이용한 풀이가 있다. 사실 대회중에 이걸 디버깅 하다가 시간이 부족해서 스몰이라도 맞자! 하는 마음에 시뮬레이션을 냈고, 그렇게 라지를 맞았다(…)

#!/usr/bin/env pypy
counters = {
    'R': 'P',
    'P': 'S',
    'S': 'R'
}

class Trie:
    def __init__(self):
        self.link = {}
        self.end = False

    def add(self, s):
        c, i = self, 0
        while i < len(s):
            nc = s[i]
            if nc not in c.link:
                c.link[nc] = Trie()
            c = c.link[nc]
            i += 1
        c.end = True

    def win(self):
        if len(list(self.link.keys())) == 3: return '', False
        if len(list(self.link.keys())) == 2 and sum([int(self.link[k].end) for k in self.link.keys()]) == 2: return '', False
        if len(list(self.link.keys())) == 1: return counters[list(self.link.keys())[0]], True
        if len(list(self.link.keys())) == 0: return '', True

        rets = {opt: self.link[opt].win() for opt in self.link.keys()}

        for move in ['R', 'P', 'S']:
            okay, nxt = True, ''
            for others in self.link.keys():
                if move == counters[others]: continue
                if counters[move] == others or not rets[others][1]: okay = False
                if not okay: break
                nxt = rets[others][0]
            if okay: return move + nxt, True

        return '', False

def solve(ss):
    trie = Trie()
    for s in ss: trie.add(s)
    ans, possible = trie.win()
    return ans[:500] if possible else "IMPOSSIBLE"

T = int(raw_input().strip())
for C in range(1, T + 1):
    n = int(raw_input().strip())
    ss = [raw_input().strip() for _ in range(n)]
    zz = [(t * (999 // len(t)))[:500] for t in ss]
    print("Case #{}: {}".format(C, solve(zz)))

Power Arrangers

A, B, C, D, E 의 다섯 개로 만들 수 있는 순열의 개수는 120개이다. 이 중에서 119개의 순열을 무작위 순서로 늘어놓았을 때, 빠진 하나의 순열을 최대 150개의 질문을 통해 알아내는 문제이다. 각 질문은 원하는 위치의 알파벳을 물어보는 것으로, 예를 들어 i번째 순열의 j번째 알파벳을 물어볼 경우 i * 5 + j를 물어보면 된다.

첫 번째 글자부터 순차적으로 결정해 나가면 해결할 수 있는 문제이다. 빠진 순열의 첫 글자는 119개의 순열에서 $4! - 1 = 23$번 등장한다는 사실을 이용하면 총 119번의 쿼리를 통해 첫 번째 알파벳을 알 수 있다. 같은 방법을 반복해서 두 번째 글자를 알아낼 때에는 $3! - 1 = 5$번 등장하는 알파벳을 찾으면 되는데, 여기에는 총 23번의 쿼리가 필요하다. 이런 식으로 마지막 글자까지 반복하면 총 119 + 23 + 5 + 1 = 148번의 쿼리를 통해 답을 찾을 수 있다.

#include<cstdio>
#include<set>
#include<vector>
#include<numeric>
#define sz size()
#define pb emplace_back
#define ALL(X) (X).begin(),(X).end()
using namespace std;
vector<int> range(int n) { vector<int> a(n); iota(ALL(a), 0); return a; }

void solve()
{
    vector<vector<vector<int>>> cand(6, vector<vector<int>>(5));
    set<int> until_now;
    const int target[] = {23, 5, 1, 0, 0};
    char ans[10]{}, last = 0;
    cand[0][0] = range(119);

    for (int k = 0; k < 5; k++) {
        for (int i: cand[k][last]) {
            printf("%d\n", i * 5 + k + 1), fflush(stdout);
            char x[4]{}; scanf("%s", x);
            int al = int(*x - 'A');
            cand[k+1][al].pb(i);
        }

        for (int i = 0; i < 5; i++) {
            if (until_now.count(i) == 0 && cand[k+1][i].sz == target[k]) {
                ans[k] = char(i + 'A');
                until_now.emplace(i);
                last = i;
                break;
            }
        }
    }

    puts(ans); fflush(stdout);
    char verdict[4]{}; scanf("%s", verdict);
    if (*verdict == 'N') exit(-1);
}

int main()
{
    int T;
    scanf("%d%*d", &T);
    while (T--) solve();
    return 0;
}

Bacterial Tactics

박테리아를 게임 판에 번갈아가며 하나씩 배치해서 자신의 차례에 더이상 둘 수 있는 수가 없는 사람이 패배하는 게임에 대한 문제이다. 게임에는 두 종류의 박테리아가 존재하는데, 놓으면 가로로 최대한 퍼지는 종과 놓으면 세로로 최대한 퍼지는 종이다. 단, 게임 판에는 방사성 물질이 존재하는 칸이 있는데, 박테리아가 해당하는 칸까지 퍼져나가면 바로 죽어버리고, 플레이어들은 이러한 일이 일어나도록 배치할 수 없다. 내가 첫 순서라고 생각했을 때, 첫 수를 어떻게 두어야 이길 수 있는지 그 경우의 수를 세어보자.

사실 이는 전형적인 알고리즘 게임 문제로, 매번 한 개의 박테리아를 배치할 때마다 게임 판이 둘로 나뉘어 부분 문제 2개의 답으로부터 전체 문제의 답을 구하는 형태를 갖는다. 이렇게 여러 게임의 승패로부터 전체 승패를 구하는 문제는 그런디 정리¹를 이용해서 해결할 수 있다.

각 상태의 그런디 수는 부분 문제의 그런디 수를 XOR 하여 얻을 수 있고, 그렇게 각 상태의 그런디 수를 구했을 때 0이 나온다면 해당하는 상태로부터 승리하는 방법이 없다는 것이고, 이를 이용해서 모든 첫 수에 대해 그런디 수가 0이 되는 경우 - 즉 상대가 패배하는 경우의 수를 세면 답을 구할 수 있다.

#include<cstdio>
#include<cstring>
#include<cstdint>
#include<vector>
#include<algorithm>
#define ALL(X) (X).begin(),(X).end()
using namespace std;

int n, m, d[18][18][18][18], f[18][18];

bool place_h(int x, int y, char vacant, char mark)
{
    int le = x, ri = x;
    while (le >= 0 && f[y][le] == vacant) --le;
    if (le >= 0 && f[y][le] == '#') return false;
    while (ri < m && f[y][ri] == vacant) ++ri;
    if (ri < m  && f[y][ri] == '#') return false;
    while (++le < ri) f[y][le] = mark;
    return true;
}

bool place_v(int x, int y, char vacant, char mark)
{
    int lo = y, hi = y;
    while (lo >= 0 && f[lo][x] == vacant) --lo;
    if (lo >= 0 && f[lo][x] == '#') return false;
    while (hi < n && f[hi][x] == vacant) ++hi;
    if (hi < n  && f[hi][x] == '#') return false;
    while (++lo < hi) f[lo][x] = mark;
    return true;
}

int grundy(int lx, int ly, int rx, int ry, int mark=100)
{
    if (lx >= rx || ly >= ry) return 0;
    int &ret = d[lx][ly][rx][ry];
    if (~ret) return ret;
    ret = 0;

    vector<bool> mex(n * n * m * m + 1, false);
    for (int i = ly; i < ry; i++) {
        for (int j = lx; j < rx; j++) {
            if (place_h(j, i, '.', mark)) {
                int g = grundy(lx, ly, rx, i, mark + 1) ^ grundy(lx, i+1, rx, ry, mark + 1);
                mex[g] = true;
                place_h(j, i, mark, '.');
            }

            if (place_v(j, i, '.', mark)) {
                int g = grundy(lx, ly, j, ry, mark + 1) ^ grundy(j+1, ly, rx, ry, mark + 1);
                mex[g] = true;
                place_v(j, i, mark, '.');
            }

        }
    }

    return ret = find(ALL(mex), false) - mex.begin();
}

int main()
{
    for (int T, C = scanf("%d", &T); C <= T; ++C) {
        printf("Case #%d: ", C);
        scanf("%d%d", &n, &m);
        for (int i = 0; i < n; i++) {
            char buf[22]{};
            scanf("%s", buf);
            for (int j = 0; j < m; j++) f[i][j] = buf[j];
        }

        int ret = 0;
        memset(d, -1, sizeof d);
        for (int i = 0; i < n; i++) if (place_h(0, i, '.', 99)) {
            ret += m * !(grundy(0, 0, m, i) ^ grundy(0, i+1, m, n));
            place_h(0, i, 99, '.');
        }

        for (int i = 0; i < m; i++) if (place_v(i, 0, '.', 99)) {
            ret += n * !(grundy(0, 0, i, n) ^ grundy(i+1, 0, m, n));
            place_v(i, 0, 99, '.');
        }

        printf("%d\n", ret);
    }
    return 0;
}

대회 중에는 테스트 셋 1을 해결하는 다이나믹 프로그래밍 코드를 이렇게 작성했다. $2^{4\cdot 4}$개의 상태만 고려하면 되기 때문에 모든 경우를 무식하게 탐색하는 방법이다. 여기서도 매번 재귀 호출을 할 때마다 부호를 뒤집는데, 이는 상대가 패배하는 것(다음 함수 호출)이 내(현재 함수 호출)가 승리하는 것이기 때문이다.

#include<cstdio>
#include<cstring>
#include<cstdint>
#include<map>

int n, m;
std::map<int, int8_t> d;
char f[16][16];

bool go(int stat)
{
    if (d.count(stat)) return bool(d[stat] - 1);
    int8_t &ret = d[stat];
    ret = 1;

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) if (f[i][j] == '.') {
            // horizontal
            {
                int le = j, ri = j, nstat = stat;
                while (le >= 0 && f[i][le] == '.') {
                    nstat |= 1 << (i * m + le);
                    --le;
                }

                if (le < 0 || f[i][le] == '@') {
                    while (ri < m && f[i][ri] == '.') {
                        nstat |= 1 << (i * m + ri);
                        ++ri;
                    }

                    if (ri >= m || f[i][ri] == '@') {
                        for (int x = le+1; x < ri; x++) f[i][x] = '@';
                        bool verdict = go(nstat);
                        for (int x = le+1; x < ri; x++) f[i][x] = '.';
                        if (!verdict) {
                            ret = 2;
                            return true;
                        }
                    }
                }
            }

            // vertical
            {
                int le = i, ri = i, nstat = stat;
                while (le >= 0 && f[le][j] == '.') {
                    nstat |= 1 << (j + le * m);
                    --le;
                }

                if (le < 0 || f[le][j] == '@') {
                    while (ri < n && f[ri][j] == '.') {
                        nstat |= 1 << (ri * m + j);
                        ++ri;
                    }

                    if (ri >= n || f[ri][j] == '@') {
                        for (int x = le+1; x < ri; x++) f[x][j] = '@';
                        bool verdict = go(nstat);
                        for (int x = le+1; x < ri; x++) f[x][j] = '.';
                        if (!verdict) {
                            ret = 2;
                            return true;
                        }
                    }
                }
            }
        }
    }

    return false;
}

int main()
{
    for (int T, C = scanf("%d", &T); C <= T; ++C) {
        printf("Case #%d: ", C);
        scanf("%d%d", &n, &m);

        uint8_t rok[16]{}, cok[16]{};
        for (int i = 0; i < m; i++) cok[i] = 1;

        for (int i = 0; i < n; i++) {
            scanf("%s", f[i]);
            rok[i] = 1;
            for (int j = 0; j < m; j++) {
                rok[i] &= f[i][j] != '#';
                cok[j] &= f[i][j] != '#';
            }
        }

        int ret = 0;
        d.clear();
        for (int i = 0; i < n; i++) if (rok[i]) {
            int stat = 0;
            for (int j = 0; j < m; j++) {
                f[i][j] = '@';
                stat |= 1 << (m * i + j);
            }

            ret += m * !go(stat);

            for (int j = 0; j < m; j++)
                f[i][j] = '.';
        }

        for (int i = 0; i < m; i++) if (cok[i]) {
            int stat = 0;
            for (int j = 0; j < n; j++) {
                f[j][i] = '@';
                stat |= 1 << (i + j * m);
            }

            ret += n * !go(stat);

            for (int j = 0; j < n; j++)
                f[j][i] = '.';
        }

        printf("%d\n", ret);
    }
    return 0;
}

그런디 정리에 대한 짧은 요약, TopCoder 튜토리얼. ↩ ↩²

Google Code Jam 2019 Round 1B

2019-04-29T12:55:30+00:00

GCJ R1B는 새벽 1시에 열려서 잠을 포기하고 참가! 했지만.. 컨디션 조절 실패로 (변명) 이번에도 Round 2 진출에 실패하고 말았다. 전체적인 난이도는 A가 너무 쉽고, B가 생각보다 어려웠으며, C는 구현이 상당히 복잡한 문제였다.

Manhattan Crepe Cart
Draupnir
Fair Fight

Manhattan Crepe Cart

Q×Q(1≤Q≤100,000)그리드 상에 있는 P(1≤P≤500)명의 사람의 현재 위치와 이동 방향이 주어졌을 때, 가장 많은 사람의 진행 방향과 겹치는 점의 위치를 찾는 문제이다. 편의상 각 사람은 하나의 반평면이라고 생각하면 된다: 예를 들어 북쪽을 향하고 있을 경우 $y > y_0$ 인 모든 점이 해당 사람의 진행 방향에 있다고 할 수 있고, 동쪽을 향하고 있을 경우 $x > x_0$ 인 모든 점이 해당 사람의 진행 방향에 있다고 할 수 있다.

풀이는 가로 반평면과 세로 반평면을 따로 고려함으로써 각각 $y$와 $x$좌표를 알아낼 수 있다는 것을 떠올리면 간단하다. 우선 가로 반평면을 해결하는 방법을 살펴보자. 이는 간단한 스윕 라인¹을 통해 해결할 수 있다.

북쪽을 바라보는 사람을 이벤트 $(y_0 + 1, +1)$으로 나타낼 수 있고, 같은 방법을 이용해서 남쪽을 바라보는 사람 역시 $(y_0, -1)$으로 나타낼 수 있다. 이제 각 이벤트를 처리하면서 가장 많은 사람의 진행 방향과 겹치는 점을 선택하면 끝!

#include<cstdio>
#include<algorithm>
#include<vector>
#define x first
#define y second
#define pb emplace_back
#define ALL(X) (X).begin(),(X).end()
using namespace std;
using ii = pair<int, int>;

int n, m;
vector<ii> p[2];

int sweep(vector<ii>& events, int base) {
    int acnt = base, ret = 0, cnt = base;
    sort(ALL(events));

    for (auto& evt: events) {
        cnt += evt.y;
        if (cnt > acnt) {
            acnt = cnt;
            ret = evt.x;
        }
    }

    return ret;
}

int main()
{
    for (int T, C = scanf("%d", &T); C <= T; ++C) {
        printf("Case #%d: ", C);
        scanf("%d%d", &n, &m);
        p[0].clear();
        p[1].clear();

        int xb = 0, yb = 0;
        for (int i = 0; i < n; i++) {
            int x, y; char d[16];
            scanf("%d%d%s", &x, &y, d);
            if (*d == 'N') {
                p[0].pb(y+1, 1);
            } else if (*d == 'S') {
                ++yb;
                p[0].pb(y, -1);
            } else if (*d == 'E') {
                p[1].pb(x+1, 1);
            } else if (*d == 'W') {
                ++xb;
                p[1].pb(x, -1);
            }
        }

        printf("%d %d\n", sweep(p[1], xb), sweep(p[0], yb));
    }
    return 0;
}

Draupnir

오딘이 $0$번째 날에 6개의 링을 각각 $r_1, r_2, …, r_6$개 가지고 있다고 하자($r_i≤100$). $i$번째 날이 될 때마다, $i|j$, 즉 $i$의 약수인 $j$번째 링이 두 배로 늘어난다. 따라서 $i$번째 날의 각 링의 개수는 각각 $r_1 \cdot 2^{\lfloor{i/1}\rfloor}, r_2 \cdot 2^{\lfloor{i/2}\rfloor}, …$개가 된다. 문제는 $r_1, …, r_6$을 모르는 상태에서 $i$번째 날에 오딘이 가지고 있는 모든 링 개수의 합($\mathrm{mod~} 2^{63}$)을 묻는 질문을 통해 $r_1, …, r_6$을 알아내는 것이다.

풀이의 아이디어는 각 $r_i$가 100보다 작음을 이용, 128진법과 비슷한 아이디어를 통해 합으로부터 각 링의 개수를 분리하는 것이다. 예를 들어 210일 째에 오딘이 가지고 있는 링의 개수를 풀어 쓰면 다음과 같이 표현할 수 있다: $Q(210) = r_1 \cdot 2^{210} + r_2 \cdot 2^{105} + r_3 \cdot 2^{70} + r_4 \cdot 2^{52} + r_5 \cdot 2^{42} + r_6 \cdot 2^{35} \mathrm{~mod~} 2^{63} \\ Q(210) = r_4 \cdot 2^{52} + r_5 \cdot 2^{42} + r_6 \cdot 2^{35}$

지수를 살펴보면 각각의 차이가 7 이상이기 때문에 합으로부터 $r_4, r_5, r_6$을 얻어낼 수 있다.

$\begin{cases} r_6 & = & Q(210) \div 2^{35} \mathrm{~mod~} 128 \\ r_5 & = & Q(210) \div 2^{42} \mathrm{~mod~} 128 \\ r_4 & = & Q(210) \div 2^{52} \mathrm{~mod~} 128 \\ \end{cases}$

마찬가지로 42일 째의 링 개수는 다음과 같이 표현 가능하다. $Q(42) = r_1 \cdot 2^{42} + r_2 \cdot 2^{21} + r_3 \cdot 2^{14} + r_4 \cdot 2^{10} + r_5 \cdot 2^{8} + r_6 \cdot 2^{7} \\$ 다행히 이미 $r_4, r_5, r_6$을 알고 있으므로, 아까와 똑같은 방법을 통해 나머지 링의 개수도 구할 수 있다.

$\begin{cases} r_3 & = & (Q(42) - r_4 \cdot 2^{10} - r_5 \cdot 2^{8} - r_6 \cdot 2^{7}) \div 2^{14} \mathrm{~mod~} 128 \\ r_2 & = & (Q(42) - r_4 \cdot 2^{10} - r_5 \cdot 2^{8} - r_6 \cdot 2^{7}) \div 2^{21} \mathrm{~mod~} 128 \\ r_1 & = & (Q(42) - r_4 \cdot 2^{10} - r_5 \cdot 2^{8} - r_6 \cdot 2^{7}) \div 2^{42} \mathrm{~mod~} 128 \\ \end{cases}$

def solve3(x, s):
    return [(x >> i) & 127 for i in s]

def solve():
    print(210, flush=True)
    x = solve3(int(input()), [210 // 4, 210 // 5, 210 // 6])

    print(42, flush=True)
    y = int(input()) - sum([x[i] << (42 // (i + 4)) for i in range(3)])

    r = solve3(y, [42 // 1, 42 // 2, 42 // 3]) + x
    print(" ".join([str(x) for x in r]), flush=True)
    if int(input()) == -1: exit(-1)

T, _ = map(int, input().strip().split())
[solve() for C in range(1, T + 1)]

Fair Fight

N(1≤N≤100,000)종류의 검이 각각 여러 자루씩 존재하고, 각 종류별로 찰스와 데릴라가 각각의 검을 선택했을 때의 공격력이 주어진다. 찰스와 데릴라는 각각 자신의 공격력이 최대가 되는 검을 선택한다고 할 때, 선택할 수 있는 검의 종류를 $[L, R]$ 구간으로 제한해서 둘의 공격력 차이가 K이하가 되도록 하는 경우의 수를 구해보자.

보자마자 히스토그램에서 가장 큰 직사각형 찾기가 떠오르는 문제이다. 이를 해결하는 방법에는 여러 가지가 있지만, 여기선 구현은 조금 복잡하지만 아이디어가 간단한 방법인 바이너리 서치를 이용한 풀이를 살펴보자.

구간이 주어졌을 때, 찰스와 데릴라는 각각 가장 큰 공격력($C_i, D_i$)을 갖는 검을 고르게 된다. 이 사실을 이용해서 각각의 검이 찰스(혹은 데릴라)에게 최대의 공격력을 주는 구간을 따로 고려하면 모든 답의 후보를 살펴볼 수 있다.

다음의 테스트 케이스를 살펴보자:

4        # K = 4
4 4 0 5  # C_i
4 4 4 1  # D_i

여기서 각각의 검이 찰스에게 최대의 공격력을 주는 구간은 다음과 같다(각각의 수는 모두 인덱스를 나타낸다).

: {1..1..1} # [(1, 1)]
: {1..2..4} # [(1, 2), (2, 2), (1, 3), (2, 3), (2, 4)]
: {1..3..4} # [(1, 3), (2, 3), (3, 3), (3, 4)]
: {4..4..4} # [(4, 4)]
: {1..5..5} # [(1, 5), (2, 5), (3, 5), (4, 5), (5, 5)]

왼쪽의 각 구간 별 중괄호 표현은 각 검이 구간 내의 최댓값인 가장 큰 구간을 나타낸다. 이를 구할 때 바로 바이너리 서치를 이용하게 되는데, 검 $i$에 대한 구간을 고려할 때, $[i, j]$ 구간의 최댓값이 $C_i$ 이하라면 $j < k$인 $[i, k]$ 구간의 최댓값 역시 $C_i$ 이하가 되기 때문에 바이너리 서치로 $i$를 중심으로 했을 때 (1)오른쪽 끝과 (2)왼쪽 끝을 따로 구할 수 있다. 이 구간을 $L_i, R_i$라고 하자.

이제 $C_i - K ≤ \mathrm{max}(\{D_j \| L’≤j≤R’\}) ≤ C_i + K$를 만족하는 $L_i ≤ L’ ≤ i ≤ R’ ≤ R_i$ 쌍의 개수를 구하면 검 $i$가 속하는 모든 가능한 구간의 개수를 구할 수 있다.

여기선 부등호의 양 변을 따로 계산하면 편리한데, 우선 $D_j ≤ C_i + K$를 만족하는 $j$의 최대 범위를 아까와 같은 방식으로 찾고, 이를 $L^+, R^+$라고 하자. 그 다음 $D_j ≥ C_i - K$를 만족하는 최대 범위를 찾아 $L^-, R^-$라고 하면 (그런 구간이 존재할 경우) $L_i ≤ L^+ ≤ L^- ≤ i ≤ R^- ≤ R^+ ≤ R_i$가 되고, 이로부터 $L’ = \{L^+, …, L^-\}$, 그리고 $R’ = \{R^-, …, R^+\}$를 찾아 $i$를 중심으로 하는 구간의 개수 $\|L’\| \cdot \|R’\|$를 얻을 수 있다.

여기까진 어렵지 않게 떠올릴 수 있지만, 실제로 구현할 때에는 특정 구간의 최댓값을 빠르게 구하는 구간 최댓값 쿼리²를 이용해야 하고, 같은 공격력을 갖는 검이 여럿 있을 경우 중복되는 구간을 세지 않도록(위의 예제를 보자) 신경써서 구현해야 해서 대회 시간에 해결하기에는 어려운 문제라고 느꼈다.

#include<cstdio>
#include<map>
#include<algorithm>
using namespace std;
using ll = long long;

struct MaxNode {
    using ReturnType = int;
    int v;
    inline MaxNode(ReturnType v=-1e9): v(v) {}
    inline ReturnType Query() const { return v; }
    inline void Update(const ReturnType& x) { v = x; }
    inline MaxNode Combine(const MaxNode& le, const MaxNode& ri) {
        v = max(le.v, ri.v);
        return *this;
    }
};

template<class Node>
struct SegmentTree {
    typedef typename Node::ReturnType T;
    Node *nodes;
    int size;

    inline SegmentTree(int *s, int *e): size(1) {
        int n(e - s);
        while (size <= n || size < 8) size <<= 1;
        nodes = new Node[size<<1];

        for (int i = n; i > 0; i--)
            --e, nodes[i+size].Update(*e);

        for (int i = size - 1; i > 0; i--)
            nodes[i].Combine(nodes[i<<1], nodes[i<<1|1]);
    }

    inline T Query(int l, int r) const {
        Node le, ri, tmp;
        for (l += size, r += size + 1; l < r; l >>= 1, r >>= 1) {
            if (l & 1) le = tmp.Combine(le, nodes[l++]);
            if (r & 1) ri = tmp.Combine(nodes[--r], ri);
        }
        return tmp.Combine(le, ri).Query();
    }

    inline ~SegmentTree() { delete[] nodes; }
};

const int MAXN = 1e5 + 10;
int n, k, a[MAXN], b[MAXN];

template<typename T>
int searchMaxLeft(T & tree, int l, int r, int i, int x) {
    int ret = 1 << 30;
    while (l <= r) {
        int mid = (l + r) >> 1;
        if (tree.Query(min(i, mid), max(i, mid)) <= x) {
            ret = min(ret, mid);
            r = mid - 1;
        } else {
            l = mid + 1;
        }
    }

    return ret;
}

template<typename T>
int searchMaxRight(T & tree, int l, int r, int i, int x) {
    int ret = -(1 << 30);
    while (l <= r) {
        int mid = (l + r) >> 1;
        if (tree.Query(min(i, mid), max(i, mid)) <= x) {
            ret = max(ret, mid);
            l = mid + 1;
        } else {
            r = mid - 1;
        }
    }

    return ret;
}

int main()
{
    for (int T, C = scanf("%d", &T); C <= T; ++C) {
        scanf("%d%d", &n, &k);

        for (int i = 1; i <= n; i++) scanf("%d", a + i);
        SegmentTree<MaxNode> tree1(a + 1, a + n + 1);

        for (int i = 1; i <= n; i++) scanf("%d", b + i);
        SegmentTree<MaxNode> tree2(b + 1, b + n + 1);

        ll ans = 0;
        map<int, int> ignore;
        for (int i = 1; i <= n; i++) {
            int j = ignore.count(a[i]) ? ignore[a[i]] + 1 : 1;
            int alb = searchMaxLeft(tree1, j, i, i, a[i]);
            int arb = searchMaxRight(tree1, i, n, i, a[i]);

            int lb = max({alb, searchMaxLeft(tree2, j, i, i, a[i] + k)});
            int rb = min({arb, searchMaxRight(tree2, i, n, i, a[i] + k)});
            if (rb >= lb) ans += (rb - i + 1) *1LL* (i - lb + 1);

            int flb = max({alb, searchMaxLeft(tree2, j, i, i, a[i] - k - 1)});
            int frb = min({arb, searchMaxRight(tree2, i, n, i, a[i] - k - 1)});
            if (frb >= flb) ans -= (frb - i + 1) *1LL* (i - flb + 1);

            ignore[a[i]] = i;
        }
        printf("Case #%d: %lld\n", C, ans);
    }
    return 0;
}

스윕 라인에 대한 TopCoder 튜토리얼, Baekjoon Online Judge 튜토리얼. ↩
구간 최댓값 문제를 해결하는 Segment Tree, Sparse Table. ↩

Google Kick Start 2019 Round B

2019-04-21T02:33:30+00:00

오늘 오전에는 Kick Start Round B가 있었다. 난이도는 Round A처럼 역시 어려웠다(ㅠㅠ). 다만 각 문제가 다이나믹 프로그래밍, 그리디, 그리고 라인 스위핑 등 기본적인 알고리즘의 의미를 충실하게 고민하면 풀 수 있는 구성으로, PS를 다시 연습하기에 훌륭한 대회였다.

Building Palindromes
Energy Stones
1. Test Set 1
2. Test Set 2
Diverse Subarray

Building Palindromes

알파벳 대문자로 이루어진 문자열 S(1≤|S|≤100,000)와 Q개의 독립적인 쿼리 [L, R]이 주어졌을 때, 각 쿼리에 대해 문자열 조각 S[L:R+1]을 재배열하여 팰린드롬을 만들 수 있는지 확인하는 문제이다.

이는 간단하게 구간 안에 존재하는 각 알파벳의 개수를 세어 확인할 수 있다. 홀수 개 존재하는 알파벳이 1개인 경우에는 해당 알파벳을 가운데에 놓음으로써 팰린드롬을 만들 수 있지만, 이러한 알파벳이 여럿 존재하면 팰린드롬을 만들 수 없으므로 간단히 해결 가능하다.

#include<cstdio>
#include<cstring>
const int MAXN = 1e5 + 10;

char s[MAXN]{};
int d[26][MAXN]{}, n, q;
int main()
{
    for (int T, C = scanf("%d", &T); C <= T; ++C) {
        printf("Case #%d: ", C);
        scanf("%d%d%s", &n, &q, s + 1);
        memset(d, 0, sizeof d);
        for (int k = 0; k < 26; k++) {
            for (int i = 1; i <= n; i++)
                d[k][i] = d[k][i-1] + (s[i] - 'A' == k);
        }
        int ans = 0;
        while (q--) {
            int l, r;
            scanf("%d%d", &l, &r);
            int odd = 0;
            for (int k = 0; k < 26; k++)
                odd += (d[k][r] - d[k][l-1]) % 2;
            ans += odd < 2;
        }
        printf("%d\n", ans);
    }
    return 0;
}

Energy Stones

돌 몬스터가 점심으로 N(1≤N≤100)개의 에너지 스톤을 먹으려 한다. 각 에너지 스톤은 S, E, L의 값을 갖는데, 돌을 소화시키는 데에 S(1≤S≤100)만큼의 시간이 걸리고, 돌을 시간 0에 먹을 경우 E만큼의 에너지를 얻을 수 있다. 그리고 시간이 1만큼 지날 때 마다 L만큼 돌의 에너지가 줄어들어 결과적으로 시간 T에 돌을 먹을 경우 max(0, E - L * T)만큼의 에너지를 얻고, 먹는 데에는 시간이 걸리지 않지만, 소화시키는 데에 S만큼 걸려 T = T + S가 된다.

Test Set 1

이 데이터 셋에서는 모든 돌의 S가 같으므로 각 돌을 먹는 데에 걸리는 시간을 1이라고 간단히 생각할 수 있다. 따라서 먹을 돌의 집합이 “이미 결정된 상태” 에서는 L이 큰 것부터 순서대로 먹느 것이 최적인데, 그럼 먹을 돌의 집합은 어떻게 구해야 할까?

순서를 고정한 상태에서 최적의 부분집합을 선택하는 것은 0-1 냅색을 이용해서 쉽게 해결할 수 있다. 즉, 주어진 돌을 미리 L이 감소하는 기준으로 정렬해 두고 냅색을 이용하면 최적의 순서로 선택했을 때 부분 집합이 갖는 에너지의 합을 구할 수 있다.

Test Set 2

S가 다를 수 있으므로 아까보다 복잡해진 기분이 든다. 하지만, 결국 단위 시간당 줄어드는 에너지의 양, 즉 L' = L / S를 생각해 보면 아까와 별로 다를 것이 없음을 알 수 있다.

#include<cstdio>
#include<cstring>
#include<tuple>
#include<vector>
#include<algorithm>
#define pb emplace_back
#define ALL(X) (X).begin(),(X).end()
using namespace std;

const int MAXN = 111;
int n, s[MAXN], l[MAXN], e[MAXN];

int solve() {
    vector<tuple<int, int, int>> v;
    for (int i = 0; i < n; i++) {
        v.pb(min(l[i], e[i]), s[i], e[i]);
    }

    sort(ALL(v), [](const auto& p, const auto& q) {
        return get<0>(p) * get<1>(q) > get<0>(q) * get<1>(p);
    });

    for (int i = 0; i < n; i++) {
        tie(l[i], s[i], e[i]) = v[i];
    }

    int d[MAXN * MAXN]{}, maxt = 0;
    for (int i = 0; i < n; i++) {
        for (int j = maxt; j >= 0; j--) {
            int val = max(0LL, e[i] - j *1LL* l[i]);
            d[j + s[i]] = max(d[j + s[i]], d[j] + val);
        }
        maxt += s[i];
    }

    return *max_element(d, d + ++maxt);
}

int main()
{
    for (int T, C = scanf("%d", &T); C <= T; ++C) {
        printf("Case #%d: ", C);
        scanf("%d", &n);
        for (int i = 0; i < n; i++) {
            scanf("%d%d%d", s + i, e + i, l + i);
        }
        printf("%d\n", solve());
    }
    return 0;
}

Diverse Subarray

길이 N(1≤N≤100,000)의 정수 배열이 주어진다. 배열의 각 원소 A[i]가 장식품의 종류를 나타낼 때, 이 배열에서 가장 많은 원소가 포함된 연속한 부분 배열을 선택하는 문제이다. 여기까진 간단해 보이지만, 조금 특이한 제한 조건이 있다: 각 종류별 장식품을 S개 보다 많이 선택할 경우, 해당 종류는 모두 압수당해서 0개가 되어버린다는 것이다.

테스트 셋 1은 N의 제한 조건이 1≤N≤1,000 이므로 모든 부분 배열을 순회하여 해결할 수 있다. 한편, 테스트 셋 2의 경우에는 그렇게 간단히는 해결할 수 없다. 즉, 모든 부분 배열을 확인하지 않고 최적의 부분 배열을 찾아야 한다.

우선 테스트 셋 1번을 해결하는 알고리즘을 ‘조금 복잡하게’ 만들어 보자.

1	1	4	1	4	4
+1	+1	+1	-2	+1	-2

위쪽 행은 예제 수열, 그리고 아래는 S = 2인 경우 각각의 원소까지 선택했을 때 부분 배열 안에 남게 되는 장식품의 수의 변화값을 나타낸다. 즉, 맨 앞의 1만 선택하면 (0) + 1 = 1개가 남고, 네 번째 원소까지 고를 경우 (0) + 1 + 1 + 1 - 2 = 1개가 남는다. 이렇게 시작점이 맨 앞으로 고정돼 있는 경우의 최적 부분 배열은 3번째 원소까지 고른 것(=3)임을 알 수 있다.

1	1	4	1	4	4
±0	+1	+1	+1	+1	-2

이번엔 부분 배열의 시작 위치를 한 칸 옮긴 상태를 생각해 보자. 이 경우의 최적 부분 배열은 다섯 번째 원소까지(=4)가 된다.

여기서 눈여겨 봐야 할 것은 시작 점을 바꿀 때 바뀐 부분(파란 색) 이다. 시작 점이 바뀌더라도 실제로 갱신해야 할 값은 이전 시작 점과 같은 값을 갖는 S번째, 그리고 S + 1번째 값 뿐임을 알 수 있다.

이를 바탕으로 다시 코드를 작성해 보면 다음과 같다.

#include<cstdio>
#include<map>
#include<deque>
#include<vector>
#include<algorithm>
#define sz size()
#define pb emplace_back
using namespace std;
const int MAXN = 1e5 + 10;

int n, s;
int a[MAXN];

int main()
{
    for (int T, C = scanf("%d", &T); C <= T; ++C) {
        printf("Case #%d: ", C);
        scanf("%d%d", &n, &s);
        for (int i = 1; i <= n; i++) {
            scanf("%d", a + i);
        }

        map<int, deque<int>> d;
        vector<int> v(MAXN, 0);
        for (int i = 1; i <= n; i++) {
            auto & q = d[a[i]];
            v[i] = q.sz == s ? -s : q.sz > s ? 0 : 1;
            q.pb(i);
        }

        int ans = 0;
        for (int b = 1; b <= n; b++) {
            int ptr[MAXN]{}, cur = 0;
            for (int e = b; e <= n; e++) { // can be eliminated
                cur += v[d[a[e]][ptr[a[e]]++]];
                ans = max(ans, cur);
            }
            if (d[a[b]].sz > s) v[d[a[b]][s]] = 1;
            if (d[a[b]].sz > s + 1) v[d[a[b]][s+1]] = -s;
            d[a[b]].pop_front();
        }

        printf("%d\n", ans);
    }
    return 0;
}

결과적으로 이렇게 구하더라도 여전히 시간 복잡도는 배열 길이의 제곱에 비례한다. 하지만, 이제 코드에서 시간을 줄일 수 있는 부분이 확실하게 보인다: 바로 합을 구하는 루프!

이는 세그먼트 트리와 같은 자료 구조를 이용하여 원소 수의 로그에 비례하는 시간에 구할 수 있다. 더욱이, 시작점이 바뀔 때 마다 업데이트 하는 연산 역시도 로그 시간에 수행할 수 있다. 따라서 모든 시작점에 대해 최적 부분 배열을 로그 시간에 구할 수 있으므로 총 시간 복잡도는 $O(n\log{n})$이 된다.

#include<cstdio>
#include<map>
#include<deque>
#include<vector>
#include<algorithm>
#define sz size()
#define pb emplace_back
using namespace std;
const int MAXN = 1e5 + 10;

struct PrefixSumNode {
    typedef int ReturnType;
    ReturnType sum, prefix;
    inline PrefixSumNode(ReturnType x=0): sum(x), prefix(x) {}
    inline ReturnType query() const { return prefix; }
    inline void update(const ReturnType& x) { sum = prefix = x; }
    inline PrefixSumNode combine(const PrefixSumNode& le, const PrefixSumNode& ri) {
        sum = le.sum + ri.sum;
        prefix = max(le.prefix, le.sum + ri.prefix);
        return *this;
    }
};

template<class Node>
struct SegmentTree {
    typedef typename Node::ReturnType T;
    Node *nodes;
    int size;

    inline SegmentTree(int n): size(1) {
        while (size <= n || size < 8) size <<= 1;
        nodes = new Node[size<<1];
    }

    inline void update(int p, const T& v) {
        nodes[size+p].update(v);
        for (p += size; p > 1; p >>= 1) {
            int parent = p >> 1, le = p, ri = p;
            if (p&1) le = p ^ 1;
            else ri = p ^ 1;
            nodes[parent].combine(nodes[le], nodes[ri]);
        }
    }

    inline T query(int l, int r) const {
        Node le, ri, tmp;
        for (l += size, r += size + 1; l < r; l >>= 1, r >>= 1) {
            if (l & 1) le = tmp.combine(le, nodes[l++]);
            if (r & 1) ri = tmp.combine(nodes[--r], ri);
        }
        return tmp.combine(le, ri).query();
    }

    inline ~SegmentTree() { delete[] nodes; }
};

int n, s;
int a[MAXN];

int main()
{
    for (int T, C = scanf("%d", &T); C <= T; ++C) {
        printf("Case #%d: ", C);
        scanf("%d%d", &n, &s);
        for (int i = 1; i <= n; i++) {
            scanf("%d", a + i);
        }

        map<int, deque<int>> d;
        SegmentTree<PrefixSumNode> tree(n);
        for (int i = 1; i <= n; i++) {
            auto & q = d[a[i]];
            tree.update(i, q.sz == s ? -s : q.sz > s ? 0 : 1);
            q.pb(i);
        }

        int ans = 0;
        for (int b = 1; b <= n; b++) {
            ans = max(ans, tree.query(b, n));
            if (d[a[b]].sz > s) tree.update(d[a[b]][s], 1);
            if (d[a[b]].sz > s + 1) tree.update(d[a[b]][s+1], -s);
            d[a[b]].pop_front();
        }

        printf("%d\n", ans);
    }
    return 0;
}

Let’s Encrypt, Cross Sigining

2019-04-18T10:33:30+00:00

Let’s Encrypt가 7월 8일부터 자체 서명한 인증서를 발급한다는 소식을 듣고, 바로 관련된 문제가 무엇인지 찾아보았다. 문제는 ISRG가 Root CA로 신뢰받기 시작한 것이 최근이라는 점인데, 예를 들어 Windows의 경우, 작년 8월 이후에 윈도우즈 업데이트를 하지 않았을 경우 테스트 사이트에 접속했을 때 “신뢰할 수 없는 사이트” 에러를 볼 수도 있다.

이제 이를 이해하고 대응하기 위해 필요한 개념들을 살펴보자.

Chain of Trust
Cross Sigining
그래서 방법은?

Chain of Trust

Let’s Encrypt에서 발급받은 인증서를 이용하는 사이트에 접속하면 다음과 같은 인증서 정보를 볼 수 있다.

인증서가 3단계로 계층 형태를 갖는데, 각각이 무엇인지 아래 그림과 함께 살펴보자.

우선 End-entity Certificate이 바로 아까 본 그림의 a.cyclic.dev 인증서에 해당한다. 이 인증서에는 Let's Encrypt Authority X3에 의해 발급되었고, RSA로 서명 받았음이 기재되어 있다. 기재된 정보를 따라가면 Intermediate Certificate를 만날 수 있다.

Intermediate Certificate은 다시 Root CA인 DST Root CA X3에 의해 발급된 것이라고 한다.

이번엔 스스로 발급한(self-signed) Root CA의 인증서가 나온다.

보통 브라우저와 OS는 신뢰할 수 있는 Root CA의 정보를 가지고 있고, 이를 바탕으로 유효한 체인을 따라가서 신뢰할 수 있는 Root CA까지 도달하면 해당 체인을 모두 신뢰하게 된다.

Let’s Encrypt의 (현재) 인증서를 따라가면 나오는 Root CA인 DST Root CA는 IdenTrust에서 관리하는데, 역사가 길어 대부분의 기기(OS,브라우저,…)가 해당 Root CA 인증서를 신뢰한다.

한편, 7월부터는 Let’s Encrypt를 운영하는 ISRG(Ineternet Security Research Group) Root CA에서 발급한 인증서를 이용하는 것을 테스트 사이트에서 확인할 수 있다.

Cross Sigining

그런데, 방금 그림을 자세히 보면 중간에 있는 Let’s Encrypt Authority X3가 너무 익숙하다. 처음에 살펴본 DST 인증서 체인에도 같은 CA의 인증서가 있었다.

이는 Let’s Encrypt Authority X3가 Cross Signing을 받은 CA이기 때문이다. 즉 두 Root CA, DST Root CA X3와 ISRG Root X1에게 인증을 받은 CA란 것이다.

CA라는 것은 사실 결국 RSA 공개키와 비밀키의 쌍이고, 인증서는 비밀키로 서명된 데이터와 공개키로 이루어진 것인데, CA가 하나라는 말은 키 쌍이 하나라는 뜻이고(중요), 두 곳에서 인증을 받았단 것은 인증서는 둘이라는 뜻이다(중요). 즉, 우리의 End-Entity Certificate은 그 하나의 키(Let’s Encrypt Authority X3)로 서명된 것이므로, 위의 두 인증서(DST Root CA X3, ISRG Root X1) 둘 중 어느 쪽을 이용해도 인증이 유효하다(매우 중요).

따라서, Intermediate Certificate이 만료되기 전까지는 현재 이용중인 DST Root CA X3의 서명이 들어있는 Intermediate Certificate을 ISRG Root X1의 인증서 대신 서버에 적용함으로써 오래 된 유저들이 업데이트 하기를 기다릴 수 있다!!!

그래서 방법은?

Certbot을 이용해서 인증서를 발급받으면 fullchain.pem이 생성되고, TLS 스펙을 따르는 서버는 보통 이 파일을 이용한다. 여기엔 두 개의 인증서 정보가 들어있는데, 위의 것이 End-Entity Certificate, 아래의 것이 Intermediate Certificate 이다.

직접 ISRG의 것과 DST의 것을 바꿔보며 테스트 해 보면 가장 확실한데, ISRG의 Intermediate Certificate은 아까의 테스트 사이트에 접속해서 얻을 수 있다.

openssl s_client -showcerts -connect valid-isrgrootx1.letsencrypt.org:443 -servername valid-isrgrootx1.letsencrypt.org

Google Code Jam 2019 Round 1A

2019-04-13T04:33:30+00:00

오늘 열린 GCJ R1A도 GCJ 퀄 라운드와 마찬가지로 쉬운 아이디어로 풀리는 문제가 많았다. 물론 나는 그 쉬운 아이디어가 빨리 안 떠올라서 망했지만 T_T

Pylons
Golf Gophers
Alien Rhyme

Pylons

격자 그래프에서의 Hamiltonian Path를 찾는 문제로, 연속된 이동이 같은 열, 같은 행, 그리고 같은 대각선을 포함하면 안 된다는 조건이 Knight’s tour를 연상시키는 문제였다.

랜덤 서치를 이용하면 모든 경우에 대해 답을 구하는 데에 그닥 오랜 시간이 걸리지 않는다. 문제는 여기에 약간의 운빨이 필요하다는 사실인데.. 이를 극복하기 위해 C++ 로 모든 경우의 답을 미리 구한 다음, 파이썬으로 출력만 해서 편하게 풀려고 했었다.

근데.. 코드잼에 코드 길이 100K 제한이 있는줄은 몰랐지! 대회가 끝나고 나서 생각해보니 lzma, pickle, base64 모듈을 이용하면 이러한 꼼수도 이용 가능함을 알게 되었지만..

import lzma as l
import pickle as p
import base64 as b
from collections import defaultdict
a = p.loads(l.decompress(b.b85decode(b'(생략)')))

def solve(n, m):
    if n in a.keys() and m in a[n].keys():
        return "POSSIBLE\n" + "\n".join(["{} {}".format(x[0], x[1]) for x in a[n][m]])
    if m in a.keys() and n in a[m].keys():
        return "POSSIBLE\n" + "\n".join(["{} {}".format(x[1], x[0]) for x in a[m][n]])
    return "IMPOSSIBLE"
T = int(input().strip())
for C in range(1, T + 1):
    n, m = map(lambda x: int(x.strip()), input().strip().split())
    print("Case #{}: {}".format(C, solve(n, m)))

#include<ctime>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<tuple>
#include<vector>
#include<algorithm>
#define x first
#define y second
#define pb emplace_back
using namespace std;
using ii = pair<int, int>;

int n, m;
vector<ii> s, g[33][33];
bool vis[33][33];

bool possible(int x, int y, int nx, int ny) {
    if (nx == x || ny == y || nx < 1 || ny < 1 || nx > m || ny > n ||
        vis[ny][nx] || (ny - nx) == (y - x) || (ny + nx) == (y + x)) return false;
    return true;
}

void dfs(int x, int y)
{
    vis[y][x] = true;
    s.pb(x, y);
    if (s.size() == (n * m)) throw "ok!";
    const int N = g[x][y].size();
    for (int k = min(max(m, n), 32); k-- && N > 0;) {
        int nx, ny;
        tie(nx, ny) = g[x][y][rand() % N];
        if (possible(x, y, nx, ny))
            dfs(nx, ny);
    }
    vis[y][x] = false;
    s.pop_back();
}

void build_graph()
{
    for (int i = 1; i <= 20; i++) {
        for (int j = 1; j <= 20; j++) {
            g[i][j].clear();
        }
    }

    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            for (int ni = 1; ni <= n; ni++) {
                for (int nj = 1; nj <= m; nj++) {
                    if (possible(j, i, nj, ni))
                        g[j][i].pb(nj, ni);
                }
            }
        }
    }
}

void solve()
{
    memset(vis, 0, sizeof vis);
    scanf("%d%d", &n, &m);
    build_graph();
    try {
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++)
                dfs(j, i);
        }
        puts("IMPOSSIBLE");
    } catch (...) {
        puts("POSSIBLE");
        for (auto& p: s) {
            printf("%d %d\n", p.y, p.x);
        }
    }
}

int main()
{
    srand(time(NULL));
    for (int T, C = scanf("%d", &T); C <= T; ++C) {
        printf("Case #%d: ", C);
        solve();
    }
    return 0;
}

Golf Gophers

18개의 칸에 N만큼의 수가 랜덤한 자연수로 분배되어 더해질 때, 몇 번의 쿼리를 통해 N을 구하는 문제이다. 각 칸은 모듈러 M으로 회전하는데(즉 0 -> 1 -> ... -> M-1 -> 0), 이 M을 칸 별로 직접 지정해서 결과를 쿼리할 수 있다.

문제를 읽으면 딱 Chinese Remainder Theorem이 생각난다. N이 랜덤하게 분배되므로 사용하기 어려울 것 같지만, 각 쿼리에 대해 모두 같은 M을 지정해 주면, Test Set 2의 경우에도 6개의 모듈러를 가지고 CRT를 수행할 수 있다.

from functools import reduce
mod = [5, 7, 11, 13, 17, 18]

def euclid(x, y):
    if y == 0: return x, 1, 0
    g, b, a = euclid(y, x % y)
    return g, a, b - a * (x // y)

def modinv(x, m):
    return (euclid((x % m + m) % m, m)[1] + m) % m

def solve(n):
    s, tot = 0, reduce(lambda x, y: x*y, mod, 1)
    for m in mod:
        print(" ".join([str(m)] * 18), flush=True)
        r = sum([int(x.strip()) for x in input().strip().split()]) % m
        s += r * modinv(tot // m, m) * (tot // m)

    print(s % tot, flush=True)
    input()

T, n, _ = map(int, input().strip().split())
[solve(n) for C in range(1, T + 1)]

Alien Rhyme

N개의 문자열 중 일부를 골라 쌍을 지을 때, 최대한 많은 쌍을 만드는 문제이다. 여기서 쌍을 짓기 위해서는 둘의 접미사가 일치해야 하고, 각 쌍 별로 선택된 접미사가 달라야 한다.

문제를 읽으면, 쌍을 지을 때에 최대한 긴 접미사를 먼저 선택하는 것이 최적이란 사실을 쉽게 떠올릴 수 있다. 이 아이디어를 구현하는 방법에는 여러 방법이 있지만, 나는 Trie와 DFS를 이용해서 아래부터(깊이가 깊은 노드부터) 쌍을 묶도록 구현했다.

class Trie:
    def __init__(self):
        self.link = {}
        self.count = 0
        self.end = False
        self.root = False
    def add(self, s):
        c, i = self, 0
        while i < len(s):
            nc = s[i]
            if nc not in c.link:
                c.link[nc] = Trie()
            c = c.link[nc]
            i += 1
        c.end = True
    def count_pairs(self):
        ans, ret = 0, int(self.end == True)
        for x in self.link.keys():
            a, r = self.link[x].count_pairs()
            ans, ret = ans + a, ret + r

        if ret > 1 and self.root == False:
            ans, ret = ans + 2, ret - 2

        return ans, ret


def solve(ss):
    trie = Trie()
    trie.root = True
    for s in ss: trie.add(s)
    return trie.count_pairs()[0]


T = int(input().strip())
for C in range(1, T + 1):
    n = int(input().strip())
    ss = ["".join(list(reversed(input().strip()))) for _ in range(n)]
    print("Case #{}: {}".format(C, solve(ss)))

Google Code Jam 2018 Round 1A

2019-04-11T14:23:30+00:00

토요일에 GCJ Round 1A를 치기 전에 부랴부랴 2018 기출을 풀어봤다. A, B는 쉬운데 C는 특히 Large가 어려워서 고생했다.

Waffle Choppers
Bit Party
Edgy Baking

Waffle Choppers

R x C 크기의 직사각형 격자(와플)를 가로로 h번, 세로로 v번 잘라서 각 잘린 조각에 들어있는 @(초코칩) 의 개수가 같도록 만들 수 있는지 확인하는 문제이다.

풀이는 간단하게 가로와 세로에 대해 자를 부분을 따로 찾을 수 있다는 것을 이용하면 된다. 가로로 자른 각각의 부분은 초코칩을 (v+1) x (조각 별 초코칩 수) 개 가지고 있어야 한다. 마찬가지로 세로의 경우에도 각 조각이 (h+1) x (조각 별 초코칩 수) 개의 초코칩을 가지고 있어야 한다.

이렇게 자를 부분을 따로 구하고 나면 실제 조각들이 몇 개의 초코칩을 갖게 되는지 알 수 있으므로 마지막 체크만 하면 쉽게 해결할 수 있다.

#include<cstdio>
#include<vector>
using namespace std;
using ll = long long;
const int MAXN = 111;
inline void invariant(bool x) { if (!x) throw x; }

int n, m, h, v, d[MAXN][MAXN];

vector<int> get_cuts(int stake, bool transpose=false) {
    int m = (transpose ? ::n : ::m),
        n = (transpose ? ::m : ::n),
        cuts = (transpose ? v : h),
        div = (transpose ? h : v) + 1;

    vector<int> res(cuts);
    for (int k = 0, i = 1; k < cuts; k++) {
        int choco = 0;
        while (i <= n && choco < div * stake) {
            choco += transpose? (d[m][i] - d[m][i-1]) : (d[i][m] - d[i-1][m]);
            ++i;
        }

        res[k] = i - 1;
        invariant(choco == div * stake);
    }

    return res;
}

bool solve()
{
    for (int i = 1; i <= n; i++) {
        char f[MAXN]{};
        scanf("%s", f+1);
        for (int j = 1; j <= m; j++)
            d[i][j] = f[j] == '@';
    }

    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++)
            d[i][j] += d[i-1][j] + d[i][j-1] - d[i-1][j-1];
    }

    int pieces = (h + 1) * (v + 1);
    int stake = d[n][m] / pieces;
    invariant(d[n][m] % pieces == 0);
    if (stake == 0) return true;

    int pi = 0;
    auto&& vcuts = get_cuts(stake, true);
    auto&& hcuts = get_cuts(stake);
    for (auto& ci: hcuts) {
        int pj = 0;
        for (auto& cj: vcuts) {
            int chocolates = d[ci][cj] - d[pi][cj] - d[ci][pj] + d[pi][pj];
            invariant(chocolates == stake);
            pj = cj;
        }
        pi = ci;
    }

    return true;
}

int main()
{
    for (int T, C = scanf("%d", &T); C <= T; ++C) {
        printf("Case #%d: ", C);
        scanf("%d%d%d%d", &n, &m, &h, &v);
        try {
            solve();
            puts("POSSIBLE");
        } catch (...) {
            puts("IMPOSSIBLE");
        }
    }
    return 0;
}

Bit Party

R대의 로봇이 C대의 서로 다른 계산대를 이용해서 B개의 물품(비트)을 계산하려고 한다. 각 계산대 $i$는 최대 $M_i$개의 비트만을 계산할 수 있고, $N (N ≤ M_i)$개의 비트를 계산하는 데에 $S_i \cdot N + P_i$ 만큼의 시간이 걸린다. 각 로봇이 최소 한 개의 비트를 계산해야 하며, 각자 다른 계산대를 이용해야 할 때, 계산을 모두 끝마치는 데에 걸리는 최소 시간은 얼마일까?

풀이는 바이너리 서치를 이용해서 시간 제한 $T$를 정하고, 해당하는 시간 제한 내에 모든 비트(B개)를 계산할 수 있는지 확인하면 간단하게 구현할 수 있다.

시간 제한이 고정돼 있을 경우에 각 계산대가 계산할 수 있는 비트의 수는 $\mathrm{max}(\mathrm{min}((T - P_i) / S_i, M_i), 0)$ 이 된다. 여기서 가장 많은 수의 비트를 계산할 수 있는 $R$개의 계산대의 비트 수를 더한 것이 바로 시간 제한 T 안에 계산할 수 있는 비트 개수의 최댓값이다.

#include<cstdio>
#include<vector>
#include<numeric>
#include<algorithm>
#define RALL(X) (X).rbegin(),(X).rend()
using namespace std;
using ll = long long;

const int MAXN = 1e3 + 10;

ll n, m, b;
ll s[MAXN], p[MAXN], u[MAXN];

ll calc_max(ll t)
{
    vector<ll> v(n);
    for (int i = 0; i < n; i++) {
        v[i] = max(0LL, min(ll(t - p[i]) / s[i], ll(u[i])));
    }
    sort(RALL(v));
    return accumulate(v.begin(), v.begin() + m, 0LL);
}

ll solve()
{
    ll l = 0, r = 1LL << 60, ans = r;
    while (l <= r) {
        ll mid = (l + r) >> 1;
        if (calc_max(mid) >= b) {
            r = mid - 1;
            ans = mid;
        } else l = mid + 1;
    }
    return ans;
}

int main()
{
    for (int T, C = scanf("%d", &T); C <= T; ++C) {
        scanf("%lld%lld%lld", &m, &b, &n);
        for (int i = 0; i < n; i++) {
            scanf("%lld%lld%lld\n", u + i, s + i, p + i);
        }
        printf("Case #%d: %lld\n", C, solve());
    }
    return 0;
}

Edgy Baking

이건 졸려서 내일..

GitHub 프로필에 이미지 달기

2019-04-10T09:33:30+00:00

어제 GitHub에서 프로필의 Pinned 영역에 이미지를 올리는 재미있는 글을 보았다. 방법은 간단한데, Gist에 이미지를 올리고, 이를 Pin하는 것이다. Gist에 이미지를 어떻게 올리는지는 Loading a thumbnail into Gist for bl.ocks.org d3 graphs 에서 확인할 수 있다. 간단히 요약하면 Gist 또한 일반적인 Git 저장소이므로, 단순히 git clone을 통해 받아온 저장소에 이미지를 추가한 다음 커밋과 푸시를 하면 된다고.

실제로 이렇게 gist를 만들고 커밋한 다음 Pinned 영역에 해당 Gist를 추가하면 이미지가 잘 나오는 것을 볼 수 있다.

Google Code Jam 2019 Qualification Round

2019-04-07T02:33:30+00:00

이번 GCJ 퀄 라운드는 간단한 아이디어로 풀리는 문제가 많아서 재미있었다. 물론 C번은 런타임 에러가 발생할 수 있는 함정이 여럿 있었고, 큰 수 나눗셈 계산이 필요해서 언어 선택에 조금의 제한이 생기기는 했지만.

Foregone Solution
You Can Go Your Own Way
Cryptopangrams
1. 함정: 팰린드롬
Dat Bae

Foregone Solution

4가 한 개 이상 포함된 숫자 N을, 4를 포함하지 않는 두 양의 정수 X와 Y의 합으로 나타내는 문제, 즉 str(X).count('4') == 0 and str(Y).count('4') == 0 and X + Y == N인 X, Y를 아무거나 찾으면 된다. 따라서 풀이는 그냥 4가 나타나는 자리에만 2가 들어가도록 하면 끝!

T = int(input().strip()) + 1
for C in range(1, T):
    x = input().strip()
    a = x.replace('4', '2')
    x = int(x) - int(a)
    print("Case #{}: {} {}".format(C, x, a))

You Can Go Your Own Way

N by N 격자에서 오른쪽과 아래 쪽의 이동만 이용해서 왼쪽 위의 점부터 오른쪽 아래 점으로 이동하는 경로를 출력하는 문제이다. 다만, 하나의 경로가 주어지고, 이 경로와 겹치는 이동이 있어서는 안 된다. 이 문제의 풀이 역시도 정말 간단한데, 두 개의 이동 방법으로 끝 점까지 이동하기 위해서는 N-1 번의 아래 이동과 N-1번의 오른쪽 이동이 필요하다는 것을 이용해서, 주어진 이동 경로의 오른쪽과 아래 이동을 서로 바꾸면 항상 90도 회전한 경로로 이동하므로 겹치지 않고 이동할 수 있다.

T = int(input().strip()) + 1
for C in range(1, T):
    _, x = input(), input().strip()
    a = x.replace('E','s').replace('S','E').replace('s','S')
    print("Case #{}: {}".format(C, a))

Cryptopangrams

N 이하의 소수 중에서 26개를 뽑아 크기 순서대로 각 소수에 A, B, …, Z 를 대응시켰을 때, 알파벳 대문자로 이루어진 팬그램 (모든 알파벳이 한 번 이상 등장하는 문자열) 을 연속된 두 문자에 대응하는 소수의 곱으로 암호화 한 결과가 주어진다. N과 암호화된 정수의 리스트를 가지고 복호화 하는 문제이다.

팬그램이기 때문에 풀이는 매우매우 간단하게 떠오르지만, 이번 라운드에서 가장 많은 함정을 가지고 있는 문제가 아니었을까 싶다.

ABCDEFGHIJKLMNOPQRSTUVWXYZ
6 15 35 77 143 221 323 437 667 899 1147 1517 1763 2021 2491 3127 3599 4087 4757 5183 5767 6557 7387 8633 9797

첫 문자와 마지막 문자를 제외한 모든 문자는 암호문에서 두 번 등장하는 사실을 알 수 있다. 예를 들어 B는 6과 15에 모두 등장하므로, gcd(6, 15) 를 이용해 소수가 3과 대응되는 알파벳이 있음을 알 수 있다. 같은 방법을 반복하면 3, 5, 7, …, 97 총 24개의 소수를 찾을 수 있다. 나머지 두 소수 역시 6을 3으로 나누고, 9797을 97로 나누면 2와 101임을 알 수 있다. 이제 이렇게 얻은 소수에 크기 순서대로 A, B, …, Z 를 대응시키면 끝!

함정: 팰린드롬

A와 B를 너무 쉽게 풀어서, 이것도 간단하겠지~ 하면서 막 내다가, 부끄럽게도.. 결국 테스트 데이터 생성기를 짜고 나서야 이 함정을 깨달았다.

ABACDEFGHIJKLMNOPQRSTUVWXYZ
6 6 10 35 77 143 221 323 437 667 899 1147 1517 1763 2021 2491 3127 3599 4087 4757 5183 5767 6557 7387 8633 9797

실제로는 이렇게 암호문에 같은 수가 등장하는 경우도 고려해주어야 한다. (ABA => 6 6) 아까처럼 무작정 gcd를 구해서 끝내면 소수가 아닌 6이 들어가고 2는 찾지 못할 수 있으니 주의. 사실 n이 작으니까 적당히 2중 루프로 모든 경우를 구해보는 것도 좋은 방법이다. (아래 코드)

from fractions import gcd
from string import ascii_uppercase
def uniq(x): return sorted(list(set(filter(lambda y: y != 1, x))))
alphabet = [x for x in ascii_uppercase]

def decrypt(d, c, s):
    a = [s]
    for i in range(n-1): a.append(c[i] // a[-1])
    return "".join([d[u] for u in (a + [c[-1] // a[-1]])])

T = int(input().strip()) + 1
for C in range(1, T):
    _, n = map(lambda x: int(x.strip()), input().split())
    x = list(map(lambda x: int(x.strip()), input().split()))

    g = uniq(sum([[gcd(a, b) for b in x if gcd(a, b) > 1 and a != b] for a in x], []))
    g = uniq(sum([[a // b for b in g if a % b == 0] for a in x], g))
    d = {p: q for q, p in zip(alphabet, g)}

    for p in filter(lambda p: x[0] % p == 0, g):
        try:
            print("Case #{}: {}".format(C, decrypt(d, x, p)))
            break
        except: pass

Dat Bae

1과 0으로 이루어진 길이 N의 메시지를 보내면 각 컴퓨터가 차례로 자신이 받은 값을 그대로 응답으로 돌려주는 시스템이 있다. 다만 N 대의 컴퓨터 중 B 대가 고장나서 응답을 주지 않는 상태일 때(즉 요청의 길이는 N이지만 응답의 길이는 N - B이다), 최대 F번의 쿼리를 이용해 고장난 B개 컴퓨터의 번호를 찾는 문제이다.

정해와는 조금 다르게, BFS와 비슷한 방법으로 해결했다. 간단하게 스몰(Test Set 1) 문제를 다음과 같은 트리 형태로 나타내어 보자. ([구간 시작, 구간 끝], 구간 내 고장난 머신의 개수)

노드의 개수가 최대 1024개이므로 트리의 높이는 10이 되고, 각 높이 별로 쿼리를 한 번씩 하면 어느 칸이 고장인지 간단히 알 수 있다. 각각의 노드에서 구간을 두 개로 쪼갤 때, 왼쪽 절반에는 1, 오른쪽 절반에는 0을 부여하면 위의 그림처럼 쿼리 결과의 1과 0의 개수를 세어 각 구간에 고장난 머신이 몇 개 존재하는지 알 수 있다.

이를 구간 별로 따로 진행하면 쿼리가 많이 필요하지만, 같은 레벨 (높이) 에 있는 구간을 모아서 처리하면 트리의 높이 만큼, 즉 최대 10번의 쿼리만 이용해서 모든 구간의 고장난 노드의 수를 얻을 수 있다.

Test Set 2 (F = 5) 일 때에는 어떻게 하면 될까? 기존과 같이 트리의 각 레벨 별로 한 번씩 쿼리를 하되, 가능할 경우 구간을 2개보다 잘게 나누어서 높이를 줄이면 된다.

중요한 아이디어는, 구간을 쪼갰을 때 아무리 많이 고장나도 구간 하나가 통째로 지워지지 않을 만큼만 쪼개면 ((length - 1) // broken) 앞서 살펴본, 구간을 2개로 나누는 방법과 거의 똑같이 처리할 수 있다는 것이다.

이렇게 접근했을 때 최악의 경우는 무엇일까? 결국 트리의 높이가 최대한 높아지는 것이 최악인데, 예를 들면 n = 1024, b = 9 ([2, 4, 8, 16, 32, 64, 128, 256, 512]) 가 있다. 그리고 직접 과정을 진행해 보면, 이러한 경우에도 쿼리 5번에 모든 고장난 노드를 찾을 수 있음을 확인 가능하다. (각 쿼리별로 발견하는 노드: [] -> [32, 64, 128, 256] -> [16, 512] -> [2, 4] -> [8])

from sys import stdout

def send(q):
    print("".join([str(x) for x in q]), flush=True)
    res = input().strip()
    if len(res) == 2 and res == "-1": exit(-1)
    return res

def query(length, ranges):
    data = [0] * length
    for pos, length, bit, _, used in ranges:
        if used: continue
        for k in range(length):
            data[k + pos] = bit
    return send(data)

def divide_range(pos, length, bit, broken, used):
    if broken == 0 or length == 0:
        return [], []

    if broken == length:
        return [] if used else [pos + x for x in range(length)], [[pos, length, bit, broken, True]]

    k = max(2, (length-1) // broken)
    m = length // k
    nxt = [[pos + m * j, m, (j+1) % 2, 0, False] for j in range(k-1)]
    nxt += [[pos + m*(k-1), length - m*(k-1), k % 2, 0, False]]

    return [], nxt

def clean(result, bit):
    return result[:result.rfind(str(1 - bit))] if len(result) > 0 and int(result[-1]) != bit else result

def solve(n, broken, f, pos=0):
    q, ans, query_count = [[pos, n, 0, broken, False]], [], 0
    while len(q) > 0 and query_count <= f:
        ranges = [divide_range(*rng) for rng in q]
        ans = sum([rng[0] for rng in ranges], ans)
        q_next = sum([rng[1] for rng in ranges], [])

        if len(q_next) == 0 or query_count >= f: break
        query_res, query_count = query(n, q_next), query_count + 1

        faults, nptr = 0, 0
        for i in range(len(q)):
            pos, length, bit, broken, _ = q[i]
            if broken == length or broken == 0:
                nptr, faults = nptr + int(broken > 0), faults + broken
                continue

            k = max(2, (length-1) // broken)
            m = length // k

            actual_pos, actual_length = pos - faults, length - broken
            result = query_res[actual_pos:actual_pos + actual_length]

            pos = 0
            for j in range(k):
                length = q_next[nptr][1]
                current = clean(result[pos:pos+length], (j + 1) % 2)
                faults_found = length - sum([(j + 1) % 2 == int(x) for x in current])
                q_next[nptr][-2] = faults_found
                pos, faults, nptr = pos + length - faults_found, faults + faults_found, nptr + 1

        q = q_next

    return " ".join([str(x) for x in sorted(ans)])


T = int(input().strip())
for C in range(1, T + 1):
    n, b, f = map(lambda x: int(x.strip()), input().split())
    w = solve(n, b, f)
    print(w, flush=True)
    if int(input().strip()) == -1: exit(-2)

exit(0)

사실 이건 문제의 난이도 보다는 인터랙티브 문제라 테스트가 매끄럽지 않아서 힘들었다.

Ubuntu 서버에서 AFP로 디렉토리 공유하기

2019-04-06T13:49:30+00:00

오늘은 드디어 여행 사진을 보정하려고 했으나, 맥북의 디스크 용량이 너무 부족해서 진행이 어려웠다. 결국 용량 문제를 해결하기 위해서 서버 컴퓨터의 스토리지를 네트워크로 연결하는 방법까지 알아보게 되었다.

Apple Filing Protocol
Install Netatalk 3 on Ubuntu
Mount AFP Remote Volume

Apple Filing Protocol

오늘 처음 알게 된 프로토콜인데, 애플의 독점 파일 서비스 프로토콜로, 가장 흔한 예로는 맥을 Time Machine과 연결할 때에 이용하는 것으로 보인다. 특이한 점으로는 Spotlight와 Avahi(Bonjour)를 지원하는 등 맥의 기능을 대부분 지원하는 점이 있다. 또, 파일의 전송 속도 역시 SMBv3과 비교할 수 있을 만큼 빠르다고 알려져 있다. 개인적으로 SMB와 NFS에는 조금 안좋은 기억이 있기도 하고, 새로운걸 설정해보고 싶은 마음에 이번에는 AFP를 선택해 보았다.

Install Netatalk 3 on Ubuntu

Netatalk는 AFP 서버의 오픈 소스 구현체로, Linux / BSD / UNIX에서 이용할 수 있다. Ubuntu에 기본 패키지로 들어있을 만큼¹ 유서깊은 구현체인 것으로 보여서 우선은 이걸로 시도해 보았다. 기본적인 내용은 공식 매뉴얼을 참고했고, 매뉴얼에 빠진 부분(ㅠㅠ)을 노가다로 채워보았다.

설치는 다음과 같이 빌드하면 끝!

$ sudo apt install -y build-essential \
                      libevent-dev \
                      libssl-dev \
                      libgcrypt-dev \
                      libkrb5-dev \
                      libpam0g-dev \
                      libwrap0-dev \
                      libdb-dev \
                      libdb++-dev \
                      libtdb-dev \
                      libmysqlclient-dev \
                      avahi-daemon \
                      libavahi-client-dev \
                      libacl1-dev \
                      libldap2-dev \
                      libcrack2-dev \
                      systemtap-sdt-dev \
                      libdbus-1-dev \
                      libdbus-glib-1-dev \
                      libglib2.0-dev \
                      libio-socket-inet6-perl \
                      tracker \
                      libtracker-sparql-2.0-dev \
                      libtracker-miner-2.0-dev
# 아래 미러에서 직접 다운로드
# https://sourceforge.net/projects/netatalk/files/netatalk/3.1.12/netatalk-3.1.12.tar.gz/download?use_mirror=jaist&download=
$ tar xf nettalk-3.1.12.tar.gz
$ cd nettalk-3.1.12
$ ./configure \
        --with-init-style=debian-systemd \
        --without-libevent \
        --with-cracklib \
        --without-ldap \ # 저는 안 써요
        --without-kerberos \ # 저는 안 써요
        --with-pam-confdir=/etc/pam.d \
        --with-dbus-daemon=/usr/bin/dbus-daemon \
        --with-dbus-sysconf-dir=/etc/dbus-1/system.d \
        --with-tracker-pkgconfig-version=2.0
        --enable-debian \
        --enable-zeroconf
$ make -j10
$ sudo make install

다만 이대로는 아직 사용할 수가 없고, 서버 설정을 해 주어야 한다. /usr/local/etc/afp.conf를 뜯어고치자!

[Global]
hostname = Shared # <-- 컴퓨터 이름 같은 역할
hosts allow = 0.0.0.0/0 # <-- ACL을 간단하게 CIDR로 설정 가능하다
afp listen = 1.23.45.67:548 # <-- IP:PORT 형태로 Address를 지정해줘도 되고(여러 개도 가능)
afp interfaces = enp0s31f6 # <-- NIC를 지정해주어도 된다.
mimic model = TimeCapsule6,116 # <-- TimeCapsule인 척 해서, 타임캡슐로 사용할 수 있다.
zeroconf = yes # <-- Bonjour (Avahi) 를 이용해서 설정을 단순화
uam list = uams_dhx.so uams_dhx2.so # <-- 암호화 scheme인데, 사실 실제 사용하는지는 잘..
spotlight = yes # <-- Spotlight Indexing 여부
log file = /var/log/netatalk.log
fqdn = my.some.domain:548 # <-- 이렇게 fqdn을 지정해줄 수도 있다.

[Shared] # <-- 이후에 경로명이 됩니다
path = /mnt/ssd2/shared # <-- 서버에서의 실제 디렉토리 경로
valid users = lucent # <-- 유저 제한 ACL

이제 설정까지 고쳤으면, 서비스만 실행하면 끝!!

$ sudo systemctl enable netatalk.service
$ sudo systemctl enable avahi-daemon.service
$ sudo systemctl start netatalk.service
$ sudo systemctl start avahi-daemon.service
$ sudo ufw allow 548/tcp # 방화벽 허용

Mount AFP Remote Volume

맥에서 리모트 디렉토리에 연결하는 방법은 GUI를 이용하면 된다. Finder에서 CMD+K를 누르고, 도메인이나 IP 주소를 입력한 다음 엔터! afp://12.34.56.78나 afp://my.domain 같이 입력하면 된다. 여기까지 성공했다면 로그인 창이 나타나는데, 여기에는 리눅스 계정의 정보를 입력하면 된다.

근데 현재 apt install로 설치하면 제대로 설치되지 않는 문제가 있다. ↩

Google Kick Start 2019A - Parcel

2019-03-25T13:59:59+00:00

2019년의 첫 킥스타트 대회! 엄청 쉬울거라고 생각하고 덤볐으나, 놀라울 정도로 망했다ㅠㅠ 어제 기출로 풀어본 작년 Round H보다 훨씬 어렵게 느껴졌다.

오늘은 2번째 문제였던 Parcel을 풀어보자.

Parcel

격자로 된 도시에 0개 이상의 우체국이 위치하고 있다. 이 도시에 최대 1개의 우체국을 새로 배치할 수 있을 때, 각 격자 점에서 가장 가까운 우체국 까지의 거리 중에서 가장 먼 거리를 최대한 줄여보자. (여기서 거리는 $L_{1}$, 즉 맨하탄 거리이다)

이 문제를 그냥 풀려고 하면 도저히 답이 안 나온다. 이건 풀이를 읽기 전에 한번 고민해보는걸 추천!

우선 $L_1$ 거리의 특징을 알아보자. 실생활에서 일반적으로 가장 많이 이용하는 거리는 $L_2$ (유클리디안) 인데, 두 메트릭에서의 ‘원’ (한 점에서부터의 거리가 같은 점의 집합) 을 나타내면 다음과 같다:

이 문제를 풀기 위해서는 위의 $L_1$과 $L_\infty$를 유심히 살펴볼 필요가 있다. $L_1$에서의 ‘원’은 마름모, 즉 네 변의 길이가 같은 사각형이다. 근데, 이건 그냥 마름모가 아니라 정사각형을 45도 돌린 마름모다! 즉 위 그림에서 $L_1$을 45도 돌리면 $L_\infty$ (chebyshev 거리)가 나온다¹.

이제 이 사실을 가지고 문제를 바꿔서 풀어보면 훨씬 쉬워진다. 우선 답인 ‘최대 거리’를 바이너리 서치를 이용해서 구하도록 하자. 최대 거리를 $r$로 고정하면, ‘기존에 존재하는 우체국을 중심으로 하는 반지름 r의 원’ 으로 덮어지는 점과 덮어지지 않는 점을 아래와 같이 분류할 수 있다:

4	3	2	3	4
3	2	1	2	3
2	1	우	1	2
3	2	1	2	3
(r = 2 인 경우)

이제 새로운 우체국이 같은 반지름으로 나머지 (흰색) 점을 모두 덮을 수 있는지를 확인하면 바이너리 서치의 결정 함수를 완성할 수 있다. (개인적으로는 이 결정 함수를 떠올리는 것이 가장 어려울 것이라 생각한다)

일단 45도를 돌리되, 실수 계산을 피하기 위해 $y+x, y-x$로 좌표를 변환해 보자:

        4      
. 3    
. 2 . 2  
. 1 . 1 . 3
. 2 . 우 . 2  
. 1 . 1    
. 2      
      

. : 원래 격자에는 존재하지 않는 점 (스케일링 이슈)

자, 거리가 같은 점의 집합이 정사각형으로 바뀌어서 살펴보기 쉬워졌다!! 이제 여기서 ‘아직 안 덮어진’ 점을 모두 덮는 정사각형의 크기를 찾아서, 이를 다시 반지름과 비교하면 간단하게 완성♪

#include<queue>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define x first
#define y second
#define pb emplace_back
using namespace std;
using ii = pair<int, int>;

int n, m;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
int dist[255][255];

vector<ii> get_extreme(int r, vector<ii> & pts)
{
    if (dist[1][1] > 9999) {
        queue<ii> q;
        for (auto& p: pts) {
            q.push(p);
            dist[p.y][p.x] = 0;
        }

        while (!q.empty()) {
            auto p = q.front(); q.pop();
            for (int i = 0; i < 4; i++) {
                ii np{p.x + dx[i], p.y + dy[i]};
                if (np.x < 1 || np.y < 1 || np.x > m || np.y > n)
                    continue;
                int ndist = dist[p.y][p.x] + 1;
                if (ndist < dist[np.y][np.x]) {
                    dist[np.y][np.x] = ndist;
                    q.emplace(np);
                }
            }
        }
    }

    vector<ii> extreme;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++)
            if (dist[i][j] > r)
                extreme.pb(j, i);
    }

    return extreme;
}

bool cover(int r, vector<ii> & pts)
{
    int maxx = -9999, maxy = -9999,
        minx = +9999, miny = +9999;

    vector<ii> && extreme = get_extreme(r, pts);
    for (auto& p: extreme) {
        minx = min(minx, p.x + p.y);
        maxx = max(maxx, p.x + p.y);
        miny = min(miny, p.y - p.x);
        maxy = max(maxy, p.y - p.x);
    }

    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            int x = i + j;
            int y = i - j;
            if (r >= max({x - minx, y - miny, maxx - x, maxy - y}))
                return true;
        }
    }

    return false;
}

int solve(vector<ii> & pts)
{
    int le = 0, ri = m + n, ans = ri;
    while (le <= ri) {
        int mid = (le + ri) >> 1;
        if (cover(mid, pts)) {
            ri = mid - 1;
            ans = mid;
        } else {
            le = mid + 1;
        }
    }
    return ans;
}

int main()
{
    int T;
    scanf("%d", &T);
    for (int C = 1; C <= T; C++) {
        scanf("%d%d", &n, &m);
        memset(dist, 0x77, sizeof dist);

        vector<ii> pts;
        for (int i = 1; i <= n; i++) {
            char f[255]{};
            scanf("%s", f + 1);
            for (int j = 1; j <= m; j++)
                if (f[j] == '1') pts.pb(j, i);
        }

        printf("Case #%d: %d\n", C, solve(pts));
    }
    return 0;
}

이 회전 관계는 2차원에서만 성립한다. ↩

Google Kick Start 2018 - Round H

2019-03-23T15:59:59+00:00

Goolge Kick Start가 열린다는 메일을 받고 부랴부랴 기출문제를 풀어보았다. Kick Start는 간단히 말해서 Code Jam 보다 쉬운 대회로, “구글에서 일하기 위해 필요한 기술들을 맛볼 수 있는” 대회라고 한다.

The three-hour rounds feature a variety of algorithmic challenges, all developed by Google engineers so that you get a taste of the technical skills needed for a career at Google.

오늘 소개할 문제들은 Kick Start 2018 Round H의 문제들이다.

Big Buttons
Mural
Let Me Count The Ways

Big Buttons

R과 B로 길이가 N인 문자열을 만들 때, 주어진 p개의 prefix 중 어느 것과도 겹치지 않는 prefix로 시작하는 문자열의 개수를 구하는 문제이다.

풀이는 간단하게 주어진 prefix 로 Trie를 만들고, 루트부터 탐색해서 링크가 끊어지는 부분을 찾아서 개수를 세면 된다. 사용 가능한 문자가 R과 B 뿐이므로 개수는 쉽게 셀 수 있다. ($2^n$ 꼴)

class Trie:
    def __init__(self):
        self.link = {}
        self.end = False
    def add(self, s):
        c, i = self, 0
        while i < len(s):
            nc = s[i]
            if nc not in c.link:
                c.link[nc] = Trie()
            c = c.link[nc]
            i += 1
        c.end = True
    def count_feasible(self, n):
        if self.end or n <= 0: return 0
        ret = 0
        for x in ['R', 'B']:
            if x not in self.link:
                ret += 1 << (n - 1)
                continue
            ret += self.link[x].count_feasible(n - 1)
        return ret

def solve(n, ss):
    trie = Trie()
    for s in ss: trie.add(s)
    return trie.count_feasible(n)

T = int(input().strip())
for C in range(1, T + 1):
    n, p = map(int, input().split())
    ss = [input().strip() for _ in range(p)]
    print("Case #{}: {}".format(C, solve(n, ss)))

Mural

일렬로 서 있는 n개의 벽에 그림을 그리려 한다. 처음 그림을 그릴 벽은 마음대로 선택할 수 있고, 이후에는 먼저 그림을 그린 벽과 인접한 벽에만 그릴 수 있다.

그림을 하나 그릴 때마다 그림과 인접하지 않은 끝 벽이 한 개씩 무너져내린다고 할 때, 벽이 어떻게 무너지든 상관 없이 확실히 얻을 수 있는 최대의 아름다움을 계산해보자. (아름다움은 그림이 그려진 벽의 점수 (*문자열로 주어진다) 의 합이다)

그냥 보면 왼쪽 벽이 무너질지 오른쪽 벽이 무너질지 고민이 되지만, 사실 연속된 (n+1) / 2 개의 벽은 모두 선택해볼 수 있다:

그림이 그려진 벽과 인접한 벽 또한 무너지지 않기 때문에, 실제로 무너지기 전에 그림을 그려야 할 벽은 (n+1) / 2 - 2 개가 된다 (양 끝에 인접한 벽에는 가장 마지막에 그리면 되므로). 이러한 조건을 고려하면, 무조건 ‘중간 벽’부터 선택할 경우 예외 없이 항상 그릴 수 있는 것을 확인할 수 있다.

따라서 partial sum 을 구해두고, 가능한 (n+1) / 2 개의 연속된 벽의 아름다움 중 가장 큰 것을 구하면 끝!

def solve(n, s):
    ans = 0
    d = [0] * (n + 1)
    for i in range(1, n + 1): d[i] = d[i-1] + int(s[i])
    for i in range(0, n // 2 + 1):
        ans = max(ans, d[i + (n+1) // 2] - d[i])
    return ans

T = int(input().strip())
for C in range(1, T + 1):
    n = int(input().strip())
    print("Case #{}: {}".format(C, solve(n, '0' + input().strip())))

Let Me Count The Ways

n 쌍의 커플을 아주 긴 배에 일렬로 태우려 한다. 이중 m 쌍의 신혼 커플은 서로 인접한 자리에 태우지 않는 경우의 수를 구해보자.

Inclusion-Exclusion (포함-배제) 원리 ($|A\cup B| = |A| + |B| - |A\cap B|$) 로 해결할 수 있다. 원래 이런 방법을 이용할 때에는 모든 집합을 살펴보기 때문에 $2^n$ 의 복잡도를 갖지만, 여기서는 각 집합의 크기가 동일하므로 $O(m)$ 개의 집합만 살펴보면 해결할 수 있다.

귀찮은 점으로는, n 과 m 이 큰 경우가 있어서 큰 수 모듈러 계산을 해야한다는 것이 있다.

from functools import lru_cache
factorials = [1]
MOD = 1000000007

def factorial(n):
    while len(factorials) <= n:
        factorials.append(factorials[-1] * len(factorials) % MOD)
    return factorials[n]

@lru_cache(maxsize=None)
def modpow(n, m):
    ret = 1
    while m > 0:
        if m & 1 > 0:
            ret = ret * n % MOD
        n = n * n % MOD
        m >>= 1
    return ret

@lru_cache(maxsize=None)
def factorial_inverse(n):
    return modpow(factorial(n), MOD - 2)

def binomial(n, k):
    return factorial(n) *\
           factorial_inverse(k) % MOD *\
           factorial_inverse(n - k) % MOD

def solve(n, m):
    ans = factorial(n * 2)
    for k in range(1, m + 1):
        sign = -2 * int(k % 2 > 0) + 1
        val = binomial(m, k) *\
              binomial(2 * n - k, k) % MOD *\
              factorial(k) % MOD *\
              factorial(2 * (n - k)) % MOD *\
              modpow(2, k) % MOD
        ans += sign * val
    return (ans % MOD + MOD) % MOD

T = int(input().strip())
for C in range(1, T + 1):
    n, m = map(int, input().split())
    print("Case #{}: {}".format(C, solve(n, m)))

Trie

2019-03-23T14:59:59+00:00

Trie란 Prefix Tree나 Radix Tree라고도 불리는 트리 형태의 자료구조로, reTRIEval 에서 유래한 이름을 가지고 있다.

Trie는 각 노드가 string으로 된 key를 나타내고, 각 엣지 (간선)가 하나의 알파벳을 나타내는 트리 형태의 자료구조로, key-value 쌍을 저장하도록 하면 map처럼 associative array로 이용할 수 있고, 그냥 key만 저장하면 어떤 string이 집합에 속하는지 확인하기 위한 set처럼 삽입/삭제가 가능한 집합 자료구조로 이용할 수 있다.

흔히 사용되는 std::map/std::set의 내부 구현인 Red-black tree (balanced binary search tree/self-balancing binary search tree)와 비교해보면 각 연산 (검색, 삽입)이 다음과 같은 시간 복잡도를 갖는다 ($L$: key로 이용되는 문자열의 최대 길이, $N$: key의 개수, 즉 자료구조의 원소 개수):

연산	BBST	Trie
삽입	$O(L\mathrm{log}N)$	$O(L)$
검색	$O(L\mathrm{log}N)$	$O(L)$

{"AA", "AC", "BC", "BCG", "C", "CC"} 의 문자열을 원소로 갖는 Trie를 그림으로 나타내면 다음과 같다:

$\otimes$로 표현되는 노드는 해당 노드로 끝나는 문자열이 존재한다는 의미인데, 예를 들어 이 집합에 "A"는 존재하지 않지만 "AA"는 존재하므로 "AA"를 나타내는 노드에서는 $\otimes$로 표현되는 노드로의 간선이 존재하지만 "A"를 나타내는 노드에서는 간선이 존재하지 않는 것을 확인할 수 있다. (이후 $\otimes$ 로 나타나는 노드로 연결되는 간선을 "$"로 표현)

연산의 경우 BST처럼 삽입 과정이 검색과 굉장히 닮아있기 때문에, 검색부터 살펴보도록 하자.

"BCG"를 검색하는 경우
"A"를 검색하는 경우
삽입
삭제

`"BCG"`를 검색하는 경우

루트에서 시작해서, 해당 알파벳을 나타내는 간선을 따라 쭉쭉 따라가면 끝. 단, "BGC"를 "BCG$"로 고려해야 한다. 만약 중간에 NULL을 만나게 된다면 (존재하지 않는 간선을 선택하게 된다면) 해당 문자열은 집합에 존재하지 않는다는 결론이 나오고, 그렇지 않을 경우 해당 문자열이 집합에 존재한다는 것을 확인할 수 있다.

`"A"`를 검색하는 경우

마찬가지로 "A$"를 생각하면, 중간에 $을 나타내는 간선이 존재하지 않아 실패하는 것을 볼 수 있다.

삽입

검색을 보면서 깨달았겠지만, 삽입은 검색을 하는 도중 실패한 부분부터 간선을 추가해나가는 식으로 반복하면 간단!

삭제

삭제 역시도 각 노드에 rereference count 를 관리하면서 0이 되는 순간 노드와 간선을 지워주는 형태로 구현하면 간단하다.

Google 설문지 응답을 POST로 받기

2019-03-22T12:59:59+00:00

스크립트 만들기
스크립트 연동 및 실행하기

스크립트 만들기

응답이 기록되는 스프레드 시트에서 스크립트 에디터를 열자. Google Apps Script는 기본적으로 ECMAScript에 G Suite에 접근하는 기능이 추가된 것¹으로, 스크립트가 구글의 서버에서 실행되는 특징을 갖는다.

설문지 응답에 트리거를 거는 방법과 응답 내용을 JSON POST 요청을 보내는 방법, 그리고 로깅을 하는 기본적인 방법을 적어보면 다음과 같다.

특이한 점으로는 코드의 실행 단위가 함수이기 때문에 트리거를 걸어주는 부분도 함수로 만들어야 한다는 것이 있다.

function setUp() {
  ScriptApp.newTrigger('onFormSubmit').forSpreadsheet(SpreadsheetApp.getActive()).onFormSubmit().create();
}

function onFormSubmit(e) {
  e = e.namedValues;
  e['name'] = e['field1'][0];
  e['title'] = e['field2'][0];
  e['content'] = e['field2'][0];
  var options = {
    'method' : 'post',
    'contentType': 'application/json',
    'payload' : JSON.stringify(e)
  };
  Logger.log(UrlFetchApp.fetch('http://some-http-url/post-endpoint', options));
}

스크립트 연동 및 실행하기

이렇게 작성한 코드를 스프레드 시트에서 실행하는 방법을 알아보자.

우선 이렇게 방금 작성한 함수를 가져오고

함수들을 등록한 다음

아까 트리거를 걸어주는 함수만 실행하면 완료!

지정해둔 URL로 POST 요청이 오는 것을 확인할 수 있다. 덧붙여서 Logger로 출력한 로그는 스크립트 에디터의 메뉴에서 확인할 수 있다.

overview 에 자세히 적혀있다 ↩

odd-even-linked list

2019-03-21T14:59:59+00:00

문제 링크. O(n) 시간과 O(1) 공간으로 해결해보자.

Input:  1->2->3->4->5->null
Output: 1->3->5->2->4->null

홀수 리스트와 짝수 리스트를 분리한 다음 둘을 연결하는 것으로 쉽게 해결할 수 있다: 홀수 리스트와 짝수 리스트는 포인터를 두 칸씩 전진하면 구할 수 있다. 이렇게 분리한 두 리스트를, 미리 저장해두었던 짝수 리스트의 첫 원소 포인터를 이용해 붙여주면 끝!

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
struct Solution {
    ListNode* oddEvenList(ListNode * head) {
        if (head == nullptr) return nullptr; // 빈 리스트가 들어올 수 있다.
        auto * odd  = head;
        auto * even = head -> next;
        auto * conn = even;
        while (odd -> next != nullptr && even -> next != nullptr) {
            auto * odd_next  = odd  -> next -> next;
            auto * even_next = even -> next -> next;
            odd  -> next = odd_next;
            even -> next = even_next;
            odd  = odd  -> next;
            even = even -> next;
        }
        odd -> next = conn;
        return head;
    }
};

Wilson’s Theorem

2019-03-20T14:09:00+00:00

오늘 트위터에서 쌍둥이 소수 $p, p + 2$가 있을 때, $p! ~\mathrm{mod}~ p + 2$를 구해보자! 라는 타래를 보고 예에전 학부때 배운 정수론이 떠올라서 기록해보았다.

윌슨 정리

$(p - 1)! \equiv -1 ~\mathrm{mod}~ p \text{ if and only if } p \text{ is a prime.}$

이 정리를 이용해서 처음의 문제를 풀면 굉장히 간단하게 풀린다: 이를 이용하면 $(p+1)! \equiv -1 ~\mathrm{mod}~ p+2 $ 임을 알 수 있고, 이는 다시 $(p+1)! \cdot (p+1)^{-1} \equiv -1 \cdot -1 \equiv 1 ~\mathrm{mod}~ p+2$로 깔끔하게 정리된다.

윌슨 정리의 증명

1. $p \text{ is a prime } \Rightarrow (p - 1)! \equiv -1 ~\mathrm{mod}~ p$

($p=2$일 때에는 성립하니까 $3$ 이상의 $p$에 대해서만 생각해보자) $x \in \{1, 2, …, p-1\}$은 모두 $p$와 서로소 관계이므로 각 $x$에 대해 $x\cdot{x^*}\equiv 1~\mathrm{mod}~ p$인 $x^* \in \{1, 2, …, p-1\}$가 존재한다. 여기서, $xx^* \equiv 1 ~\mathrm{mod}~ p$가 되는 $x$ 중에는 $x \equiv x^* ~\mathrm{mod}~ p$인 경우도 존재하는데, 이러한 경우에 $x \equiv \pm 1 ~\mathrm{mod}~ p$ 임을 알 수 있다(즉 $x = 1$ 또는 $x = p-1$). 따라서 $(p-1)! \equiv (p-1) \cdot 1 \cdot (p-2) \cdot … \cdot 2 \equiv -1 \cdot 1 \cdot 1 \equiv -1 ~\mathrm{mod}~ p$ 임을 확인할 수 있다.

2. $(p - 1)! \equiv -1 ~\mathrm{mod}~ p \Rightarrow p \text{ is a prime. } $

($p \leq 4$일 때에는 성립하니까 5 이상인 $p$에 대해서만 생각해보자) $p$가 소수가 아니라고(즉 $q | p$인 소수 $q$ 가 존재한다고) 가정하자. 이 경우 $q < p$이므로 $q | (p - 1)!$라는 결과가 나오는데, 이는 결국 $q \cdot q’ = p$인 $q$가 존재함을 의미하므로 $(p - 1)! = 0 \mathrm{mod} p$가 되어 모순이다. 따라서 $p$가 소수임을 확인할 수 있다.

간만에 ps

2019-03-19T14:21:00+00:00

오늘은 시간이 없어서 뭔가 기록할 만큼 공부한건 없고, 타임라인에 문제가 보이길래 오랜만에 또 ps 문제를 풀어봤다.

문제를 읽고 떠오르는 몇 가지 중요한 관찰을 적어보자.

주어진 바구니의 위치를 정렬했을 때, 방문한 지점은 $[l, r]$ 처럼 연속된 형태여야 한다. (이동중에 지나게 되는 사탕을 먹지 않으면 손해니까)
모든 바구니의 사탕 수가 동일하므로, 문제를 바꿔 생각할 수 있다: $t_i$를 $i$번째 사탕 바구니에 방문했을 때의 시간이라고 하면, $~\mathrm{maximize}~ m \cdot n - (t_1 + t_2 + … + t_n)$ $\Leftrightarrow ~\mathrm{minimize}~ \sum_{i=1}^n t_i$ 을 풀면 된다.

이걸로 충분하면 좋겠으나, 아직 해결해야 할 의문이 남아있다.

과연 모든 사탕을 먹는게 최적일까? 당연히 아니다. 어떤 $k < n$인 $k$에 대해, $t_k \geq m$이 되면 더 이상의 바구니를 방문할 이유가 없으니까.
$k$개의 바구니만 방문하는 경우에 방문하게 되는 바구니의 구간은 $k-1$개의 바구니만 방문하는 경우의 구간을 포함할까? 이게 되면 바이너리 서치를 통해 최적의 $k$를 찾을 수 있을 텐데, 아쉽게도 성립하지 않는 케이스를 찾을 수 있다: 바구니가 [-99, -98, -97, -1, 0, 1, 50, 100] 과 같이 놓여있는 경우, 4개의 바구니를 방문하는 경우와 5개의 바구니를 방문하는 경우에 방문하게 되는 바구니의 구간이 전혀 다름을 확인할 수 있다.

지금까지 생각해본 내용을 바탕으로 해법을 구상하면 이렇게 정리할 수 있다.

상태를 $(\mathrm{left}~, ~\mathrm{right}~, ~\mathrm{is\_right}~, ~\mathrm{remaining})$ 으로 정의하고, 다이나믹 프로그래밍으로 최소 시간을 구하자! $~\mathrm{left}~, ~\mathrm{right}~$: 이미 방문한 구간의 끝 점, $~\mathrm{is\_right}~$: 현재 위치가 오른쪽 끝 점인지의 여부, $~\mathrm{remaining}~$: 앞으로 몇 개의 바구니를 더 선택할 예정인지.
- $O(n^3)$의 시간과 공간으로 문제를 해결할 수 있다.
- 각 $~\mathrm{remaining}~$에 대해 배열을 재활용하면 공간복잡도는 $O(n^2)$으로 줄일 수 있다.

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
using ll = long long;

int n, m;
int c[311];
ll d[2][311][311];

ll candy(int l, int r, int right, int k)
{
    if (k == 0) return 0;
    ll & ret = d[right][l][r];
    if (ret != -1) return ret;
    ret = m *1LL* k;

    int pos = right ? c[r] : c[l];
    if (l > 0) {
        int dist = abs(pos - c[l - 1]);
        ret = min(ret, candy(l - 1, r, 0, k - 1) + dist *1LL* k);
    }

    if (r + 1 < n) {
        int dist = abs(pos - c[r + 1]);
        ret = min(ret, candy(l, r + 1, 1, k - 1) + dist *1LL* k);
    }

    return ret;
}

int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 0; i < n; i++) scanf("%d", c + i);

    int has_zero = 1;
    if (find(c, c + n, 0) - c >= n) c[n++] = has_zero = 0;

    sort(c, c + n);
    int start = lower_bound(c, c + n, 0) - c;

    ll ans = 0;
    for (int k = n; k > 0; k--) {
        memset(d, -1, sizeof d);
        ans = max(ans, m *1LL* k - candy(start, start, 0, k - 1));
    }

    printf("%lld", ans - m * !has_zero);
    return 0;
}

TIL 블로그 개설

2019-03-18T12:14:00+00:00

습관 개선을 위해 또 한번, 100일 커밋 프로젝트에 참여하게 됐다. 이번에는 구체적인 계획 없이 그냥 뭐든 그날 그날 알게 된 내용을 이렇게 짧은 글로 기록한 다음, 주말에 내용을 모아서 블로그에 포스트를 써 보는 것을 목표로 해야지.

오늘은 무슨 일인지 막상 공부를 해 보려고 핸드폰에 띄워 둔 수백 개의 탭을 훑어 보아도 좀처럼 흥미가 생기는 주제가 없어서, 이번 주의 테마는 “여행 갈 준비나 해 보자!” 로 정했다. 3월 말 ~ 4월 초에 벚꽃을 보러 교토를 방문할 막연한 생각을 갖고 있는데, 구체적으로 어디를 방문할지, … 를 정리해 봐야지!

벚꽃 개화 시기

tenki.jp를 보면, 교토, 효고의 경우 대략 3월 25일 정도에 벚꽃이 개화하여 4월 2일 정도에 만개할 예정이라고 한다.

지도

방문하고 싶은 곳들을 지도으로 정리해보고 있다.
1. 우선 가장 보고싶은 곳은 수로각