Informatics

Practice Round 2019

makesource — Tue, 24 Dec 2019 10:10:55 +0900

1. Number thinking

문제요약:

Up and Down 을 Interactive 로 옮겨 놓은 문제이다.

풀이:

숫자 범위를 L 이라고 할때, 항상 현재 범위의 중간을 확인하는 방식으로 [log2 (L)] + 1 번 만에 정답을 맞출 수 있다.

Interactive probolem 이기 때문에, 출력 시 buffer flush 를 해주지 않으면 TLE 로 판정된다.

2. Mural

문제요약:

길이 N 개의 벽이 있고, 각 벽에 해당되는 점수가 있다.

하루 마다 길이 1 에 해당되는 벽을 색칠 할 수 있고, 하루마다 좌우측 벽 중 색칠되지 않은 놈들중 하나가 무너진다.

첫번째 날에는 아무 벽에서 색칠을 시작 할 수 있고, 시작한 이후에는 이미 색칠된 벽의 좌우만 칠 할 수 있다.

이러한 상황에서 얻을 수 있는 점수중 최대를 구하는 문제

풀이:

문제를 잘 요약해보면, 연속된 구간으로만 색을 칠 할 수 있고,

매일 하나의 벽을 칠하고 하나의 벽이 무너지기 때문에 최대 칠할 수 있는 벽은 [(N+1)/2] 개 이다.

어느 곳에서든 시작할 수 있기 때문에 길이 [(N+1)/2] 구간중 합이 가장 큰 구간을 구하면 정답이 된다.

sliding window 방식을 통해 합을 구하면 길이 N 만에 합이 최대인 구간을 구할 수 있다.

3. Kickstart alarm

문제요약:

주어진 수식을 계산하면 된다

풀이:

정답이 되는 최종합을 Ai 를 기준으로 수식을 정리하다보면 각 계수의 특징이 관찰된다.

(power1 + power2 + .. powerk) 를 Ai 를 기준으로 정리하면

ans = a1 * A1 * N + a2 * A2 * (N-1) ... + an * An * 1 과 같은 꼴로 나타낼 수 있는데,

이때 ai 들을 관찰해보면 ai = ai-1 + i^1 + i^2 ... i^k 과 같은 꼴로 나타낼 수 있다. (a1 = K)

i^1 + i^2 .. i^k 는 등비수열 합 공식에 의해 i * (i^k - 1) / (i-1) 으로 나타나고,

MOD 1000000007 에 대한 모든 i 에 대한 역원을 미리 구해두면 ai 값을 빠르게 계산 할 수 있다.

주의할 점:

1. 모듈러 연산에서 뺄샘이 들어가는 경우 무조건 MOD 만큼 더해준 다음 빼준다.

2. 각각의 모든 연산에서 MOD 연산을 해주어야 정확한 값이 계산된다. #define 으로 정의해두면 편하다

문제출저

https://codingcompetitions.withgoogle.com/kickstart/round/0000000000051060

Kick Start - Google’s Coding Competitions

Hone your coding skills with algorithmic puzzles meant for students and those new to coding competitions. Participate in one round or join them all.

codingcompetitions.withgoogle.com

KOI 2011 지역본선 책장

makesource — Wed, 28 Feb 2018 00:55:14 +0900

Problem

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

Summary

N 개의 책이 주어진다.

각 책 마다 너비 W 와 높이 H 가 주어지고, 주어진 순서대로 책장에 꽂으려 한다.

모든 책을 꽂기 위한 책장의 너비와 높이중 최대값을 최소로 하려고 할 때, 그 최소값은 얼마일까?

Solution

너비와 높이 중 최대값을 최소로 하는 문제이다.

모든 책을 꽂아야 하는 책장의 특성상 너비가 증가함에 따라 높이가 단조감소하고, 너비가 줄어들면 높이가 단조증가하게 된다.

따라서 책장의 너비(폭) 을 고정시키고, 그 때의 최소 높이를 구한 다음 그 높이를 기준으로 책장의 너비를 늘릴지 줄일지 결정할 수 있고 따라서 이 문제는 파라메트릭 서치로 접근 가능하다.

그렇다면 책장의 너비를 고정 시켰을 때 모든 책을 꽂기 위한 최소 높이를 구하는 방법에 대해 알아보자.

1. Solution

책을 꽂는 순서가 정해져 있기 때문에 마지막 층에 꽂을 책을 결정하고 나면, 맨 위에 책들을 제외한 책들에 대해 최소 높이를 구하면 된다. 따라서 재귀적으로 문제 크기를 단계적으로 줄여나갈 수 있고, 동적계획법으로 문제를 해결 할 수 있다.

와 같이 표현 할 수 있고, 각 i 에 대해 모든 후보 j 에 대해 검사를 하여 정답을 구할 수 있다.

2. Solution

위의 점화식을 다시 한번 살펴 보자.

고정된 i 에 대해 편의상 max(h[j...i]) = H[j] 라고 표현하면

D[i] =max { D[j-1] + H[j] } 로 나타난다.

여기서 max 함수 안에 있는 각 항을 따로 살펴보면

D[j-1]: j 가 증가 함에 따라 단조 증가하는 그래프를 그린다.

