멍멍멍

[텐서플로우] 3차원 이상의 텐서 사이의 행렬 곱(tf.matmul)

bowbowbow — Sun, 24 Mar 2019 16:04:18 +0900

3차원 이상의 텐서 사이의 행렬 곱 - 텐서플로우

- 목차

3차원 텐서 사이의 행렬 곱

텐서플로우를 처음 접하고 텐서플로우 코드를 보다가 아래 예시 코드처럼 3차원 텐서 사이에서 행렬 곱(tf.matmul)을 하는 코드를 만났습니다. 행렬 곱은 2차원에서만 정의되는 줄 알고 있었는데 3차원 텐서에서도 어떻게 행렬 곱(tf.matmul)함수가 사용 가능한 건지 의문이 들었습니다.

A = tf.Variable(tf.random_normal([2, 2, 3]))
B = tf.Variable(tf.random_normal([2, 3, 7]))
C = tf.matmul(A, B)

텐서플로우에서 텐서는 다차원 행렬, 코드상에서는 다차원 배열을 나타냅니다. 1차원 텐서는 벡터이고 코드 상에서 [1, 2, 3]과 같은 1차원 배열입니다. 2차원 텐서는 우리가 잘 알고 있는 행렬이며 코드상에서 [[1, 2 ,3], [4, 5, 6]]과 같은 2차원 배열입니다. 3차원 텐서는 행렬을 여러 층 쌓은 것이고 코드상에서 [[[1, 2] ,[3, 4]], [[4, 5], [6, 7]]]와 같은 3차원 배열입니다.

위 코드를 아래와 같이 실행해보니 오류 없이 잘 실행됐고 C의 차원으로 2x2x7을 얻었습니다.

sess = tf.Session()
sess.run(tf.global_variables_initializer())
C = sess.run(C)
print(C.shape) # C의 차원 출력

어떻게 작동하는걸까?

행렬 곱은 2차원에서만 정의되는데 어떻게 3차원 텐서에서 행렬 곱(tf.matmul)을 사용할 수 있을까요?

알아보니 두 개의 3차원 텐서 사이의 행렬 곱(tf.matmul)은 단순히 아래 그림1처럼 2차원 행렬을 여러 층으로 쌓은 3차원 텐서에서 각 층 사이의 2차원 행렬 간의 곱을 리턴합니다.

그림1. 3차원 텐서 사이의 행렬 곱 예시

따라서 3차원 텐서 사이의 행렬 곱(tf.matmul)을 이용하면 아래 코드와 같이 2차원 행렬 곱 두 개를 더 간편하게 나타낼 수 있습니다.

A0 = tf.Variable(tf.random_normal([2, 3]))
A1 = tf.Variable(tf.random_normal([2, 3]))

B0 = tf.Variable(tf.random_normal([3, 7]))
B1 = tf.Variable(tf.random_normal([3, 7]))

# 2차원 행렬 곱
C0 = tf.matmul(A0, B0)
C1 = tf.matmul(A1, B1)

# 3차원 텐서의 행렬 곱으로 나타내면
A = tf.stack([A0, A1]) # shape: 2x2x3
B = tf.stack([B0, B1]) # shape: 2x3x7
C = tf.matmul(A, B) # shape: 2x2x7

텐서플로우를 돌릴 때 보통 N개의 입력으로 구성된 배치(Batch)를 만들어서 런합니다. 이 때 N개의 행렬을 곱하는 상황이 빈번한데 이를 한 줄로 간편하게 하기 위해 3차원 텐서 사이의 행렬 곱 함수(tf.matmul)가 이렇게 작동하는 것입니다.

5차원 텐서 사이의 행렬 곱

그러면 아래와 같이 5차원 텐서 사이의 행렬 곱(tf.matmul)도 작동할까요?

A = tf.Variable(tf.random_normal([5, 4, 10, 2, 3]))
B = tf.Variable(tf.random_normal([5, 4, 10, 3, 7]))
C = tf.matmul(A, B)

가능합니다! 위 코드를 아래와 같이 실행해보면 오류 없이 잘 실행되고 C의 차원으로 5x4x10x2x7을 얻었습니다.

이를 통해 3차원 이상의 텐서 사이의 행렬 곱은 행렬의 차원을 나타내는 마지막 두 개의 차원(2x3, 3x7) 사이에 행렬 곱이 가능하고 행렬 앞에 있는 차원(5x4x10)이 같으면 가능한 것을 알 수 있습니다.

[자료구조]Union-Find: Disjoint Set의 표현

알 수 없는 사용자 — Wed, 6 Jul 2016 14:37:37 +0900

Union-Find 란?

Union-Find 란 Disjoint Set 을 표현할 때 사용하는 독특한 형태의 자료구조로,

공통 원소가 없는, 즉 "상호 배타적" 인 부분 집합 들로 나눠진 원소들에 대한 정보를 저장하고 조작하는 자료구조

입니다.

위의 상황을 표현하기 위해서는 초기화 과정과 다음과 같은 두 가지 연산을 지원해야 하기 때문에, Union-Find 자료구조 라고 부르게 되었다고 합니다.

Union-Find 지원 연산

초기화 : N 개의 원소가 각각의 집합에 포함되어 있도록 초기화 합니다.
Union (합치기) 연산 : 두 원소 a, b 가 주어질 때, 이들이 속한 두 집합을 하나로 합칩니다.
Find (찾기) 연산 : 어떤 원소 a 가 주어질 때, 이 원소가 속한 집합을 반환합니다.

Union-Find 의 구현

Union-Find의 실제 구현은 주로 트리구조를 이용하는데, 왜 배열은 이용하지 않는지, 트리를 사용하였을 때의 장점은 무었인지에 대해 알아보도록 하겠습니다.

배열로 표현하기

가장 간단한 방법으로 1차원 배열로 집합을 표현합니다.

예를 들어

번 원소가 속하는 집합의 번호

라 하면

Union-Find 지원 연산

