컴공의 노예생활

[백준] 14287 - 내리 갈굼 3

노예2 — Thu, 19 Dec 2019 16:01:06 +0900

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

14287번: 내리 갈굼 3

영선회사에는 치명적인 악습이 있는데, 바로 상사가 직속 부하를 갈구면 그 부하가 부하의 직속 부하를 연쇄적으로 갈구는 내리 갈굼이 있다. 즉, 상사가 한 직속 부하를 갈구면 그 부하의 모든 부하들이 갈굼을 당한다. 이러한 내리 갈굼은 회사에 가장 큰 불만 사항이 되었고, 사장 영선이는 이 불만을 해소해주기 위하여, 단 하루만 야자타임식으로 하여, 반대로 부하가 상사를 갈구면, 그 위로 쭉 사장까지 모두 갈굼을 당한다. 갈굼의 대한 정보는 실시간으로 주어진

www.acmicpc.net

내리 갈굼 2 문제에서 거꾸로 부하가 상사를 갈구는 문제.

상사가 받은 갈굼 정도는 부하들이 받은 내리갈굼의 합과 같다.

전위순회로 트리를 구조화하고 구간합을 구하는 segment tree로 답을 구할 수 있다.

<C++ code>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
#include <cstdio>
#include <vector>
#include <cmath>
using namespace std;
 
int n, m;
vector<int> tree, lazy, arr, l, r, child[100001], v;
 
void preorder(int node, int& cnt){
    l[node] = ++cnt;
    for(int i: child[node]){
        preorder(i, cnt);
    }
    r[node] = cnt;
}
 
void update_lazy(int node, int start, int end){
    if(lazy[node] != 0){
        tree[node] += lazy[node];
        if(start != end){
            lazy[node * 2] += lazy[node];
            lazy[node * 2 + 1] += lazy[node];
        }
        lazy[node] = 0;
    }
}
 
void update_range(int node, int start, int end, int left, int right, int diff){
    update_lazy(node, start, end);
    if(left > end || right < start) return;
    if(left <= start && end <= right){
        tree[node] += diff;
        if(start != end){
            lazy[node * 2] += diff;
            lazy[node * 2 + 1] += diff;
        }
        return;
    }
    update_range(node * 2, start, (start + end) / 2, left, right, diff);
    update_range(node * 2 + 1, (start + end) / 2 + 1, end, left, right, diff);
    tree[node] = tree[node * 2] + tree[node * 2 + 1];
}
 
int query(int node, int start, int end, int left, int right){
    update_lazy(node, start, end);
    if(left > end || right < start) return 0;
    if(left <= start && end <= right) return tree[node];
    return query(node * 2, start, (start + end) / 2, left, right) + query(node * 2 + 1, (start + end) / 2 + 1, end, left, right);
}
 
int main(){
    int tmp, cnt = 0;
    scanf("%d %d", &n, &m);
    scanf("%d", &tmp);
    for(int i=2; i<=n; i++){
        scanf("%d", &tmp);
        child[tmp].push_back(i);
    }
    l.resize(n+1);
    r.resize(n+1);
    preorder(1, cnt);
 
    int h = (int)ceil(log2(n));
    int tree_size = (1 << (h + 1)) - 1;
    tree.resize(tree_size);
    lazy.resize(tree_size);
 
    while(m--){
        int a, b, c;
        scanf("%d %d", &a, &b);
        if(a == 1){
            scanf("%d", &c);
            update_range(1, 0, n-1, l[b]-1, l[b]-1, c);
        }
        else{
            printf("%d\n", query(1, 0, n-1, l[b]-1, r[b]-1));
        }
    }
 
    return 0;
}
Colored by Color Scripter
cs

[백준] 2820 - 자동차 공장

노예2 — Wed, 18 Dec 2019 17:45:44 +0900

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

2820번: 자동차 공장

문제 상근이는 자동차를 매우 좋아한다. 자동차 공장에 취직한 상근이는 계속된 승진 끝에 드디어 사장이 되었다. 공장에는 총 N명의 직원이 있다. 상근이를 제외한 모든 직원은 한 명의 상사가 있다. (상근이는 모든 사람의 상사이다) 상근이의 번호는 1번이고, 나머지 직원의 번호는 2부터 N이다. 모든 직원은 자신의 모든 부하 직원(직속 부하와 부하의 부하등등을 모두 포함)의 월급을 인상하거나 삭감할 수 있다. 상근이는 권력 남용을 막기 위해 직원의 월급을