H[j]: j가 증가 함에 따라 단조 감소하는 그래프를 그린다. (j 가 감소함에 따라 증가한다.)

D와 H의 개형을 대략적으로 나타내면 위의 그림과 같다.

이러한 상황에서 D와 H를 더한 값을 최소로 하는 j를 찾는것이 이 문제의 핵심이다.

그래프의 개형을 통해 아래의 Lemma를 얻을 수 있다.

lemma 1: 고정된 i 에 대해, H[j]이 같은 한 가장 작은 j를 선택하는 것이 유리하다. 즉 H[j]가 감소하는 j에 대해서만 고려해도 충분하다.

따라서 i 가 고정되어 있을때에는 H[j]가 감소하는 j 리스트를 가지고 있어, 이 j 에 대해서만 식을 계산해도 충분하다.

그렇다면 i 가 증가할 때 그래프의 개형을 살펴보자

위와같이 i+1 번째 책이 이전 책보다 높이가 큰 경우와 작은경우 두가지 경우가 나올 수 있다.

또 세로축이 오른쪽으로 이동한 이유는 문제 조건 상 (w[j] + ... + w[i] <= L) 을 만족해야 되기 때문에 i 가 증가함에 따라 가능한 j의 범위는 점점 감소하기 때문이다.

i 일때 고려해야되는 j 의 후보를 list[i] , i + 1 일때 고려해야되는 j 의 후보를 list[i+1] 이라 하면

list[i+1] 은 list[i]의 앞에서 몇개의 원소가 삭제되고, list[i]의 뒤에서 몇개의 원소가 삭제되거나 추가된 형태가 된다.

그리고 여기서 삭제된 j들은 이후 i 의 값과 상관없이 고려해야할 대상에서 아에 제거된다. (한번 높아진 H[j] 값이 다시 감소 하지 않기 때문)

이를 정리하면 아래와 같은 lemma 를 얻는다.

lemma 2: i 가 증가함에 따라 고려해야되는 j 의 후보는 앞 / 뒤에서 추가 혹은 삭제되며 한번 후보에서 빠진 j 는 i 에 상관없이 다시 고려될 필요 없다.

따라서 i 가 증가하는 순서로 D[i] 값을 계산할 때 고려해야 하는 j 의 후보군들을 deque로 관리하면 원소가 앞, 뒤에서 추가 혹은 제거되는 상황을 효과적으로 처리 할 수 있다.

하지만 최악의 경우 각 i 에대해 고려해야 할 j 의 후보군이 n 에 비례 할 수도 있기 때문에 매번 list 의 모든 후보에 대해 계산하면 O(N^2) 이 된다.

따라서 매번 후보에 대한 계산을 하지 않고 리스트에 삽입되는 순간 D[j-1] + H[j] 값을 계산하고 이 값을 우선순위큐에 넣어둔다. 그런 다음 D[i] 를 계산 할 때 우선순위 큐에서 가장 작은 원소를 뽑아 D[i] 값을 계산한다.

여기서 주의할 접은 리스트에서 제거되는 원소에 대해서는 그 값을 고려하면 안되기 때문에 큐에서 뽑은 뒤 이 값이 현재 deque 안에 있는 j 에 의해 계산된 값인지 확인하는 과정이 필요하다.

lemma2 에 따라 각 원소는 최대 한번 리스트에 삽입 / 삭제 되기 때문에 우선순위 큐에 삽입되는 원소 또한 N 에 비례하며 따라서 D[1] ... D[N] 까지의 모든 값 계산을 N log N 시간만에 해결 할 수 있다.

3. Solution

이 문제를 O(N) 으로 해결하기 위해서는 후보 j 에 대한 값을 저장하기 위해 사용한 우선순위 큐 대신, 값이 증가하는 데큐 하나와 값이 감소 하는 데큐 2개를 사용하면 된다. 하지만 기본적으로 j후보가 앞/뒤에서 dynamic 하게 추가 삭제되기 때문에 데큐안의 원소를 우리가 원하는 범위 안의 값으로 잘 관리해주기 상당히 까다로울 것으로 예상된다.

p.s) 위의 O(N log N) 솔루션으로도 충분히 제한시간 안으로 답을 구해낼 수 있다.

Implementation

아래 코드는 두번째 방법인 O(N log N) 으로 구현되어 있습니다.

우선순위 큐 안의 원소가 현재 deque 안의 원소에서 계산된 값인지 확인하기 위해 valid 라는 배열을 두어 큐에서 뽑을 때 매번 확인하는 과정이 포함되어 있습니다.

오일러 파이 함수

makesource — Fri, 23 Sep 2016 15:28:52 +0900

오일러 파이 함수란

= 1부터 n까지의 양의 정수 중에 n과 서로소인 것의 개수를 나타내는 함수이다

로 정의되는 함수이다.

이러한 파이 함수에는 여러가지 성질이 발견되는데

우선 곱의 함수라는 점이다.

이에 대한 증명은 에라토스테네스의 채와 비슷하게 정수들을 쭉 나열한 다음, 서로소가 아닌 수들을 지워나가면 규칙을 찾을 수 있다.