초기화 : 와 같이 각자 다른 집합 번호로 초기화 해줍니다.
Union (합치기) 연산 : 두 집합을 합치기 위해 배열의 모든 원소를 순회 하면서 하나의 집합 번호를 나머지 한개의 집합 번호로 교체합니다. 아래의 그림은 3번 집합을 2번 집합으로 합치는 과정입니다. (

Find (찾기) 연산 : 한 번만에 원소가 속하는 집합 번호를 알 수 있습니다. ( )

배열로 Union-Find를 구현 할 수는 있지만, 위에서 보았듯 Union 연산 수행 시 배열의 모든 원소를 순회해야 하기 때문에 시간복잡도가 이 됩니다.
물론 Find 연산은 빠르지만, Union 연산 수행 횟수가 많기 때문에 우리는 더 빠른 Union 연산을 원합니다.
더 좋은 방법은 없을까요?

트리로 표현하기

바로 트리 로 Union-Find 를 구현하면 배열보다 빠르게 Union 연산을 수행할 수 있습니다.
세 가지 연산에 대해 알아보기 전에, 트리 구조로 표현하기 위해 필요한 기본적인 내용을 먼저 알아 봅시다.

Base 1
한 집합에 속하는 원소들을 하나의 트리로 묶어주기 때문에, 자료구조는 아래 그림과 같이 트리 들의 집합으로 표현됩니다.

Base 2
트리 구조 에는 트리의 대표 노드 라고도 볼 수 있는 루트 노드 가 존재 하므로, 각 원소가 속하는 집합 번호를 바로 이 루트 노드의 원소로 정합니다.

Base 3
Union 연산을 수행하기 위해서는 두 원소가 같은 집합에 속하는지를 먼저 확인한 후, 다른 집합에 속할 때만 합쳐야 합니다.
같은 집합에 속한다는 뜻은, 같은 루트 노드를 가진다는 말과 대응되므로 어떤 원소의 루트 노드 를 찾는 Find 연산을 지원해야 합니다.

Base 4
이러한 Find 연산을 지원하기 위해서 모든 자식 노드가 부모에 대한 포인터 정보를 가지고 있도록 합니다. 이러한 설정은 가진 정보를 바탕으로 포인터를 따라가 결과적으로 최종 부모인 루트 노드 가 무었인지 찾을 수 있게 됩니다.
단, 부모 노드에서 자식 노드로 내려가는 일은 발생하지 않기 때문에, 부모가 자식에 대한 포인터 정보는 가질 필요가 없습니다.

이를 바탕으로 지원해야 하는 연산을 알아봅시다.

Union-Find 지원 연산

초기화 : 모두 각자 다른 집합이 됩니다. 각 노드는 모두 루트 노드 가 되며 N 개의 루트 노드를 생성하고 자기 자신을 가리키는 포인터를 가지도록 설정합니다.
Union (합치기) 연산 : 각 트리의 루트를 찾은 뒤, 다르다면 하나를 다른 한쪽의 자손으로 넣어 두 트리를 합칩니다.
Find (찾기) 연산 : 각 노드에 저장된 포인터 정보를 따라가 주어진 원소가 포함된 트리의 루트 노드를 찾습니다. ( 트리의 높이와 시간복잡도가 비례 )

이와 같이 Union-Find를 트리 구조로도 나타내 보았습니다. Find 연산 수행 시 걸리는 시간이 트리의 높이 와 비례하게 되고, Union 연산 수행시간 역시 Find 연산 수행 시간이 지배하게 됩니다.
이처럼 Union 연산시간 복잡도가 배열로 나타내었을 때의 보다 줄어 들었음을 알 수 있습니다.

트리로 표현하기 : 실제 소스코드

최적화 하기

이와 같이 트리로 구현하는 방법에는 큰 문제점이 발생할 수 있습니다.
바로 최악의 경우 완전히 비대칭 적인 트리, 즉 연결 리스트 형태가 되어버릴 수 있다는 것입니다.
예를 들어 두 트리 a 와 b 를 합칠 때, a 의 루트 노드를 항상 b 의 루트 노드의 자식으로 넣는다고 가정한다면, 다음과 같이

원소의 갯수가 일때, 트리의 높이가 인, 트리의 장점을 전혀 살릴 수 없는 연결 리스트 형태가 되고 맙니다.
이렇게 되면 Union 연산도, Find 연산도 수행시간이 이 되어버려 배열로 구현했을 때 보다도 효율이 나빠지게 됩니다.

이 문제는 두 트리를 합칠 때, 항상 높이가 더 낮은 트리를 높은 트리 밑에 넣음 으로써 해결가능 합니다. 이렇게 되면 트리의 높이가 크게 높아지는 상황을 방지 할 수 있습니다.

이러한 최적화를 union-by-rank 라 하며, 여기서 rank 는 해당 트리의 높이를 저장합니다.

최적화 하기 : 실제 소스코드

위의 코드에서 경로 압축 최적화 ( path compression ) 과정도 함께 추가 되었는데, 이를 수행하면 다음 그림과 같습니다.

Union-Find 정리

위의 최적화 과정을 모두 적용한 Disjoint Set 의 연산 수행시간은 분석하기 아주 어렵습니다. 왜냐하면 Find 연산을 호출 할 때마다 수행시간이 달라지기 때문입니다. ( 트리의 높이 변화에 의해 )

참고한 책에 의하면 평균 수행시간은 로, 여기서

은 에커만 함수를 이용해 정의되는 함수

로 거의 모든 크기의 에 대해 4 이하의 값을 가진다고 합니다. 즉, 현실적인 모든 입력에 대해 상수시간에 동작한다고 봐도 무관 하다고 합니다.

이처럼 Union-Find 는 그 자체로 구현이 매우 간단하고 동작 속도가 아주 빠르기 때문에 다른 알고리즘의 일부로 자주 사용됩니다.

추가적으로

그래프의 연결성 확인 ( 크루스칼 알고리즘 등 )
가장 큰 집합 추적

등의 문제에 Union-Find 를 적용하여 해결해 보시기 바랍니다.

끝

[알고리즘 문제해결전략 책을 참고해서 작성했습니다]

삼성 대학생 프로그래밍 대회(SCPC) 2016 1차 예선 풀이

bowbowbow — Thu, 30 Jun 2016 10:11:41 +0900

SCPC 2016 1차 예선 풀이

구현
재귀 함수로 위 과정을 구현했습니다. 코드는 주석으로 설명했습니다. 주의할 점 : 문제에서 1을 두 배로 만드는 것을 최대 63회해서 까지 값이 커질 수 있지만 long long의 표현 범위 최댓값은 이기 때문에 unsigned long long 자료형을 사용해야 합니다.

문제2. 징검다리

문제 요약
징검 다리를 건너는데 1~K 거리 만큼 점프할 수 있습니다. 현재 위치한 징검다리에 a거리 만큼 점프해서 들어왔으면 다음에 점프할 때 a거리로 점프하면 안됩니다. 이 때 개울을 건너는 방법의 수를 구하는 문제입니다.

풀이
N이 매우 큰데 경우의 수를 구해야해서 dp문제라고 생각했습니다. dp[i][j] : i번째 징검다리로 j 거리 점프에서 진입 했을 때 개울을 건너는 방법의 수로 정의하고 다음과 같이 점화식을 세웠습니다.

를 빼는 이유는 현재 징검다리에 j 거리 만큼 점프해서 진입했기 때문에 문제의 조건에 따라 다음에 j 거리 만큼 점프하면 안되서 그 경우의 수를 빼준 것입니다.

주의할 점) 이 점화식 그대로 반복문을 작성하면 만점을 받지 못합니다. 그대로 반복문으로 구현하면 아래와 같은 3중 for문이 작성되는데

첫번째 for문 : 50000번 반복 (징검 다리 수 N : 50000)
두번째 for문 : 100번 반복 (점프거리 K : 100)
세번째 for문 : 100번 반복 (시그마 계산)

연산횟수가 50000*100*100회로 너무 많기 때문입니다.

여기서 시그마 계산은 각 (i, j) 에 대해 처음 한 번만 하도록 하고 다음 부터는 이용하는 방식으로 고쳐서 2중 for문으로 줄일 수 있습니다.