www.acmicpc.net

구간합을 구하는 문제는 아니지만 트리에서 자식들의 갱신이 이루어지는 문제이므로

segment tree와 lazy propagation을 통해 문제를 풀 수 있다.

dfs를 통해 각 사원의 위치를 계산하고 O(lgn) 으로 쿼리를 처리할 수 있다.

<C++ code>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
#include <cstdio>
#include <vector>
#include <cmath>
using namespace std;
 
int n, m;
vector<int> arr, arr_tmp, tree, lazy, l, r;
vector<int> child[500001];
 
void pre_order(int i, int &cnt){
    l[i] = ++cnt;
    for(int v: child[i]){
        pre_order(v, cnt);
    }
    r[i] = cnt;
}
 
void init(int node, int start, int end){
    if(start == end){
        tree[node] = arr_tmp[end + 1];
        return;
    }
    init(node * 2, start, (start + end) / 2);
    init(node * 2 + 1, (start + end) / 2 + 1, end);
}
 
void update_lazy(int node, int start ,int end){
    if(lazy[node] != 0){
        tree[node] += lazy[node];
        if(start != end){
            lazy[node * 2] += lazy[node];
            lazy[node * 2 + 1] += lazy[node];
        }
        lazy[node] = 0;
    }
}
 
void update_range(int node, int start, int end, int left, int right, int diff){
    update_lazy(node, start, end);
    if(start > right || left > end) return;
    if(left <= start && end <= right){
        tree[node] += diff;
        if(start != end){
            lazy[node * 2] += diff;
            lazy[node * 2 + 1] += diff;
        }
        return;
    }
    update_range(node * 2, start, (start + end) / 2, left, right, diff);
    update_range(node * 2 + 1, (start + end) / 2 + 1, end, left, right, diff);
}
 
int query(int node, int start, int end, int idx){
    update_lazy(node, start, end);
    if(start > idx || end < idx) return 0;
    if(start == end && start == idx){
        return tree[node];
    }
    return query(node * 2, start, (start + end) / 2, idx) + query(node * 2 + 1, (start + end) / 2 + 1, end, idx);
}
 
int main(){
    scanf("%d %d", &n, &m);
    
    arr.resize(n+1);
    scanf("%d", &arr[1]);
    for(int i=2; i<=n; i++){
        int tmp;
        scanf("%d %d", &arr[i], &tmp);
        child[tmp].push_back(i);
    }
    int cnt = 0;
    l.resize(n+1);
    r.resize(n+1);
    pre_order(1, cnt);
 
    int h = (int)ceil(log2(n));
    int tree_size = (1 << (h+1)) - 1;
    tree.resize(tree_size);
    lazy.resize(tree_size);
    arr_tmp.resize(n+1);
    for(int i=1; i<=n; i++){
        arr_tmp[l[i]] = arr[i];
    }
    init(1, 0, n-1);
 
    while(m--){
        char q;
        int a, x;
        scanf("%*c%c", &q);
        if(q == 'p'){
            scanf("%d %d", &a, &x);
            update_range(1, 0, n-1, l[a], r[a]-1, x);
        }
        else{
            scanf("%d", &a);
            printf("%d\n", query(1, 0, n-1, l[a] - 1));
        }
    }
 
    return 0;
}
Colored by Color Scripter
cs

[백준] 14268 - 내리 갈굼 2

노예2 — Mon, 9 Dec 2019 20:13:45 +0900

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

14268번: 내리 갈굼 2

영선회사에는 치명적인 악습이 있는데, 바로 상사가 직속 부하를 갈구면 그 부하가 부하의 직속 부하를 연쇄적으로 갈구는 내리 갈굼이 있다. 즉, 상사가 한 직속 부하를 갈구면 그 부하의 모든 부하들이 갈굼을 당한다. 갈굼에 대해 정도에 대한 수치가 주어지는데, 이 수치 또한 부하들에게 똑같이 갈궈진다. 이번에는 내리 갈굼이 실시간으로 일어날 것이다. 입력으로 아래와 같은 쿼리가 주어질 것이다. 1 i w : i번째 직원이 직속 상사로부터 w만큼 갈굼을 당한

www.acmicpc.net

앞선 내리 갈굼 문제에서 갱신 중간에 쿼리가 주어지는 문제이다.

내리 갈굼 문제의 알고리즘에서 dfs를 이용하여 해당 사원의 상사를 모두 갱신하는 방법은 TLE가 발생했다.