이러한 파이 함수의 값을 구하는 방법에는 여려가지가 있겠지만,

우선 특정 N에 대해 구한다고 생각하면

N의 소인수들을 다 구한 다음 이 공식을 사용하면 된다.

1~ 까지 파이 함수의 값을 구하기 위해서는,

소수판별을 할때 에라토스테네스의 채 기법을 사용한다.

pi[i] = i;

for (int i=2;i<=N;i++) {

if (pi[i] == i) { // 소수인 경우

pi[i] = i - 1;

for (int j=i+i;j<=N;j+=i) pi[j] = pi[j] * (i-1) / i;

}

와 같이 구할 수 있다.

시간복잡도는 n lg lg n이다.

이러한 파이 함수와 관련된 법칙이 있는데, 바로 오일러의 정리이다.

만약 a와 n이 서로소이고 n이 자연수이면 다음이 성립한다.

특히 n이 소수일때는 pi(n) = n-1 이기때문에 페르마 소정리 a^(p-1) = 1 (mod p)가 성립한다.

이를 통해서 서로소인 a와 n에 대해 모듈러 inverse을 계산 할 수 있다.

서로소인 a와 n에 대해 모듈러 인버스를 다른 방식으로 계산 할 수 있는 방법도 있는데, 이는 확장유클리드 알고리즘을 이용한 방식이다.

확장 유클리드란

ax + by = gcd(a,b)를 만족하는 정수해 x,y 를 찾기 위한 알고리즘으로

이를 위의 식에 적용시키면

a*x + n*y = gcd(a, n) = 1 을 만족시키는 정수해를 찾을 수 있고

양변을 모듈러 n연산을 씌우면

a*x = 1 (mod n)이라는 식이 만들어 진다.

여기서 x는 법 n에 대해 a의 곱셈에대한 역원이 된다.

임의의 수 N에 대해 pi를 구하는 방법

imsi = N;

for (j=2;j*j<=imsi;j++) if (imsi % j == 0) {

while(!(imsi %j)) imsi /= j;

pi = pi / j * (j-1)

}

if (imsi > 1) { // 소수

pi = pi / imsi * (imsi - 1)

}

Centroid Decomposition

makesource — Fri, 23 Sep 2016 15:17:21 +0900

트리에서 사용하는 분할정복 기법을 Centroid Decomposition이라고 한다.

트리에 존재하는 모든 경로에 대해서 어떤 연산을 수행하려 할때

트리를 분할에 서브 트리에 대해 연산을 수행하고, 그러한 서브트리를 merge해 전체 트리에서의 결과값을 얻어 낼 수 있다.

여기서 중요한 것은 주어진 트리르 어떻게 쪼개는지 이다.

쪼개는 방법에 따라 시간복잡도가 달라지는데, 분할정복 처럼 트리의 크기를 계속해서 반 씩 쪼깨고 각 서브트리를 처음 트리사이즈 시간만에 merge 할 수 있다면 시간복잡도는 마스터 정리에 의해 O(N lg N)이 된다.

이 문제를 푸는 데 있어 중요한 것은

1. Subtree 로 분할할 cutting edge를 어떻게 잡을것인가?

2. 서로다른 Subtree들의 결과값을 어떻게 리니어 하게 Merge 할 것인가?

우선 트리에서 서브트리의 노드갯수가 원래 트리 노드 갯수 / 2가 되도록 커팅 할 수 있는 정점은 항상 존재한다.

그러한 노드는 한번은 bfs순회를 통해 찾을 수 잇다.

여기서 주의할 점이 있는데, Cutting edge를 찾는 과정에서 dfs를 돌릴때 visit배열을 따로 사용하면 안된다.

이유인 즉슨 Cutting과정은 남은 노드가 1개가 될때 까지 재귀적을 반복되는데 매 Cutting과정에서 visit배열을 초기화하고 사용하면 제곱 시간이 들기 때문이다.

따라서 구현을 할때는 현재 노드가 cutting 되었는지 아닌지를 판단하는 배열, cutted하나와 자기로 온 부모 노드로 따라올라가지 못하도록 부모노드의 인덱스만 가지고 dfs를 돌린다. 트리이기 때문에 dfs를 돌릴때 부모로 가지 않도록 해주면, visit 배열을 따로 사용하지 않고 구현 할 수 있다.

그렇게 cutting할 노드를 찾기 위해 dfs 탐색을 한 후, 노드 리스트를 가지고 현재 노드를 잘랏을때 생기는 서브트리의 정점갯수중 max값을 구한다. 그런다음 그 max값이 원래노드갯수/2보다 작거나 같다면 그 정점을 루트로 다시 분할 하면 된다.

int dfs(int node, int mom = -1) {
    cnt[node] = 1;
    list.push_back(node);
    for (pair<int,int> e : graph[node]) {
        if (e.first == mom || cutted[e.first]) continue;
        cnt[node] += dfs(e.first, node);
    }
    return cnt[node];
}

int getCut(int node) {
    list.clear();
    int count = dfs(node);
    for (int x : list) {
        int cmax = 0;
        for (pair<int,int> e : graph[x]) {
            int y = e.first;
            if (cutted[y] || cnt[x] < cnt[y]) continue;
            cmax = maxf(cmax, cnt[y]);
        }
        cmax = maxf(cmax, count - cnt[x]);
        if (cmax <= count/2) return x;
    }
    return node;
}

위의 구현을 코드로 나타낸 것이다.

그런 다음 merge하는 과정에서는 같은 그룹의 서브트리들이 계산 과정에서 선택되지 않도록 그룹별로 분리를 잘 해줘야 한다.

이는 문제마다 구현이 달라질 수 있으므로, 문제별로 잘 생각해본다.

머지 과정에서는 아래과정에서 구한 결과값이 전혀 필요없기 때문에

분할하기전에 머지를 먼저해도 되고, 분할하고 나서 머지를 해도 상관없다.

분할을 해서 subtree에 대해 solve를 부르는 것은, 그 subtree 내에 존재하는 모든 경로들을 탐색하는 것이고,

머지하는 과정에서는 cut한 노드를 무조건 거쳐가는 경로에 대한 계산이라 보면 된다.

밑에는 코드포스 C번에 대한 코드이다.

http://codeforces.com/contest/715/problem/C

#include <stdio.h>
#include <vector>
#include <queue>
#include <memory.h>
#include <map>
#define mp make_pair
#define __ 100010
#define maxf(a,b) ((a)>(b)?(a):(b))
typedef long long ll;
using namespace std;

struct Queue {
    int node, d, g;
    ll l, r;
};

vector<Queue> qlist[__];
vector<int> list;
vector<pair<int,int>> graph[__];
ll ten[__], rev[__], ans;
int cnt[__], vis[__], cutted[__];
ll N, M;

int dfs(int node, int mom = -1) {
    cnt[node] = 1;
    list.push_back(node);
    for (pair<int,int> e : graph[node]) {
        if (e.first == mom || cutted[e.first]) continue;
        cnt[node] += dfs(e.first, node);
    }
    return cnt[node];
}

int getCut(int node) {
    list.clear();
    int count = dfs(node);
    for (int x : list) {
        int cmax = 0;
        for (pair<int,int> e : graph[x]) {
            int y = e.first;
            if (cutted[y] || cnt[x] < cnt[y]) continue;
            cmax = maxf(cmax, cnt[y]);
        }
        cmax = maxf(cmax, count - cnt[x]);
        if (cmax <= count/2) return x;
    }
    return node;
}

void calc(int node) {
    queue<Queue> Q;
    int group = 0;
    for (pair<int,int> e : graph[node]) {
        if (cutted[e.first]) continue;
        Q.push({e.first, 0, ++group, e.second%M, e.second%M});
    }
    for (int i=1;i<=group;i++) qlist[i].clear();
    memset(vis,0,sizeof vis);
    vis[node] = 1;
    while (!Q.empty()) {
        Queue n = Q.front(); Q.pop();
        if (vis[n.node]) continue;
        vis[n.node] = 1;
        qlist[n.g].push_back(n);
        for (pair<int,int> e : graph[n.node]) {
            if (vis[e.first] || cutted[e.first]) continue;
            ll L = (n.l * 10 + (ll)e.second)%M;
            ll R = ((ll)e.second * ten[n.d+1] + n.r)%M;
            Q.push({e.first, n.d+1, n.g, L, R});
        }
    }
    map<ll, int> rv;
    for (int i=1;i<=group;i++) {
        for (Queue x : qlist[i]) rv[x.r] ++;
    }
    for (int i=1;i<=group;i++) {
        for (Queue x : qlist[i]) rv[x.r] --;
        for (Queue x : qlist[i]) {
            if (x.l == 0) ans ++;
            if (x.r == 0) ans ++;
            ll t = (-x.l + M)%M;
            t = (t * rev[x.d+1])%M;
            ans += rv[t];
        }
        for (Queue x : qlist[i]) rv[x.r] ++;
    }
}

void solve(int node) {
    int cut = getCut(node);
    calc(cut);
    cutted[cut] = 1;
    for (pair<int,int> e : graph[cut]) {
        if (cutted[e.first]) continue;
        solve(e.first);
    }
    cutted[cut] = 0;
}

pair<ll, ll> extended_gcd(ll a,ll b) {
    if (b == 0) return mp(1,0);
    pair<ll, ll> t = extended_gcd(b, a%b);
    return mp(t.second, t.first - t.second * (a/b));
}

int main() {
    scanf ("%lld%lld",&N,&M);
    ten[0] = 1 % M;
    for (int i=1;i<=N;i++) {
        ten[i] = (ten[i-1] * 10) % M;
        rev[i] = (extended_gcd(M, ten[i]).second + M) % M;
    }
    for (int i=1;i<N;i++) {
        int a,b,c;
        scanf ("%d%d%d",&a,&b,&c);
        graph[a].push_back(mp(b,c));
        graph[b].push_back(mp(a,c));
    }
    solve(0);
    printf ("%lld",ans);
    return 0;
}

divide & conquar optimization

makesource — Sat, 27 Aug 2016 21:43:14 +0900

D[t][i] = min (D[t-1][j] + C[j][i]) (j < i) 꼴인 경우

위의 조건을 만족하는 최소의 j를 P[t][i]라고 할때

P[t][i] <= P[t][i+1] < --- > C[a][c] + C[b][d] <= C[a][d] + C[b][c] 증명은 귀류법!

반대로

D[t][i] = max (D[t-1][j] + C[j][i]) (j < i) 꼴인 경우

위의 조건을 만족하는 최소의 j를 P[t][i]라고 할때

P[t][i] <= P[t][i+1] < --- > C[a][c] + C[b][d] >= C[a][d] + C[b][c] 증명은 귀류법!

위의 조건을 이용해 divide & conquar 방식으로 로그시간만에 dp table 값을 계산 할 수 있다.

증명

(1)

C[a][c] + C[b][d] <= C[a][d] + C[b][c]

D[t][i] = min( D[t-1][k] + C[k][i] )

A[t][i] <= A[t][i+1]

귀류법

어떤 i에 대해서

A[t][i] = j > A[t][i+1] = k

D[t][i] = D[t-1][j] + C[j][i] < D[t-1][k] + C[k][i]

D[t][i+1] = D[t-1][k] + C[k][i+1] < D[t-1][j] + C[j][i+1]

D[t-1][j] - D[t-1][k]에 대해 정리해보면

C[k][i+1] - C[j][i+1] < D[t-1][j] - D[t-1][k] < C[k][i] - C[j][i]

즉 C[k][i+1] - C[j][i+1] < C[k][i] - C[j][i]

다시써서 C[k][i+1] + C[j][i] < C[k][i] + C[j][i+1] 에서 (k < j < i < i+1)

사각 부등식을 만족한다는 가정에 모순되므로 위 명제는 참이다

(2)

C[a][c] + C[b][d] >= C[a][d] + C[b][c]

D[t][i] = max( D[t-1][k] + C[k][i] )

A[t][i] <= A[t][i+1]

귀류법

어떤 i에 대해서

A[t][i] = j > A[t][i+1] = k

D[t][i] = D[t-1][j] + C[j][i] > D[t-1][k] + C[k][i]

D[t][i+1] = D[t-1][k] + C[k][i+1] > D[t-1][j] + C[j][i+1]

D[t-1][j] - D[t-1][k]에 대해 정리해보면

C[k][i] - C[j][i] < D[t-1][j] - D[t-1][k] < C[k][i+1] - C[j][i+1]

즉 C[k][i] - C[j][i] < C[k][i+1] - C[j][i+1]

다시 써서 C[k][i] + C[j][i+1] < C[k][i+1] + C[j][i] 에서 (k < j < i < i+1)

사각 부등식을 만족한다는 가정에 모순되므로 위 명제는 참이다

boj 김치 문제

D[i] = i날에 꺼낼때 max value

D[i] = (i-j+1) * T[i] + V[j] ( j < i)로 정의되므로

C[j][i] = (i-j+1) * T[i] + V[j]가 된다

사각 부등식의 조건을 살펴 보면

C[a][c] + C[b][d] - C[a][d] - C[b][c]

= (c-a+1) * T[c] + V[a] + (d-b+1) * T[d] + V[b] - (d-a+1) * T[d] - V[a] - (c-b+1) * T[c] - V[b]

= (c-a+1-c+b-1) * T[c] + (d-b+1-d+a-1) * T[d]

= (b-a) * T[c] + (a-b) * T[d]

= (b-a) (T[c] - T[d]) 로 정리되며

a<b<c<d , T[a] > T[b] > T[c] > T[d]라는 조건에서

준 식의 값은 양수가 된다

즉 다시써서 C[a][c] + C[b][d] > C[a][d] + C[b][c] 를 만족하므로 divide & conquar optimization 을 사용 할 수 있다

apio 2010 patrol 간략한 풀이

makesource — Sun, 3 Feb 2013 17:31:38 +0900

우선 K=1일때에는 트리의 지름에 설치하는것이 가장최적이라는 결론을 내릴수 있는데

그에 대한 증명을 위해서 지름길을 설치했을때의 경로길이를 수식으로 표현해보자

일단 지름길을 설치하지 않았을때에는 모든간선을 2번씩 지나야함으로

경로이길이는 2(N-1)이 된다.

지름길을 하나 설치하면 트리에 간선을 하나 추가하는 행위임으로 반드시 하나의 사이클이 생기게된다.

이때 사이클 위에 존재하는 간선은 한번씩만 사이클위에 속하지 않는 간선은 2번씩지나야함으로

경로의 길이는 2(N-1) - L + 1이 되는데 L은 (사이클 위에 포함된 정점의 갯수-1)개 이다.

따라서 K=1일때는 간선을 추가하여 만드는 사이클의 길이(즉, 정점갯수-1) 가 최대가 되게 하면 됨으로

트리에 지름에 설치하는것이 가장 최적이라는 결과가 나온다.

이제 K=2일때 생각을 해보자

우리가 설치할 두개의 지름길에 따라서 생기는 사이클의 갯수도 2개가 된다.

이때 두개의 사이클이 하나이상의 엣지를 공유하는경우(같은 정점을 공유하는것은 상관없다)와

엣지를 공유하지 않는경우로 생각할수 있는데

엣지를 공유하지 않는경우에는 트리에서 두개의 경로의합이 가장크게 하는 정점을 찾으면 된다.

그러면 엣지를 서로 공유하는 경우가 문제가되는데, 이는 두개의 경로를 조금만 변형시켜주면 서로 엣지를 공유하지 않도록 바꿀수있다

즉 (v1,v2)를 연결하는 지름길 e1 과 (v3,v4)를 연결하는 지름길 e2를

1. (v1,v3)와 (v2,v4)로 연결하거나

2. (v1,v4)와 (v2,v3)로 연결하면

두개중 하나의 경우에서는 반드시 겹치는 경로가 사라지게 된다.

즉 K=2일때에는 트리에서 두개의 경로의합이 최대가되는 경로 2개만 찾으면된다.

이사실을 알았을때

K=1일때와 K=2일때 해결하는방법을 알아보자

i) K=1일때