구현
위 점화식을 그대로 반복문으로 구현하되 시그마는 한 번만 계산하도록 했습니다. 코드는 주석으로 설명했습니다.

코드에서 주의할 점은 숫자가 엄청나게 커져서 MOD(1000000009)로 계속 나머지 연산을 하게 하기 때문에 점화식에서 합( $)이$ dp[i+j][j] 보다 작은 경우가 발생하여 값이 음수가 될 수도 있습니다. 따라서 dp[i][j] = (sum+MOD-dp[i+j][j])%MOD; 와 같이 연산하도록 합니다.

문제3. 바이러스

문제 요약
문제의 설명이 복잡한데 간단하게 정리하면 주어진 그래프에서 모든 정점이 차수 가 조건 , ( 는 정점의 개수 )을 만족하기 위해서 최소 몇 개의 정점을 없애야 하는가 입니다.

풀이
N이 100이기 때문에 모든 경우의 수를 시도하는 단순 백트래킹으로 구현할 수 없습니다. 따라서 그리디 방식으로 접근했습니다.

그리디(Greedy) 방식이란 욕심쟁이처럼 지금 상황에서 제일 좋은 것만을 선택하는 것입니다. 다익스트라 최단경로 알고리즘에서 대표적으로 그리디 방식이 사용됩니다. 그러나 대부분의 상황에서 그리디 방식은 눈앞의 이득에 눈이 멀어 미래에 얻게 되는 전체 이득이 최댓값을 갖지 못합니다. 당장 행복하기 위해 매일 사탕을 10개씩 먹는 어린이가 이가 썩어 결국 치과에 가서 불행해지는 상황을 예로 들 수 있습니다.

그리디 방식으로 풀기 위해 주어진 상황에서 할 수 있는 최선의 행동을 아래처럼 정했습니다.

차수가 K 미만인 정점을 지운다.
차수가 |V|-L 이상인 정점을 지운다.
지울 대상이 여러 개이면 번호가 작은 것을 먼저 지운다.

이 행동을 반복하면 놀랍게도 정답을 구할 수 있습니다. 이 그리디 방법의 정당성을 증명하기 위해 이 방법이 눈앞의 이득에 눈이 멀어 미래에 얻게 되는 전체 이득을 놓치지 않는다는 것을 보여야합니다. 즉 이 행동이 미래에 손해를 가져오지 않는다는 것을 보여야합니다.

1번 : 정점을 지우는 행동만 할 수 있기 떄문에 미래에 차수가 늘지 않습니다. 따라서 현재 지워야할 정점은 순서에 상관없이 어짜피 나중에 지워야합니다. 그래서 지금 지워도 미래에 손해보지 않습니다.

2번, 3번 : 차수가 |V|-L 이상인 정점의 경우 연결된 다른 한 정점이 지워져서 차수가 1 낮아져도 전체 정점 수도 1감소해서 기준도 낮아지기 때문에 지워야 할 정점은 지우는 순서에 상관없이 무조건 지워야합니다. 따라서 지금 지워도 미래에 손해보지 않습니다.

구현
위 그리디 규칙을 그대로 코드로 옮겼습니다. 코드는 주석으로 설명했습니다.

문제4. 대피소

문제 요약
주어진 그래프에서 각 정점에서 가장 가까운 대피소와의 거리와 번호를 구하는 문제입니다.

풀이
정점 10만 개 모두에 대해서 가장 가까운 대피소와의 거리와 번호를 구해야하기 때문에 각 정점을 출발점으로 두고 다익스트라 최단거리 알고리즘을 10만 번 돌리면 답을 구할 수 있습니다. 그러나 이렇게 하면 시간초과가 발생해서 만점을 받지 못합니다.

놀랍게도 다익스트라 알고리즘을 딱 한번 만 돌리고도 정점 10만 개 모두에 대해서 가장 가까운 대피소와의 거리와 번호를 구할 수 있습니다. 방법은 출발 점을 여러 개(모든 대피소)로 설정하고 다익스트라 알고리즘을 수행하는 것입니다.

이 문제는 알고리즘 문제 해결전략 책 2권 935p 소방차 문제와 동일한 문제입니다. 잘 이해가 안되면 책을 참고하세요.

구현
출발 점을 여러 개로 두고 다익스트라 알고리즘을 수행하도록 코드를 작성했습니다. 코드는 주석으로 설명했습니다.

문제5. 구두제작

문제 요약
장인들이 구두를 주어진 조건하에 모두 만들 수 있는지 여부를 판별하는 문제입니다.

각 구두 마다 의뢰 기간()과 제작하는데 걸리는 시간()이 주어지고 장인은 의뢰 기간 안에만 해당 구두에 대한 생산 작업을 할 수 있으며 제작 시간 이상만큼 작업해야 구두가 완성됩니다.

또 장인의 근무 시간()이 주어지는데 근무 시간 동안만 구두를 만들 수 있으며 한 구두는 한 시간 동안 한 명의 장인만 작업할 수 있습니다.

풀이
여러 조건을 만족하면서 장인을 특정 시간에 구두를 작업하도록 매칭시켜야 하기 때문에 매칭 문제(네트워크 플로우 문제)풀이법으로 접근했습니다. 아래 그림2과 같이 플로우 네트워크를 구성하고 최대 유량 알고리즘을 수행한 뒤 최대 유량이 구두 제작 시간의 합과 같으면 장인들이 구두를 모두 만드는게 가능하다고 판단했습니다.

그림2

(그림2 입력 요약)
문제의 첫번 째 입력 예시를 플로우 네트워크로 구성한 것입니다.
구두 수 N : 3, 장인 수 K : 2
구두1 : 의뢰기간 [0, 4], 제작 시간 3
구두2 : 의뢰기간 [1, 3], 제작 시간 2
구두3 : 의뢰기간 [2, 7], 제작 시간 4
장인1 : 근무시간 [0, 7]
장인2 : 근무시간 [2, 4]

구현
위 그림대로 플로우 네트워크를 구성한 뒤 dfs를 이용해서 증가경로를 하나 씩 찾아 최대 유량을 구하는 방법으로 구현했습니다. 코드는 주석으로 설명했습니다.

[기하] 다각형의 내부 외부 판별

bowbowbow — Fri, 27 May 2016 16:43:15 +0900

[기하]다각형의 내부 외부 판별

그런데 컴퓨터가 특정 점이 다각형 내부에 있는지 판별하는건 쉬울까요? 우리가 느끼는 직관대로 “점이 선들에 둘러 싸여 있으면 다각형 내부에 있는거야!” 라고 외쳐도 컴퓨터는 알아듣지 못합니다. 컴퓨터가 이해할 수 있는 특징을 파악하고 이를 전달해야합니다.

그 특징은 점의 오른쪽으로 반 직선을 그었을 때 다각형과 만나는 점의 개수가 홀수 개이면 내부에 있는 점이라는 것 입니다. 그럼 짝수 개이면 외부에 있는 점이겠죠?

그림2