lazy propagation을 사용하기 위해서 주어진 트리를 segment tree의 형태로 바꾸어야 한다.

pre-order 순회를 통해 segment tree를 만들 수 있다. (링크)

각 사원의 위치는 left에, 가장 먼 부하 직원의 위치는 right 벡터에 저장된다.

<C++ 코드>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

#include <cstdio>
#include <vector>
#include <cmath>
using namespace std;
 
int n, m;
vector<int> son[100001];
vector<int> tree, lazy, left, right;
 
void preorder(int node, int &cnt){
    left[node] = ++cnt;
    for(int s :son[node]){
        preorder(s, cnt);
    }
    right[node] = cnt;
}
 
void update_lazy(int node, int start, int end){
    if(lazy[node] != 0){
        tree[node] += lazy[node];
        if(start != end){
            lazy[node * 2] += lazy[node];
            lazy[node * 2 + 1] += lazy[node];
        }
        lazy[node] = 0;
    }
}
 
void update_range(int node, int start, int end, int l, int r, int w){
    update_lazy(node, start, end);
    if(l > end || r < start) return;
    if(l <= start && end <= r){
        tree[node] += w;
        if(start != end){
            lazy[node * 2] += w;
            lazy[node * 2 + 1] += w;
        }
        return;
    }
    update_range(node * 2, start, (start + end) / 2, l, r, w);
    update_range(node * 2 + 1, (start + end) / 2 + 1, end, l, r, w);
    tree[node] = tree[node * 2] + tree[node * 2 + 1];
}
 
int value(int node, int start, int end, int idx){
    update_lazy(node, start, end);
    if(start > idx || idx > end) return 0;
    if(start == end && start == idx) return tree[node];
    return value(node * 2, start, (start + end)/2, idx) + value(node * 2 + 1, (start + end)/2 + 1, end, idx);
}
 
int main(){
    int t;
    scanf("%d %d", &n, &m);
    left.resize(n+1);
    right.resize(n+1);
    int h = (int)ceil(log2(n));
    int tree_size = (1 << (h+1)) - 1;
    tree.resize(tree_size);
    lazy.resize(tree_size);
    scanf("%d", &t);
    for(int i=2; i<=n; i++){
        scanf("%d", &t);
        son[t].push_back(i);
    }
    int cnt = 0;
    preorder(1, cnt);
 
    for(int i=0; i<m; i++){
        int a, b, c;
        scanf("%d %d", &a, &b);
        if(a == 1){
            scanf("%d", &c);
            update_range(1, 0, n-1, left[b] - 1, right[b] - 1, c);
        }
        else if(a == 2){
            printf("%d\n", value(1, 0, n-1, left[b] -1));
        }
    }
    return 0;
}
Colored by Color Scripter

cs

[백준] 14267 - 내리갈굼

노예2 — Mon, 9 Dec 2019 18:29:06 +0900

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

14267번: 내리 갈굼

영선회사에는 치명적인 악습이 있는데, 바로 상사가 직속 부하를 갈구면 그 부하가 부하의 직속 부하를 연쇄적으로 갈구는 내리 갈굼이 있다. 즉, 상사가 한 직속 부하를 갈구면 그 부하의 모든 부하들이 갈굼을 당한다. 갈굼에 대해 정도에 대한 수치가 주어지는데, 이 수치 또한 부하들에게 똑같이 갈궈진다. 직속 상사와 직속 부하관계에 대해 주어지고, 갈굼에 대한 정보가 주어질 때, 각자 얼마의 갈굼을 당했는지 출력하시오,

www.acmicpc.net

갈굼 수치를 입력받을 때, 바로 모든 수치를 전파하는 것은 비효율적이다.

모든 수치를 입력받은 후에, 해당 부모의 수치를 갱신하고 자식에게 전파하는 경우 불필요한 탐색과 갱신을 줄일 수 있다.

이 문제의 경우에는 부모가 자식보다 작은 수를 가지므로 1번부터 순서대로 답을 구하면 된다.

<C++ 코드>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

#include <cstdio>
#include <vector>
using namespace std;
 
int n, m;
vector<int> par[100001];
vector<int> re, diff;
 