간단한 트리DP로 해결가능하다

H[u] = u와 u의 자식간의 가장 긴 경로의 길이(끝점중 하나가 u라는뜻); 로 정의하면 O(N)만에 해결할수 있을것이다.

ii) K=2일때

K=1일때보다는 조금 복잡하지만 여전히 트리 DP로 해결하다.

우선 구현에 사용되는 DP table정의를 모두 적어보면 다음과 같다.

H[u] = u와 u의 자식간의 가장 긴 경로의 길이(끝점중 하나가 u라는뜻)

L[u] = u의 서브트리들중에서 u를 포함한 가장긴 경로의 길이

A[u] = u의 서브트리들중에서 가장긴 경로의 길이

B[u] = u의 서브트리들중에서 엣지가 서로 곂치지 않는 서로다른 두개의 경로의 길이의 최대합

이때 두개의 경로를 P,Q라고 하자, P 경로의 끝점은 반드시 u 가 되어야함.

D[u] = u의 서브트리들중에서 서로 곂치지않는 경로2개의 길이의 최대합

H[u]는 트리 순회하면서 O(N)만에 가능

L[u]는 H[u]를 이용해서 O(N)만에 가능

A[u]는 L[u]를 이용해서 O(N)만에 가능

B[u]는 그냥 하면 O(N^2) 이되는데 잘하면 O(N)으로 가능하다