그림2를 보고 이 특징이 맞는지 실제로 확인해봅시다. 다각형 외부에 있는 점 A는 오른쪽으로 그은 반직선과 다각형과의 교점 개수가 2개 즉 짝수 개입니다. 반대로 다각형 내부에 있는 점 B는 오른쪽으로 그은 반직선과 다각형과의 교점 개수가 3개 즉 홀수 개입니다. 다각형 내부 어디서 오른쪽으로 반직선을 긋던 정말로 교점의 개수가 홀수개가 되는 것을 확인할 수 있습니다.

이 원칙은 눈으로는 도저히 할 수 없을 만큼 복잡한 꼭지점이 백만 개 다각형에서도 내부 외부를 판별하는데 적용할 수 있는 강력한 규칙입니다. 이제 컴퓨터한테 이 원칙을 전달해서 내부 외부 판별을 부탁합시다.

구현

어떻게 반 직선과 다각형의 교점 개수를 구하지?

다각형 내부 외부 판별 규칙은 간단하지만 반직선과 다각형의 교점의 개수를 구하는것이 쉽지 않아보입니다. 반직선과 다각형의 선분과의 교차점을 구한 후에 이 교차점이 선분 위에 있는지를 조사하는 방법을 사용해야할까요?

다행히 반직선은 항상 x축에 평행한 수평선이기 때문에 비교적 간단하게 다각형의 선분과의 교차점을 구할 수 있습니다.

다각형의 모든 선분들에 대해 반직선과 교점이 존재하는지를 검사합니다. 반직선과 선분 사이에 교점이 존재하기 위한 조건은 2가지 입니다.

점B의 y좌표가 두 선분 꼭지점의 y좌표 사이에 있다.
점B를 지나는 수평선과 선분 사이의 교점의 x좌표가 점B의 x좌표보다 크다.

조건1을 만족하면 점B를 지나는 수평 직선과 선분사이에 반드시 교점이 존재합니다. 이 때 오른쪽 반직선과의 교점만 세야하므로 조건2를 추가로 만족해야 반직선과 선분 사이의 교점 존재여부를 올바르게 판별할 수 있습니다.

그림3

이제 그림3과 같은 다각형이 주어졌을 때 점 B의 반직선과 다각형의 교점을 개수를 찾는 과정을 따라가봅시다. 다각형의 10개의 꼭지점은 p[0], p[1] , … , p[9]으로 주어졌습니다.

그림4

먼저 그림4처럼 꼭지점 p[0], p[1]을 연결하는 선분과 반직선과의 교차여부를 생각합시다. 점B는 선분 (p[0],p[1])의 y좌표 사이에 있고 교점의 x좌표가 점B보다 크기 때문에 교차한다고 판단할 수 있습니다.

그림5

두번째로 그림5처럼 꼭지점 p[9], p[0]을 연결하는 선분과 반직선과의 교차여부를 생각합시다. 점B는 선분 (p[9], p[0])의 y좌표 사이에 있지만 교점의 x좌표가 점B보다 작기 때문에 교차하지 않는다고 판단해야합니다.

그림6

세번째로 그림6처럼 꼭지점 p[3], p[4]을 연결하는 선분과 반직선과의 교차여부를 생각합시다. 점B는 선분 (p[3], p[4])의 y좌표 사이에 있지 않기 때문에 바로 교차하지 않는다고 판단합니다.

소스 코드

이제 위 과정을 코드로 옮겨 봅시다.

먼저 점과 다각형을 담기 위한 구조체와 자료형을 정의합니다.

/* 점을 구조체로 정의 함 */
strcut vector2{
    int x, y;
}
/* STL vector를 이용해서 다각형 자료형을 정의 함 */
typedef vector<vector2> polygon;

이제 점B 가 다각형 p 내부에 있는지를 반환하는 함수 isInside를 정의합니다.

bool isInside(vector2 B, const polygon& p){
    //crosses는 점q와 오른쪽 반직선과 다각형과의 교점의 개수
    int crosses = 0;
    for(int i = 0 ; i < p.size() ; i++){
        int j = (i+1)%p.size();
        //점 B가 선분 (p[i], p[j])의 y좌표 사이에 있음
        if((p[i].y > B.y) != (p[j].y > B.y) ){
            //atX는 점 B를 지나는 수평선과 선분 (p[i], p[j])의 교점
            double atX = (p[j].x- p[i].x)*(B.y-p[i].y)/(p[j].y-p[i].y)+p[i].x;
            //atX가 오른쪽 반직선과의 교점이 맞으면 교점의 개수를 증가시킨다.
            if(B.x < atX)
                crosses++;
        }
    }
    return crosses % 2 > 0;
}

이제 isInside 함수를 이용해서 다각형 내부 외부 판별을 할 수 있습니다!

[BOJ] 7737 삼각분할 (n각형을 삼각형으로 분할하는 경우의 수)

bowbowbow — Sat, 7 May 2016 15:56:42 +0900

삼각분할

아래 그림2 처럼 오각형의 각 변에 2, 3, 4, 5로 숫자를 표시하고 오각형의 대각선으로 추가되는 새로운 변에 나머지 두 변에 적힌 수의 곱을 표시하도록 하자. 여기서부터 직관적으로 n각형을 삼각분할 하는 것이 n-1개 항의 이항 연산 순서를 결정하는 경우의 수를 구하는 것과 같은 문제임을 알 수 있다.

그림2

따라서 이제 삼각분할 문제가 아니라 이항 연산 순서를 결정하는 문제를 풀도록하자. 이항 연산은 이진 트리로 나타낼 수 있다. 5각형 삼각 분할과 대응되는 아래 곱셈 순서를 각각 이진 트리로 나타내보자.

이항 연산을 트리로 나타냄

잘 관찰해보면 n개 항을 가지는 이항 연산 순서를 결정하는 경우의 수는 다시 leaf 노트가 n개인 이진 트리를 구성하는 경우의 수와 같음을 알 수 있다.

자식 노드가 없는 노드를 leaf (잎)노드라고 한다.

leaf 노드가 n개인 이진 트리를 구성하는 경우의 수를 이라 할 때 는 다음과 같은 식으로 나타낼 수 있다.

이는 카탈란 수 의 점화식 과 동일하다.

따라서 n각형을 삼각 분할하는 경우의 수는 카탈란 수 와 동일하다. 이제 삼각 분할은 생각하지 말고 카탈란 수를 구하는 것에 집중하자.

카탈란 수의 일반항은 이므로 다음 항과의 관계식 를 얻을 수 있다. 그럼 이 관계식을 이용해서 을 구하면 문제를 다 푼 걸까?

중간 과정에서 n이 100만 되도 순식간에 long long int 값의 범위를 넘어가기 때문에 을 구하는 중간 과정에서 계속 모듈러 연산(나머지 연산)을 하면서 진행해야한다. 그런데 을 진행하면서 이미 중간에 M으로 나머지 연산을 한 상태이기 때문에 n+2를 나눌 때 나누어 떨어지지 않을 수 있다.