int main(){
    int t;
    scanf("%d %d", &n, &m);
    re.resize(n+1);
    diff.resize(n+1);
    scanf("%d", &t);
    for(int i=2; i<=n; i++){
        scanf("%d", &t);
        par[t].push_back(i);
    }
    for(int i=0; i<m; i++){
        int a, b;
        scanf("%d %d", &a, &b);
        diff[a] += b;
    }
    for(int i=1; i<=n; i++){
        if(diff[i] != 0){
            re[i] += diff[i];
            for(int j=0; j<par[i].size(); j++){
                diff[par[i][j]] += diff[i];
            }
            diff[i] = 0;
        }
        printf("%d ", re[i]);
    }
    return 0;
}
Colored by Color Scripter

cs

[백준] 17822 - 원판 돌리기

노예2 — Mon, 2 Dec 2019 15:56:18 +0900

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

17822번: 원판 돌리기

반지름이 1, 2, ..., N인 원판이 크기가 작아지는 순으로 바닥에 놓여있고, 원판의 중심은 모두 같다. 각각의 원판에는 M개의 정수가 적혀있고, i번째 원판에 적힌 j번째 수의 위치는 (i, j)로 표현한다. 수의 위치는 다음을 만족한다. (i, 1)은 (i, 2), (i, M)과 인접하다. (i, M)은 (i, M-1), (i, 1)과 인접하다. (i, j)는 (i, j-1), (i, j+1)과 인접하다. (2 ≤ j ≤ M-1) (1, j)는 (

www.acmicpc.net

회전 시의 인덱스 변화를 잘 신경쓴다면 어렵지 않은 구현 문제..

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

#include <cstdio>
using namespace std;
 
int n, m, t;
int arr[52][52], rot[52], check[52][52];
int dv[2] = {1, -1};
 
inline int idx(int i){
    int t = ((i % m) + m) % m; 
    if(t == 0) return m;
    else return t;
}
 
void near(){
    for(int i=1; i<=n; i++){
        for(int j=1; j<=m; j++){
            check[i][j] = 0;
        }
    }
    for(int i=1; i<=n; i++){
        // 좌우 근접
        for(int j=1; j<m; j++){
            if(arr[i][j] == arr[i][j+1]){
                check[i][j] = check[i][j+1] = 1;
            }
        }
        if(arr[i][1] == arr[i][m]) check[i][1] = check[i][m] = 1;
        
        // 상하 근접
        for(int j=1; j<=m; j++){
            if(arr[i][j] == arr[i+1][idx(j + rot[i] - rot[i+1])]){
                check[i][j] = check[i+1][idx(j + rot[i] - rot[i+1])] = 1;
            }
        }
    }
    
    bool change = false;
    for(int i=1; i<=n; i++){
        for(int j=1; j<=m; j++){
            if(check[i][j] == 1){
                if(arr[i][j] != 0) change = true;
                arr[i][j] = 0;
            }
        }
    }
 
    if(!change){
        int cnt = 0, s = 0;
        for(int i=1; i<=n; i++){
            for(int j=1; j<=m; j++){
                if(arr[i][j] != 0){
                    cnt++;
                    s += arr[i][j];
                }
            }
        }
        double aver = (double)s / cnt;
        for(int i=1; i<=n; i++){
            for(int j=1; j<=m; j++){
                if(arr[i][j] != 0 && arr[i][j] > aver) arr[i][j]--;
                else if(arr[i][j] != 0 && arr[i][j] < aver) arr[i][j]++;
            }
        }
    }
}
 
int main(){
    scanf("%d %d %d", &n, &m, &t);
    for(int i=1; i<=n; i++){
        for(int j=1; j<=m; j++){
            scanf("%d", &arr[i][j]);
        }
    }
    for(int v=0; v<t; v++){
        int x, d, k;
        scanf("%d %d %d", &x, &d, &k);
        for(int i=x; i<=n; i+=x){
            rot[i] += dv[d] * k;
        }
        near();
    }
 
    int re = 0;
    for(int i=1; i<=n; i++){
        for(int j=1; j<=m; j++){
            re += arr[i][j];
        }
    }
    printf("%d", re);
 
    return 0;
}
Colored by Color Scripter

cs

[백준] 2357 - 최솟값과 최댓값

노예2 — Sat, 30 Nov 2019 16:46:15 +0900

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

2357번: 최솟값과 최댓값

N(1 ≤ N ≤ 100,000)개의 정수들이 있을 때, a번째 정수부터 b번째 정수까지 중에서 제일 작은 정수, 또는 제일 큰 정수를 찾는 것은 어려운 일이 아니다. 하지만 이와 같은 a, b의 쌍이 M(1 ≤ M ≤ 100,000)개 주어졌을 때는 어려운 문제가 된다. 이 문제를 해결해 보자. 여기서 a번째라는 것은 입력되는 순서로 a번째라는 이야기이다. 예를 들어 a=1, b=3이라면 입력된 순서대로 1번, 2번, 3번 정수 중에서 최소, 최댓값을

www.acmicpc.net

Segment Tree를 이용하여 시간을 단축할 수 있는 문제

아래의 페이지에 설명이 잘 정리되어 있다.

https://www.acmicpc.net/blog/view/9

세그먼트 트리 (Segment Tree)

문제 배열 A가 있고, 여기서 다음과 같은 두 연산을 수행해야하는 문제를 생각해봅시다. 구간 l, r (l ≤ r)이 주어졌을 때, A[l] + A[l+1] + ... + A[r-1] + A[r]을 구해서 출력하기 i번째 수를 v로 바꾸기. A[i] = v 수행해야하는 연산은 최대 M번입니다. 세그먼트 트리나 다른 방법을 사용하지 않고 문제를 푼다면, 1번 연산을 수행하는데 O(N), 2번 연산을 수행하는데 O(1)이 걸리게 됩니다. 총 시간 복잡도는 O

www.acmicpc.net

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

#include <cstdio>
#include <vector>
#include <cmath>
#include <algorithm>
using namespace std;
 
int arr[100001];
vector<int> min_tree, max_tree;
 
void init(int node, int start, int end){
    if(start == end){
        min_tree[node] = max_tree[node] = arr[start];
        return;
    }
    init(node * 2, start, (start + end) / 2);
    init(node * 2 + 1, (start + end) / 2 + 1, end);
    min_tree[node] = min(min_tree[node * 2], min_tree[node * 2 + 1]);
    max_tree[node] = max(max_tree[node * 2], max_tree[node * 2 + 1]);
    return;
}
 
pair<int, int> find(int node, int a, int b, int left, int right){
    if(left > b || right < a) return make_pair(2147483647, 0);
    if(a <= left && right <= b){
        return make_pair(min_tree[node], max_tree[node]);
    }
    pair<int, int> l, r;
    l = find(node * 2, a, b, left, (left + right) / 2);
    r = find(node * 2 + 1, a, b, (left + right) / 2 + 1, right);
    return make_pair(min(l.first, r.first), max(l.second, r.second));
}
 
int main(){
    int n, m;
    scanf("%d %d", &n, &m);
    int ts = 1 << int(ceil(log2(n)) + 1);
    min_tree.resize(ts);
    max_tree.resize(ts);
 
    for(int i=0; i<n; i++){
        scanf("%d", &arr[i]);
    }
    init(1, 0, n-1);
    for(int i=0; i<m; i++){
        int a, b;
        scanf("%d %d", &a, &b);
        pair<int, int> f = find(1, a-1, b-1, 0, n-1);
        printf("%d %d\n", f.first, f.second);
    }
 
    return 0;
}
Colored by Color Scripter

cs

[백준] 12766 - 지사 배정

노예2 — Tue, 26 Nov 2019 16:49:56 +0900

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

12766번: 지사 배정

문제 Innovative Consumer Products Company (ICPC)는 비밀 프로젝트를 시작하려하고 있다. 이 프로젝트는 s개의 하위 프로젝트로 구성된다. 이 프로젝트에 관련된 b(≥s)개의 ICPC의 지사들이 있고, ICPC는 각 지사에 하위 프로젝트들 중 하나를 맡기고자 한다. 다시 말하자면, 지사들은 s개의 분리된 그룹으로 나누어지고, 각 그룹이 한 하위 프로젝트를 맡게 된다. 각 달의 마지막에, 각 지사는 그 그룹에 있는 다른 모든

www.acmicpc.net

b개의 지사를 s개의 프로젝트로 나누었을 때, 메시지 전달 비용의 최솟값을 구하는 문제이다.

교차로 i에서 j까지의 최단거리를 v[i][j]라고 하자. 지사 a가 k개의 지사가 참여하는 프로젝트에 소속되어 있을 때, 지사 a와 관련된 전달 비용은 (k-1) * (v[a][b+1] + v[b+1][a])이다.

즉, 해당 프로젝트에 소속된 다른 지사가 어디인지와는 관계가 없다.

때문에 총 비용의 합계가 최소가 되게 하기 위해서는 (v[a][b+1] + v[b+1][a]) 값이 작은 지사들을 큰 프로젝트에, 값이 큰 지사들을 작은 프로젝트에 투입해야 한다.

각 지사들을 (v[a][b+1] + v[b+1][a]) 순서로 정렬하고 프로젝트를 분리하는 경우 Divide and Conquer Optimization을 적용하여 문제를 해결할 수 있다.

<C++ 코드>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

#include <cstdio>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;
 
int n, b, s, r;
int d[5001], rd[5001];
vector<pair<int, int> > v[5001], rv[5001];
vector<int> value;
 
long long sum[5001];
long long dp[5001][5001];
int p[5001][5001];
 
void dijkstra(int st, int dist[], vector<pair<int, int> > e[]){
    for(int i=1; i<=n; i++)
        dist[i] = 2147483647;
    dist[st] = 0;
    priority_queue<pair<int, int> > pq;
    pq.push({0, st});
    while(!pq.empty()){
        int td = -pq.top().first, p = pq.top().second;
        pq.pop();
        if(td > dist[p]) continue;
        for(int i=0; i<e[p].size(); i++){
            int nd = td + e[p][i].second, np = e[p][i].first;
            if(nd < dist[np]){
                dist[np] = nd;
                pq.push({-nd, np});
            }
        }
    }
    return;
}
 
long long cost(int i, int j){
    return (sum[j] - sum[i]) * (j - i - 1);
}
 
void dnqo(int t, int l, int r, int pl, int pr){
    if(l > r) return;
    int mid = (l + r) / 2;
    dp[t][mid] = p[t][mid] = -1;
 
    for(int k=pl; k<=min(mid-1, pr); k++){
        long long tmp = dp[t-1][k] + cost(k, mid);
        if(dp[t][mid] == -1 || dp[t][mid] > tmp){
            dp[t][mid] = tmp;
            p[t][mid] = k;
        }
    }
 
    dnqo(t, l, mid-1, pl, p[t][mid]);
    dnqo(t, mid+1, r, p[t][mid], pr);
    return;
}
 
int main(){
    scanf("%d %d %d %d", &n, &b, &s, &r);
    for(int i=0; i<r; i++){
        int start, end, l;
        scanf("%d %d %d", &start, &end, &l);
        v[start].push_back({end, l});
        rv[end].push_back({start, l});
    }
 
    dijkstra(b+1, d, v);
    dijkstra(b+1, rd, rv);
 
    for(int i=1; i<=b; i++){
        value.push_back(d[i] + rd[i]);
    }
    sort(value.begin(), value.end());
 
    for(int i=1; i<=b; i++){
        sum[i] = sum[i-1] + value[i-1];
    }
 
    for(int i=1; i<=b; i++){
        dp[1][i] = sum[i] * (i - 1);
        p[1][i] = 1;
    }
    for(int i=2; i<=s; i++){
        dnqo(i, i, b, 0, b);
    }
    printf("%lld", dp[s][b]);
 
    return 0;
}
Colored by Color Scripter

cs

 

[백준] 17142 - 연구소 3

노예2 — Sun, 28 Jul 2019 22:53:27 +0900

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

17142번: 연구소 3

인체에 치명적인 바이러스를 연구하던 연구소에 승원이가 침입했고, 바이러스를 유출하려고 한다. 바이러스는 활성 상태와 비활성 상태가 있다. 가장 처음에 모든 바이러스는 비활성 상태이고, 활성 상태인 바이러스는 상하좌우로 인접한 모든 빈 칸으로 동시에 복제되며, 1초가 걸린다. 승원이는 연구소의 바이러스 M개를 활성 상태로 변경하려고 한다. 연구소는 크기가 N×N인 정사각형으로 나타낼 수 있으며, 정사각형은 1×1 크기의 정사각형으로 나누어져 있다. 연구소는

www.acmicpc.net

시간 제한이 짧은 문제인만큼 시간 단축을 위한 아이디어를 떠올리는 것이 중요하다.

핵심 아이디어는 각각의 바이러스가 서로의 전파를 방해하지 않기 때문에, 각 바이러스를 전파 시킨 후에 가장 먼저 전파된 시간을 선택하면 된다는 것.

우선, 각각의 바이러스를 활성시키고 이를 전파한 결과를 기록한다.

여러 개의 바이러스를 활성화 시키는 경우 앞서 전파한 시간을 가져온 뒤, 해당 위치에서 최솟값을 선택하면 된다.

모든 위치의 전파 시간 중 최댓값을 고르면, 그 값이 최종 전파 시간이 된다.

이를 모든 상황에 대해 탐색하여 최솟값을 계산하면 된다.

<C++ 코드>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
#include <cstdio>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
 
int dfs(int pol[][50][50], int n, int m, int v, int depth, int len, int sel[]){
    if(len == m){
        int r = 0;
        for(int i=0; i<n; i++){
            for(int j=0; j<n; j++){
                int tmp = 10000;
                for(int k=0; k<m; k++){
                    if(pol[sel[k]][i][j] != 0)
                        tmp = min(tmp, pol[sel[k]][i][j]);
                }
                r = max(r, tmp);
            }
        }
        return r;
    }
    if(depth == v){
        return 10000;
    }
 
    int a = dfs(pol, n, m, v, depth+1, len, sel);
    sel[len] = depth;
    int b = dfs(pol, n, m, v, depth+1, len+1, sel);
    return min(a, b);
}
 
int main(){
    int n, m;
    int lab[50][50] = {};
    int pol[10][50][50] = {};
    int dy[4] = {-1, 0, 1, 0}, dx[4] = {0, -1, 0, 1};
    vector<pair<int, int> > vir;
    scanf("%d %d", &n, &m);
 
    for(int i=0; i<n; i++){
        for(int j=0; j<n; j++){
            scanf("%d", &lab[i][j]);
            if(lab[i][j] == 2){
                vir.push_back(make_pair(i, j));
            }
        }
    }
 
    // 벽 표기
    for(int i=0; i<n; i++){
        for(int j=0; j<n; j++){
            if(lab[i][j] != 0){
                for(int v=0; v<vir.size(); v++){
                    pol[v][i][j] = -1;
                }
            }
        }
    }
 
    // 바이러스 미리 전파
    for(int v=0; v<vir.size(); v++){
        queue<pair<int, pair<int, int> > > q;
        bool vis[50][50] = {};
        q.push(make_pair(0, make_pair(vir[v].first, vir[v].second)));
        vis[vir[v].first][vir[v].second] = true;
        while(!q.empty()){
            int t = q.front().first;
            int y = q.front().second.first, x = q.front().second.second;
            q.pop();
            for(int d=0; d<4; d++){
                int ay = y + dy[d], ax = x + dx[d];
                if(ay >= 0 && ax >= 0 && ay < n && ax < n && lab[ay][ax] != 1 && !vis[ay][ax]){
                    if (pol[v][ay][ax] != -1)  
                        pol[v][ay][ax] = t + 1;
                    vis[ay][ax] = true;
                    q.push(make_pair(t + 1, make_pair(ay, ax)));
                }
            }
        }
    }
 
    // m 개 선택 후, 계산
    int sel[10] = {};
    int re = dfs(pol, n, m, vir.size(), 0, 0, sel);
    if(re == 10000)
        printf("-1");
    else
        printf("%d", re);
 
    return 0;
}
Colored by Color Scripter
cs

[백준] 17143 - 낚시왕

노예2 — Thu, 25 Jul 2019 16:52:44 +0900

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

17143번: 낚시왕

낚시왕이 상어 낚시를 하는 곳은 크기가 R×C인 격자판으로 나타낼 수 있다. 격자판의 각 칸은 (r, c)로 나타낼 수 있다. r은 행, c는 열이고, (R, C)는 아래 그림에서 가장 오른쪽 아래에 있는 칸이다. 칸에는 상어가 최대 한 마리 들어있을 수 있다. 상어는 크기와 속도를 가지고 있다. 낚시왕은 처음에 1번 열의 한 칸 왼쪽에 있다. 다음은 1초 동안 일어나는 일이며, 아래 적힌 순서대로 일어난다. 낚시왕은 가장 오른쪽 열의 오른쪽 칸에 이동하

www.acmicpc.net

시뮬레이션 유형의 문제.

python dict를 사용해서 상어의 삭제를 구현했다.

상어가 다른 상어를 잡아먹기 때문에, 동일한 칸에 위치하는지는 이동 후의 상어들끼리만 확인하거나 모든 상어가 이동한 후에 확인해야 한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

import sys
 
lines = sys.stdin.readlines()
R, C, m = tuple(map(int, lines[0].split()))
dr, dc = [0, -1, 1, 0, 0], [0, 0, 0, 1, -1]
reverse_dir = [0, 2, 1, 4, 3]
 
sharks = {}
pos = [[-1 for _ in range(C)] for _ in range(R)]
for n, line in enumerate(lines[1:]):
    r, c, s, d, z = tuple(map(int, line.split()))
    sharks[n] = (r, c, s, d, z)
    pos[r-1][c-1] = n
 
re = 0
 
for depth in range(R):
    if pos[depth][0] != -1:
        re += sharks[pos[depth][0]][4]
        del sharks[pos[depth][0]]
        pos[depth][0] = -1
        break
for col in range(1, C):
    # move
    eaten = []
    pos_tmp = [[-1 for _ in range(C)] for _ in range(R)]
    for k in sharks.keys():
        r, c, s, d, z = sharks[k]
        
        c += (dc[d] * s) % (2 * (C - 1))
        r += (dr[d] * s) % (2 * (R - 1))
 
        for _ in range(2):
            if c < 1:
                c = 2 - c
                d = reverse_dir[d]
            elif c > C:
                c = 2 * C - c
                d = reverse_dir[d]
            elif r < 1:
                r = 2 - r
                d = reverse_dir[d]
            elif r > R:
                r = 2 * R - r
                d = reverse_dir[d]
 
        sharks[k] = (r, c, s, d, z)
        if pos_tmp[r-1][c-1] != -1:
            other = pos_tmp[r-1][c-1]
            if z > sharks[other][4]:
                eaten.append(other)
                pos_tmp[r-1][c-1] = k
            else:
                eaten.append(k)
        else:
            pos_tmp[r-1][c-1] = k
    for e in eaten:
        del sharks[e]
    pos = pos_tmp
 
    # catch
    for depth in range(R):
        if pos[depth][col] != -1:
            re += sharks[pos[depth][col]][4]
            del sharks[pos[depth][col]]
            pos[depth][col] = -1
            break
    
    if len(sharks) == 0:
        break
    
sys.stdout.write(str(re))
    
 
Colored by Color Scripter

cs

[백준] 16234 - 인구 이동

노예2 — Tue, 23 Jul 2019 14:40:42 +0900

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

16234번: 인구 이동

N×N크기의 땅이 있고, 땅은 1×1개의 칸으로 나누어져 있다. 각각의 땅에는 나라가 하나씩 존재하며, r행 c열에 있는 나라에는 A[r][c]명이 살고 있다. 인접한 나라 사이에는 국경선이 존재한다. 모든 나라는 1×1 크기이기 때문에, 모든 국경선은 정사각형 형태이다. 오늘부터 인구 이동이 시작되는 날이다. 인구 이동은 다음과 같이 진행되고, 더 이상 아래 방법에 의해 인구 이동이 없을 때까지 지속된다. 국경선을 공유하는 두 나라의 인구 차이가 L명

www.acmicpc.net

간단한 탐색 문제이고 queue를 이용한 dfs로 풀었다.

<C++ 코드>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
#include <cstdio>
#include <stdlib.h>
#include <string.h>
#include <queue>
using namespace std;
 
int country[50][50];
int vis[50][50];
int dy[4] = {-1, 0, 1, 0}, dx[4] = {0, -1, 0, 1};
 
int main(){
    int n, l, r;
    scanf("%d %d %d", &n, &l, &r);
    for(int i=0; i<n; i++){
        for(int j=0; j<n; j++){
            scanf("%d", &country[i][j]);
        }
    }
    int re = 0;
    while(true){
        bool move = false;
        memset(vis, 0, sizeof(vis));
        for(int i=0; i<n; i++){
            for(int j=0; j<n; j++){
                if(!vis[i][j]){
                    vis[i][j] = true;
                    queue<pair<int, int> > q;
                    vector<pair<int, int> > v;
                    int sum = country[i][j];
                    q.push(make_pair(i, j));
                    v.push_back(make_pair(i, j));
                    while(!q.empty()){
                        int y = q.front().first, x = q.front().second;
                        q.pop();
                        for(int d=0; d<4; d++){
                            int ay = y + dy[d], ax = x + dx[d];
                            if(ay >= 0 && ay < n && ax >= 0 && ax < n && !vis[ay][ax] && abs(country[ay][ax] - country[y][x]) >= l && abs(country[ay][ax] - country[y][x]) <= r){
                                vis[ay][ax] = true;
                                q.push(make_pair(ay, ax));
                                v.push_back(make_pair(ay, ax));
                                sum += country[ay][ax];
                            }
                        }
                    }
                    if(v.size() > 1){
                        int avg = sum / v.size();
                        for(int k=0; k<v.size(); k++){
                            country[v[k].first][v[k].second] = avg;
                        }
                        move = true;
                    }
                }
            }
        }
        if(!move) break;
        else re++;
    }
    printf("%d", re);
    return 0;
}
Colored by Color Scripter
cs