D[u]도 그냥 하면 O(N^2) 이되는데 잘하면 O(N)으로 가능하다

*B[u]와 D[u] 잘 계산하는방법*

B[u]는 세가지 경우로 나눌수있는데

1. 두개의 경로 P,Q가 모두 정점 u를 포함하는경우 (단 P의 끝점은 u)

이때 B[u]는 u의 자식정점을 CH(u)라고 정의할때 H[CH(u)]의 최댓값3개의 합이다.

2. 두개의 경로 P,Q가 있는데 u의 자식들중 임의로 하나를 v 라고하자 이때 경로 P는 edge(u,v)를 포함하는경로이고

Q는 v의 서브트리에 완전히 포함되는 가장긴 경로이다. 이때는 B[u] = B[v] + 1

3. 두개의 경로 P,Q가 있는데 u의 자식들중 임의로 두개를 v,w라고 하자 이때 경로 P는 edge(u,v)를 포함하는 경로이고

Q는 w의 서브트리에 완전히 포함되는 가장긴 경로이다. B[u] = H[v] + A[w] + 1;

D[u]도 세가지 경우로 나눌수 있는데

1. 두개의 경로 P,Q가 모두 u를 포함하는경우 , u의 자식을 CH(u)라고 할때 D[u] = H[CH(u)]의 최댓값 두개의 합 + 2