M이 소수라는 보장이 있으면 n+2를 나누는 대신 모듈러 역원을 곱하면 되지만 M은 2이상 10억 이하의 정수이므로 소수라는 보장이 없다. 이를 해결하기 위해 소수를 leaf 노드에 대응시킨 뒤 곱셈 인덱스 트리를 구성하고 관계식에서 곱셈하거 나누는 수를 소인수분해한 뒤 나타난 소인수들을 인덱스트리에서 증감 시켜주고 인덱스트리를 업데이트하는 방식을 이용한다.

Code

소수는 seive 함수 안에서 에라토스테네스 체를 통해 구했고 소인수 분해를 쉽게 하기 위해 에라소트테네스 체를 진행하면서 정수 j의 소인수를 factor[j]에 저장했다.

소수를 leaf노드로 하는 곱셈 인덱스트리는 struct BinaryTree로 구현했다.

[구글 Codejam] B번 문제 (2016 Round1 B)

bowbowbow — Fri, 6 May 2016 10:49:29 +0900

[구글 Codejam] B번 문제 (2016 Round1 B)

예시를 보니까 각 자리에서 둘 다 물음표일 때 (0, 0), (9, 0), (0, 9)로 채우고 한 쪽만 물음표일 때 반대편 자리의 값을 대입하니까 차이가 최소가 되네? 그럼 이 경우만 고려하면 될까? 최악의 경우에 이니까 다해봐도 되겠네?

놓친 반례가 없을까? ?10, ?9? 일 때 위 규칙대로 하면 010, 090인데 정답은 110, 090 이네. 그럼 둘다 물음표일 때 (0, 1), (1, 0)도 함께 고려해야하나? 그럼?9, 20처럼 한쪽만 물음표 일 때도 그냥 반대편 값(2)를 대입하면 안되고 19, 20으로 답을 선택해야하네.. 두 상황 다 반대편 수랑 1차이 나는 것도 고려해야 하구나.. 아까 찾은 규칙이 잘못됐구나..

그럼 이 방법으로 코드 쓸까? 이 방법은 최악의 경우에 가지라서 경우가 너무 많아서 8분안에 계산 못하고 코드가 너무 더러울것같다. 구글이 더러운 코드로 풀어야하는 문제를 냈을리가 없는데 다시 생각해보자.

어렵다. 예시에서 찾아낸 규칙으로 고려해야하는 경우의 수를 줄이는 방법으로 풀려고 하는데 찾은 규칙에 반례가 없다는걸 확신 못 하겠다. 이럴 땐 규칙의 근거로 사용할 수 있게 상황에 조건을 붙여서 제한해야한다.

두 수의 차이를 구하는 것에 주목해서 차이를 구할 때 내림 수가 없는 상황, 내림 수가 있는 상황으로 하나의 문제를 제한 조건을 붙인 상황으로 나누어 풀자.

내림 수가 없는 상황이면 50720, 30520의 차이를 구할 때 처럼 크거나 같은 수의 각 자리수가 다른 수의 각 자리수보다 모두 크거나 같아야한다. 즉 ?가 있을 때 차이를 최소로 하려면 두 수를 같게 만들면 된다.

내림 수가 있는 상황이면 작은 수의 ?는 9로 큰 수의 ?는 0으로 채우면 된다.

주어진 문자열에 대해서 0 ~ i-1 자리에서 내림 수가 없고 i번째 자리에서 내림 수가 발생한다고 가정하자. 또 수의 대소에 대한 정보도 알야야 결정할 수 있으므로 대소도 가정하자.

솔루션

두 수 A, B에 대해 A < B 라고 가정하자.
i-1번째 자리 까지 내림 수가 없고 i번째 자리에서 내림 수가 발생한다고 가정하자.
0~i-1자리의 ?는 두 수를 같게 만들도록하고 i~N-1자리의 ?는 작은 수는 9, 큰수는 0으로 채운다.
각 가정에 대해서 두 수를 결정하고 최소값이면 답으로 저장한다.
A, B를 바꿔서 위 과정을 한번 더 진행한다.

코드

정리

규칙을 찾을 때 고려 못한 상황에서 반례가 있을거 같으면 가정을 해서 상황에 제약을 걸고 문제를 쪼개서 풀자.

[pintos] 2. Priority Scheduling

bowbowbow — Sat, 23 Apr 2016 11:13:10 +0900

[pintos] 2. Priority Scheduling

그럼 먼저 CPU가 어떤 순서로 스레드를 실행하는지 알아야합니다. CPU는 ready_list에 있는 스레드를 순서대로 실행합니다. 현재 핀토스에서는 ready_list에 스레드를 추가할 때 리스트에서 우선순위에 맞게 중간에 삽입하는 것이 아니라 단순히 제일 뒤에 추가하고 있습니다.

Solution

아이디어

이 문제는 ready_list에 thread를 삽입할 때 우선순위가 정렬되도록 삽입하도록 수정해서 해결할 수 있습니다. 또한 현재 CPU를 점유하고 있는 스레드의 우선순위가 ready_list에서 우선순위가 가장 높은 스레드보다 우선순위보다 낮으면 이 스레드가 CPU를 선점할 수 있도록 해야합니다.

구현

먼저 ready_list를스레드의 우선순위가 정렬되도록 하기 위해 스레드를 추가할 때 핀토스에 내장된 함수인 list_insert_ordered함수를 사용합니다. 이때 사용할 비교함수 thread_compare_priority를 를 만들어합니다.

/* pintos/src/threads/thread.c */
bool thread_compare_priority (const struct list_elem *a,
                         const struct list_elem *b,
                         void *aux UNUSED){
  return list_entry (a, struct thread, elem)->priority
       > list_entry (b, struct thread, elem)->priority;  
}

이제 thread가 unblock 될 때 우선순위가 정렬되로록 ready_list에 스레드를 추가할 수 있도록 thread_unblock함수 내부에서 list_push_back을 list_insert_orderd로 교체해줍니다.

/* pintos/src/threads/thread.c */
void thread_unblock (struct thread *t) 
{
  enum intr_level old_level;

  ASSERT (is_thread (t));

  old_level = intr_disable ();
  ASSERT (t->status == THREAD_BLOCKED);
  //list_push_back (&ready_list, &t->elem); 이 부분 지움
  list_insert_ordered (&ready_list, &t->elem, thread_compare_priority, 0); //이 부분 추가
  t->status = THREAD_READY;
  intr_set_level (old_level);
}

마찬가지로 현재 CPU점유 중인 스레드가 CPU 점유를 양보하고 ready_list에 스레드를 추가할 때 사용하는 함수인 thread_yield() 내부에서 ready_list에 삽입되는 부분을 list_push_back을 list_insert_orderd로 교체해줍니다.

/* pintos/src/threads/thread.c */
void thread_yield (void) 
{
  struct thread *cur = thread_current ();
  enum intr_level old_level;

  ASSERT (!intr_context ());

  old_level = intr_disable ();
  if (cur != idle_thread) 
    list_insert_ordered (&ready_list, &cur->elem, thread_compare_priority, 0); //이 부분 추가
    //list_push_back (&ready_list, &cur->elem); //이 부분 삭제
  cur->status = THREAD_READY;
  schedule ();
  intr_set_level (old_level);
}