2. 두개의 경로 P,Q모두 u를 포함하지 않는경우 , u의 자식을 CH(u)라고 할때 D[u] = A[CH(u)]의 최댓값 두개의 합

3. 두개의 경로 P,Q중 하나만 u를 포함하는경우 , D[u] = B[u];

따라서 총 시간복잡도는 O(N)이 된다.

그래프 관련

makesource — Sat, 3 Nov 2012 20:50:35 +0900

그래프 에서

매칭 = 변집합 로, 상호 끝점을 공유하지 않는다.

변 덮개 = 변집합 로, 의 어떤 정점도 적어도 1개의 에 포함된 변에 접속 하고 있다.

안정집합 = 점집합 로, 의 어떤 두점도 에 대해 인접하고 있지 않다.

점 덮개 = 점집합 로, 의 어떤 변도 적어도 1개의 에 포함된 정점에 접속하고 있다.

일때 몇가지 법칙이 성립한다.

1. 고립점이 없는 그래프에서 대해서, |최대매칭| + |최소 변 덮개| = |V|

2. |최대 안정 집합| + |최소 점 덮개| = |V|

특히 이분그래프에서는

|최대 매칭| = |최소 변 덮개| 가 된다.

http://prague.algospot.com/judge/problem/read/TRAPCARD

위 문제가 위의 성질을 이용하여 풀수있는 대표적인 문제이다

이문제는 갯수만 출력하는것이 아니라 그 구체적인 예시까지 출력해야되는 문제인데.

이분그래프에서 minimum vertex cover를 찾는 방법은 다음과 같다.

이분그래프 에서 최소 점덮개(minimum vertex cover)를 라고 하자

이분매칭을 돌리고 나온 그래프에서 residual edge를 따라 갈수있는 정점을 라고 하면

가 된다.

다이나믹 -- 시작복잡도 줄이기

makesource — Wed, 15 Aug 2012 20:36:32 +0900

dynamic programming 문제들중

와 같은 점화식을 가진 문제들에 대해 생각해보자.

실제로 최근 KOI에서도 위와 같은 점화식을 가진 문제가 몇몇 나왔는데

2011 전국 중등부3 번이라던가

2011 지역 고등부5 번을 예로 들 수 있다.

위와 같은 점화식을 가진 문제는 특수한 경우에 따라 시간복잡도를

에서 으로 바꿔 풀 수 있다.

1. commando (APIO 2010)

위 문제의 점화식을 나타내보면

여기서 bX항은 그룹을 어떻게 나누는지에는 상관없이 항상 그 값은 과 같게 된다.

따라서 위 점화식을

로 두고 마지막에 b*(x1+x2..+xn) 을 더해주면 위와같은 점화식이 된다는것을 확인할 수 있다. 그리고 c는 j값에 상관없이 항상 일정한 값을 가지기 때문에

우리는 고정된 i 에 대하여

의 값을만에 구할수 있다면 시간복잡도는 이 될것이다.

편의상

로 정의하면, 점화식을 다음과 같이 나타낼수 있다.

두번째 식에서 세번째 식으로 넘어가는 과정에서 항이 밖으로 빠저나간 이유는 D(i)값을 구할때 고정된 i에 대해서 생각하기 때문이다. 위와 같이 정의한후 라는 함수를 생각해 보자.

그러면 위 함수는 일정한 특징을 가진 일차함수가 된다.

<특징1> j가 증가함에 따라서 기울기가 증가하는 함수이다. (-5 <= a <=-1 임으로)

<특징2> 기울기가 동일한 j와 j'는 존재하지 않는다.

이러한 사실을 알았을때, i = 5 일때 임의의 그래프를 그려보면

다음과 같습니다. 이러한 후보들 중에서 값이 주어졌을때 함수값이 최대가 되는 j후보를 찾는것이 문제의 핵심인데,

그러면 모든 j의 후보에 대해서 교점을 찾아서 함숫값을 구하면 각 i에 대해서 N번 즉 O(N^2) 이 되어버린다.

그러나 아까 찾은 특징을 생각해 보면 어떤 j에 대하여 그 함수값이 최대가 되는 어떠한 구간들을 각각 가지고 있다.

그렇다면 j후보에 대해서 직선들의 교점에 대한 list들을 관리해 주면서, 값이 주어졌을때 최댓값으로 인정받는 j를 binary search 로 찾아주고, i -> i+1이 될때 i에 대한 직선을 list에 update 시켜 준다면 풀이는 완성이 되었다.

직선을 update시켜줄때 주의해야할 점이 하나 있는데,

다음과 같은 상황일때이다. 이런 상황에선 list들을 뒤에서 부터 pop해주면서 필요없는 직선은 버리면 된다.

에서 으로 줄이는 아이디어는 간단하다.

바로 값은 항상 증가한다는 사실이다. 즉 binary search로 j후보를 찾을 필요없이 list의 앞에서 부터 값이 최댓값으로 인정받는 구간이 아니라면 pop해버리면 된다. 아까 말했듣이 값은 항상 증가하기때문에 pop한 j의 후보에 대해선 다시 참조할 일이 없기 때문이다.

2. 책장 (KOI 2011)

// 작성중

컨베이어 벨트

makesource — Fri, 13 Apr 2012 00:50:57 +0900

링크 : http://211.228.163.31/pool/coci_traka/coci_traka.php?pname=coci_traka

Solution

1) O(NM)

D(j) = j번째 사람이 첫번째 작업을 시작할 최소시간

이라 정의하자.

그러면 모든 i에 대하여

D(j) + {T(1)+T(2)+T(3)...+T(i)}*F(j) <= D(j+1) + {T(1)+T(2)+T(3)...+T(i-1)}*F(j+1) 이 성립해야 한다.

즉 모든 작업i에 대해서 j+1번째 사람이 i번째 작업을 시작할 시간은 j번째 사람이 i번째 작업을 끝낸 시간보다 같거나 커야한다.

위식을 정리하면

모든 i에 대해서

D(j+1) >= D(j) + {T(1)+T(2)+T(3)...+T(i-1)}{F(j)-F(j+1)} + T(i)*F(j)

가 성립해야한다.

즉

D(j+1) = D(j) + max( {T(1)+T(2)+T(3)...+T(i-1)}{F(j)-F(j+1)} + T(i)*F(j) )

라는 식을 얻어낼수 있다.

따라서 모든j에 대해서 모든 i를 훑으면, O(NM)솔루션을 얻어낼수 있다.

2) O(NlgM)

다음과 같은 함수를 정의하자

C(i,j) = {T(1)+T(2)+T(3)...+T(i-1)}{F(j)-F(j+1)} + T(i)*F(j)