이제 ready_list에 리스트서 가장 높은 우선순위를 가진 스레드, 즉 첫번째 스레드가 현재 CPU 점유 중인 스레드 보다 우선순위가 높으면 첫번째 스레드가 CPU를 점유해야되겠죠? 그래서 ready_list의 첫번째 스레드가 CPU 점유 중인 스레드 보다 우선순위가 높으면 CPU점유를 양보하는 함수 test_max_priority함수를 만듭니다.

/* pintos/src/threads/thread.c */
void
test_max_priority (void){
  if (!list_empty (&ready_list) &&
      thread_current ()->priority <
      list_entry (list_front (&ready_list), struct thread, elem)->priority){
      thread_yield ();
    }
}

test_max_priority 함수는 언제 호출되야할까요? 스레드가 새로 생성되서 ready_list에 추가되거나, 현재 실행중인 스레드의 우선순위가 재 조정되는 순간에 ready_list의 첫번째 스레드가 CPU 점유 중인 스레드 보다 우선순위가 높은 상황이 발생할 수 있습니다. 따라서 스레드를 새로 생성하는 함수인 thread_create 함수와 현재 스레드의 우선순위를 재조정하는 thread_set_priority함수 의 내부에 test_max_priority()를 추가합니다. (함수의 마지막 부분에 추가하면 됩니다.)

결과

pintos/src/threads 폴더로 이동합니다.

umask 000
make clean
make
cd build
make check

위 명령어 5개를 순서대로 터미널에 입력하면 아래 스크린 샷과 같이 3개의 테스트가 추가로 통과함을 확인할 수 있습니다.

make check 결과

umask 000을 하는 이유는 새로 생성되는 파일의 퍼미션을 777로 설정하기 위해서 입니다. make check를 할때 pintos/tests/thread에 있는 테스트 코드를 실행하며 정답과 비교하기 위해 출력 파일을 생성합니다. 이 때 출력파일을 쓸 권한이 있어야하고 기본 퍼미션으로 쓰기 권한을 할당하기 위해서 umask 000명령을 입력합니다. 777권한 까지는 줄 필요가 없지만 상용서비스를 만드는게 아니기 때문에 이렇게 했습니다.

[pintos] 1. Alarm System Call

bowbowbow — Fri, 22 Apr 2016 18:32:55 +0900

[pintos] Alarm System Call

처음에 핀토스 운영체제에서 프로세스와 스레드를 동일시하는 것을 보고 혼란을 겪었습니다. 왜 그럴까요? 최신 운영체제에서 멀티스레딩의 지원은 너무나 당연하지만 운영체제를 교육할 목적으로 만들어진 핀토스는 프로세스당 하나의 스레드로 구성되어있습니다. 그래서 프로세스와 스레드를 동일시 하여 구현하게 됩니다.

이 문제를 해결하기 위해 먼저 기존의 구현방식인 Busy Waiting을 살펴보고 문제의 해결책은 Sleep / Wake up 구현을 알아봅시다.

Busy Waiting 구현 살펴보기

기존 잠재우기의 구현 코드는 아래와 같습니다.

/* pintos/src/device/timer.c */
void timer_sleep(int64_t ticks){
    int64_t start = timer_ticks();
    while(timer_elapsed(start) < ticks)
        thread_yield(); //현재 CPU점유 다른 스레드에게 양보하고 ready_list 제일 뒤로 이동
}

timer_sleep함수는 현재 스레드를 ticks 시간 동안 잠재우는 함수입니다.

tick(틱)이란 컴퓨터가 켜지고 1ms에 1씩 증가하는 값입니다. 하드웨어에 달린 타이머의해 증가합니다.

이 함수가 호출된 스레드는 while문 내부에 진입합니다. 그리고 스케줄링에 의해 자신의 차례가 올 때 마다 코드가 다시 실행되고 timer_elapsed(start) 함수를 호출합니다.

timer_elapsed(start)는 timer_sleep이 호출된 시점에서 몇 tick이 지났는지를 반환하는 함수입니다. 2.5초 전에 timer_sleep 함수가 호출됬다면 timer_elasped(start)는 2500을 반환합니다.

이 함수의 반환값이 timer_sleep의 인자인 ticks값보다 작으면 thread_yield()를 호출하여 ready list 에 있는 다른 스레드를 위해 CPU 점유를 반환하고 ready list 가장 뒤로 이동합니다. 이 과정은 ticks 동안 반복되고 이러한 방식으로 핀토스는 timer_sleep을 구현합니다.

내용을 이해하기 위해 프로세스 전이 상태 개념을 이해하고 있어야합니다.

푹쉬지 못하고 고생하는 프로세스를 위해 이제 해결책을 마련해줍시다.

Sleep / Wake up

아이디어

Sleep / Wake up 방식은 우리가 아는 상식적인 잠자기 방식입니다. 즉 3시간 낮잠자기로 했으면 푹자다가 3시간 후에 알림 시간 소리를 듣고 일어나는 방식입니다.

이전 방법의 가장 큰 문제점은 편히 자야할 애들(스레드들)을 Ready 상태로 둬서 스케줄링 되게 했다는 것입니다.

상태가 Ready인 스레드는 스케줄링 되어 ready_list에 줄을 서고 자신의 차례가 오면 CPU에 의해 프로세싱 됩니다.

이 문제점을 해결하는 핵심 아이디어는 자야할 애들을 방해받지 않게 Block 상태로 만들고 sleep_list에 넣어두고 깰 시간이 되면 친절하게 찾아가서 다시 Ready 상태로 바꿔주는 것입니다. 이러면 편히 잘 수 있겠죠? 이제 어떻게 구현해야할지 살펴봅시다.

구현

loop기반으로 wating을 하지않으면 각 스레드마다 언제 깨어나야할지에 대한 정보를 각각 가지고 있어야합니다. 이 변수를 thread 구조체에 추가합니다.

/* pintos/src/thread/thread.h */
struct thread{
    ...
    /* 깨어나야 할 tick을 저장할 변수 추가 */
    int64_t wakeup_tick;
    ...
}

이제 잠자는 애들을 모아둘 공간이 필요하겠죠? 이를 위해 sleep_list 구조체를 추가합니다.
또 지금 깨워야할 애들이 없는데 깨우려고 찾아다니면 낭비겠죠? 이 낭비를 막기 위해 잠자는 애들중에 가장 먼저 일어날 친구가 일어날 시각을 변수 next_tick_to_awake를 추가합니다. 그리고 sleep_list를 사용할 수 있도록 thread_init함수에서 sleep_list를 초기화하는 코드를 추가합니다.

/* pintos/src/thread/thread.c */

static struct list sleep_list; 
static int64_t next_tick_to_awake;

...

void thread_init(void){
    ...
    list_init (&sleep_list);
    ...
}

이제 next_tick_to_awake변수를 관리하는 함수를 만들어 줍니다. 이 두 함수는 next_tick_to_awake에 대한 getter와 setter 역할을 합니다.