즉, D(j+1) = D(j) + max( C(i,j) ) 이다

1 <= i1 < i2 <= M 에 대해서 C(i1,j) <= C(i2,j) 일 필요충분 조건을 구해보자

C(i1,j) <= C(i2,j)

<==> {T(1)+T(2)+T(3)...+T(i1-1)}{F(j)-F(j+1)} + T(i1)*F(j) <= {T(1)+T(2)+T(3)...+T(i2-1)}{F(j)-F(j+1)} + T(i2)*F(j)

<==> F(j){T(i1)-T(i2)} <= {F(j)-F(j+1)}{T(i1)+T(i1+1) ... + T(i2-2) + T(i2-1)}

<==>

<==>

여기서 복잡한 식을 간단히 하기위해 다음과같은 함수를 정의한다

그러면 다음과 같은 결론을 얻을수 있다.

위의 결론을 바탕으로 몇가지 정보를 얻어낼수 있다.

(i1<i2<i3)에서

i) f(j) <= t(i1,i2) <= t(i2,i3) <==> C(i1,j) <= C(i2,j) <= C(i3,j)

즉 고정된 j에 대해서 i1과 i2는 고려 할 필요 없는 선택지이다.

ii) t(i1,i2) <= f(j) <= t(i2,i3) <==> C(i1,j) >= C(i2,j) & C(i2,j) <= C(i3,j)

즉 고정된 j에 대해서 i2는 고려 할 필요 없는 선택지이다.

iii) t(i1,i2) <= t(i2,i3) <= f(j) <==> C(i1,j) >= C(i2,j) >= C(i3,j)

즉 고정된 j에 대해서 i2와 i3는 고려 할 필요 없는 선택지이다.

위 3가지 정보를 결합하면 f(j)값이 증가하든지 감소하든지에 상관없이 t(i1,i2) <= t(i2,i3)가 성립한다면, i2는 필요없는 선택지이다.

f(j) 값에 관계가 없기 때문에 j1<j2 에서 j1에서 제거된 i의 리스트는 j2에서 또한 필요없는 리스트가 된다. 즉 리스트에 한번빠진 i의 후보는 다시 추가될 필요없다.

그렇다면 이렇게 남은 i의 후보를 L1,L2,L3...Lk라고 하면

t(L1,L2) > t(L2,L3) > t(L3,L4) ... > t(L(k-1),Lk) 가 성립한다.

만약 (1<=p<k)인 p에 대해서

t(L1,L2) > t(L2,L3) > t(L3,L4) ... > t(L(p-1),Lp) >= f(j) > t(Lp,L(p+1) ... > t(L(k-1),Lk)

가 성립하면

C(L1,j) < C(L2,j) ... < C(L(p-1),j) < C(Lp,j) > C(L(p+1),j) > ... > C(L(k-1),j) > C(Lk,j)

가 성립한다

즉,

D(j+1) = D(j) + C(Lp,j)이며,

p의 위치는 모든 j 에 대해서 binary search로 log복잡도 만에 찾을수 있음으로

최종적인 알고리즘의 시간복잡도는 O(NlgM)가 된다

Hanoi Tower

makesource — Sat, 25 Feb 2012 01:09:41 +0900

http://211.228.163.31/30stair/hanoi1/hanoi1.php?pname=hanoi1

문제를 요약하자면 현재상태의 하노이 탑이 주어졌을때 1,2,3번 기둥중 어떤기둥으로 옮기는지는 상관없고, 최소의 이동으로 모든 조각을 한곳에 모을때 최소이동과 어디로 모으는 것이 최적인지 구하는것이다.

일단 이문제는 linear 하게 풀릴수 있다.
가장 쉽게 떠올릴수 있는 방법이 모든 경우를 다해보는 backtracking 기법인데.
이문제의 실제 N범위가 100,000인걸 감안한다면 으론 해결할수 없다.

그렇다면 어떻게 접근해야 풀수 있을까?

1)
우선 우리는 N개의 하노이를 한 기둥에서 다른기둥으로 옮기기 위해 이동해야하는 최소횟수는 임이 자명하다.

2)
그리고 우리가 최종적으로 옮겨야할 목적지는 가장 큰 조각이 위치한 기둥임을 직관적으로 알수 있을것이다.

이유를 설명하자면 가장큰 조각이 존재하는 기둥을 P1이라고 한고 P2에 모든 조각을 모은다고 하자.
P2에는 어떠한 조각이 있더라도 가장 큰 조각이 P2의 가장 밑바닥에 깔려야 함으로 이는 P2의 모든조각을 P3으로 옮긴뒤 P1에 존재하는 가장 큰 조각을 P2 로 옮겨야된다. 그러나 생각해보면 맨처음 상태나 위와같이 가장큰 조각을 P2로 옮긴 뒤 상태나 기둥의 번호만 바뀔뿐 다른 것은 바뀐것이없다. 즉 필요없는 이동만 늘어난 샘이 된것이다.

위 두 힌트를 잘 사용한다면 솔루션을 만들어 낼수 있고,

에서 한줄만 바꾸면(주석처리만 하면) 솔루션을 얻어 낼수 있을것이다.