/* pintos/src/thread/thread.c */

// 가장 먼저 일어나야할 스레드가 일어날 시각을 반환함
void update_next_tick_to_awake(int64_t ticks){
  /* next_tick_to_awake 가 깨워야 할 스레드의 깨어날 tick값 중 가장 작은 tick을 갖도록 업데이트 함 */
  next_tick_to_awake = (next_tick_to_awake > ticks) ? ticks : next_tick_to_awake;
}

// 가장 먼저 일어나야할 스레드가 일어날 시각을 반환함
int64_t get_next_tick_to_awake(void){
  return next_tick_to_awake;
}

이제 스레드를 재워야하겠죠? 재우는 함수 thread_sleep를 구현합니다. 재울 애들은 sleep_list에 추가하고 block상태로 만들어주면 됩니다. 그런데 이 과정에서 인터럽트의 방해를 무시하고 온전히 함수 내부를 실행할 수 있어야하기 때문에 처음에 intr_disable()함수를 통해 인터럽트를 받아들이지 않도록 하고 내부가 다 실행되고 마지막 부분에 다시 intr_set_level(old_level) 함수를 통해 인터럽트를 받아들이도록 합니다.

이때 현재 스레드가 idle 스레드이면 슬립되지 않도록 해야합니다. idle 스레드란 운영체제가 초기화되고 ready_list가 생성되는데 이때 ready_list에 첫번째로 추가되는 스레드입니다. 굳이 이 스레드가 필요한 이유는 CPU가 실행상태를 유지하기 위해 실행할 스레드 하나 필요해서 입니다.

CPU가 할일이 없으면 아얘 꺼져버렸다가 할일이 생기면 다시 켜는방식에서 소모되는 전력보다 무의미한 일이라도 하고 있는게 더 적은 전력을 소모하기 때문입니다.

/* pintos/src/thread/thread.c */

//스레드를 ticks시각 까지 재우는 함수
void thread_sleep(int64_t ticks){
  struct thread *cur;

  // 인터럽트를 금지하고 이전 인터럽트 레벨을 저장함 
  enum intr_level old_level;
  old_level = intr_disable();

  cur = thread_current();   // idle 스레드는 sleep 되지 않아야 함 
  ASSERT(cur != idle_thread);
  //awake함수가 실행되어야 할 tick값을 update
  update_next_tick_to_awake(cur-> wakeup_tick = ticks);

  /* 현재 스레드를 슬립 큐에 삽입한 후에 스케줄한다. */
  list_push_back(&sleep_list, &cur->elem);

  //이 스레드를 블락하고 다시 스케줄될 때 까지 블락된 상태로 대기 
  thread_block();

  /* 인터럽트를 다시 받아들이도록 수정 */
  intr_set_level(old_level);
}

이제 재우고 sleep_list에 넣어뒀으니 sleep_list에서 꺼내서 깨울 함수가 필요하겠죠? 이 함수가 thread_awake 함수입니다. sleep list의 모든 entry를 순회하면서 현재 tick이 깨워야 할 tick 보다 작다면 슬립 큐에서 제거하고 unblock해줍니다. 크다면 next_tick_to_awake변수를 갱신하기 위해 update_next_tick_to_awake()를 호출한다.

/* pintos/src/thread/thread.c */
//푹 자고 있는 스레드 중에 깨어날 시각이 ticks시각이 지난 애들을 모조리 깨우는 함수
void thread_awake(int64_t wakeup_tick){
  next_tick_to_awake = INT64_MAX;
  struct list_elem *e;
  e = list_begin(&sleep_list);
  while(e != list_end(&sleep_list)){
    struct thread * t = list_entry(e, struct thread, elem);

    if(wakeup_tick >= t->wakeup_tick){
      e = list_remove(&t->elem);
      thread_unblock(t);
    }else{
      e = list_next(e);
      update_next_tick_to_awake(t->wakeup_tick);
    }
  }
}

이제 이 네 함수들을 컴파일러가 인식할 수 있게 thread.h에 프로토타입을 선언합니다.

/* pintos/src/thread/thread.h */

//스레드를 ticks시각까지 재우는 함수.
void thread_sleep(int64_t ticks);
//푹 자고 있는 스레드 중에 깨어날 시각이 ticks시각이 지난 애들을 모조리 깨우는 함수
void thread_awake(int64_t ticks);

// 가장 먼저 일어나야할 스레드가 일어날 시각을 반환함
int64_t get_next_tick_to_awake(void);
// 가장 먼저 일어날 스레드가 일어날 시각을 업데이트함
void update_next_tick_to_awake(int64_t ticks);

이제 스레드를 실제로 잠재우는 함수인 timer_sleep가 불렸을 때 반복문을 돌면서 기다는 부분을 지우고 방금 만들어준 thread_sleep함수를 호출하도록 변경합니다.

/* pintos/src/device/timer.c */
void timer_sleep (int64_t ticks) 
{
  int64_t start = timer_ticks ();

  ASSERT (intr_get_level () == INTR_ON);

  /* 
  기존의 busy waiting을 유발하는 코드를 삭제하고
  새로 구현한 thread를 sleep list에 삽입하는 함수 호출함
  */
  thread_sleep(start + ticks);
}

그리고 timer 하드웨어 의해 매 틱마다 타이머 인터럽트가 걸리는데 그때 timer_interrupt함수가 호출됩니다. 매 틱마다 get_next_tick_to_awake()함수를 통해 현재 깨워야할 스레드가 있는지 정보를 얻고 있다면 thread_awake(ticks) 함수를 호출하도록 합니다.

/* pintos/src/device/timer.c */
static void timer_interrupt (struct intr_frame *args){
   ...
  /* 매 tick마다 sleep queue에서 깨어날 thread가 있는지 확인하여,
  깨우는 함수를 호출하도록 함. */
  if(get_next_tick_to_awake() <= ticks){
    thread_awake(ticks);
  }
}

결과

pintos/src/thread 폴더에서 sudo make로 컴파일 후 pintos – -q run alarm-multiple을 실행하면 아래와 같은 결과가 나타납니다.

실행결과

이 때 idle tick이 pintos를 처음 설치했을 때 처럼 0이 아니라 550값이 출력되었습니다. idle 스레드은 위에서도 설명했지만 CPU 가 아무 할일도 없을 때 실행되는 스레드로 idle tick는 idle 스레드가 실행된 tick수, 즉 시간 입니다. 550 idle ticks 는 idle 스레드가 550ms 실행되었음을 의미합니다.

이 변화는 이전에는 Busy-Waiting 방식이라서 Sleep상태에서도 여전히 CPU가 점유되고 있었고idle 스레드가 실행될 일이 없었으나 Sleep / Wake up 방식으로 변경 한 후 CPU가 잠자는 스레드를 점유하지 않고 idle 스레드를 점유했음을 알 수 있습니다.

즉 프로세스, 스레드가 잠자는 동안 시스템 자원을 낭비하지 않도록 수정하는 과제의 목표를 달성한 것입니다!

[구글 Codejam] C번 문제 (2016 Round1 A)

bowbowbow — Sun, 17 Apr 2016 01:31:10 +0900

[Code jam] C번 문제 (2016 Round1 A)

어린이 4명이 있다. 각 어린이의 베스트 프랜드는 아래 표와 같음을 알 수 있다.

어린이 번호 자신의 베스트 프랜드 어린이 번호

1 2

2 3

3 4

4 1

이때 그림1과 같이 앉으면 모든 어린이의 왼쪽 또는 오른쪽에 자신의 베스트 프랜드가 있기 때문에 이 입력에 대해 최대 4명의 어린이가 원형으로 둘러앉아 활동을 할 수 있다.

그림1

어린이 번호	자신의 베스트 프랜드 어린이 번호
1	2
2	3
3	4
4	1

생각 흐름

각 어린이를 정점으로 나타내고 어린이의 베스트 프랜드를 방향그래프로 표현한다. 위 입력 예시는 그림2와 같은 방향그래프로 나타낼 수 있다.

그림2

그러면 직관적으로 구성된 방향그래프에서 나타나는 사이클의 최대 길이를 출력하면 답을 구할 수 있다는 생각이 든다.

그러나 4번째 입력 예시를 직접 그려보면 그림3과 같은 방향그래프로 나타낼 수 있는데

4번째 입력 예시
10
7 8 10 10 9 2 9 6 3 3

그림3

이 그래프에서 3, 10번 정점으로 구성된 길이2 사이클 밖에 없지만 최대 6명(7 9 3 10 4 1번어린이)가 원형으로 같이 앉을 수 있다고 문제에 힌트가 주어진다. 이 힌트가 없었다면 훨씬 더 많은 사람들이 틀렸을거 같다.

그림3의 그래프에서 최대 6명의 어린이가 원형으로 앉은것을 나타내면 그림4와 같이 나타낼 수 있다.

그림4

그러면 길이가 2인 사이클의 한쪽 정점을 가리키는 빨간색 간선과 다른 한쪽 정점으로 연결되는 파란색 간선들로 구성되어 있음을 알 수 있다. 따라서 길이 2사이클에 위와 같이 연결된 형태도 답의 후보로 고려해야한다.

이제 솔루션에 거의 근접한거 같다. 혹시 놓친게 없을까? 만약 길이 2사이클에 연결된 집합이 여러 개이면 답은 어떻게 될까?

그 집합안에 있는 어린이들은 반드시 자신의 베스트 프랜드가 옆에 앉아 있기 때문에 이를 이어 붙여서 원형으로 앉아도 모든 어린이들의 옆에 자신의 베스트 프랜드가 옆에 앉아 있을 것이다.

솔루션

어린이의 베스트 프랜드 관계를 그래프로 구성한다.
그래프에서 최대 길이 사이클을 구한다.
길이가 2인 사이클에 연결된 집합을 모두 구하고 길이를 합한다.
2번과 3번에서 구한 값 중에 큰 것을 답으로 한다.

코드

솔루션 1, 2번 과정은 매우 간단해서 설명을 생략한다.
솔루션 3번 과정은 길이가 2인 사이클을 찾으면 사이클을 구성하는 양쪽 정점에서 역방향으로 BFS를 돌려서 최대값을 더하면 된다. 그러나 아래 코드에서는 이 과정을 2줄로 구현하기 위해 벨만포드 알고리즘의 아이디어를 이용해서 indegree가 0인 노드에서 이 길이가 2인 사이클의 두 정점까지의 거리를 구하는 방식을 사용했다.

[CodeForces] Square Root of Permutation : 순열 제곱근

bowbowbow — Fri, 8 Apr 2016 18:41:24 +0900

Square Root of Permutation

홀수 길이의 사이클을 제곱하면 같은 길이의 홀수 사이클을 얻는다. 아래 그림3을 보고 확인할 수 있다. 왼쪽이 원래 사이클, 오른쪽이 제곱했을 때 사이클을 나타낸다.
그림3

여기서 직관적으로 홀수 길이의 사이클의 제곱근으로 같은 길이의 홀수 사이클이 존재한다는 것을 알 수 있다. 즉 사이클 의 길이가 2k+1이면 사이클 의 길이도 2k+1이다.

길이가 2k+1인 사이클 에서 길이의 거의 절반인 k+1회 이동하면 입장에서 2k+2회를 이동한 것이다. 즉 한 바퀴를 다 돌고 한 번 더 간것이기 때문에 입장에서 을 에 대응시킨 것이 입장에서 을 에 대응시킨 것이다.

이 성질을 이용해서 이 있을 때 순열 제곱근의 사이클 을 구할 수 있다.

사이클 길이가 짝수 일때

길이가 2*k (k는 양의 정수)인 사이클의 원소는 순열을 제곱했을때 독립적인 길이 k의 두 사이클을 이룬다.

이 사실은 아래 그림4을 통해서 직관적으로 알 수 있다. 왼쪽의 사이클이 제곱됐을때 나타나는 두 독립적인 사이클을 나타냈다.
그림4

이 사실로 부터 제곱 순열에서 길이가 짝수인 두 쌍의 사이클 이 있을 때 순열 제곱근의 사이클 을 구할 수 있다.

만약 같은 짝수 길이의 사이클이 쌍으로 존재하지 않는다면 제곱근 순열은 존재하지 않는다.

멍멍멍

[텐서플로우] 3차원 이상의 텐서 사이의 행렬 곱(tf.matmul)

3차원 텐서 사이의 행렬 곱

어떻게 작동하는걸까?

5차원 텐서 사이의 행렬 곱

[자료구조]Union-Find: Disjoint Set의 표현

Union-Find 란?

Union-Find 의 구현

배열로 표현하기

트리로 표현하기

트리로 표현하기 : 실제 소스코드

최적화 하기

최적화 하기 : 실제 소스코드

Union-Find 정리

끝

삼성 대학생 프로그래밍 대회(SCPC) 2016 1차 예선 풀이

목차

문제1. 3N+1

문제2. 징검다리

문제3. 바이러스

문제4. 대피소

문제5. 구두제작

[기하] 다각형의 내부 외부 판별

목차

다각형의 내부 외부 판별이란?

아이디어

다각형의 내부에 위치하는 점의 특징은 뭘까?

구현

어떻게 반 직선과 다각형의 교점 개수를 구하지?

소스 코드

[BOJ] 7737 삼각분할 (n각형을 삼각형으로 분할하는 경우의 수)

목차

문제 설명

Solution

Code

[구글 Codejam] B번 문제 (2016 Round1 B)

목차

문제 요약

생각 흐름

솔루션

코드

정리

[pintos] 2. Priority Scheduling

목차

과제 목표

Solution

아이디어

구현

결과

[pintos] 1. Alarm System Call

목차

과제 목표

Busy Waiting 구현 살펴보기

Sleep / Wake up

아이디어

구현

결과

[구글 Codejam] C번 문제 (2016 Round1 A)

목차

문제 요약

입력 예시

생각 흐름

솔루션

코드

[CodeForces] Square Root of Permutation : 순열 제곱근

목차

문제 설명

Solution

Code