반응형

문제 링크: https://www.acmicpc.net/problem/1005

 

1005번: ACM Craft

첫째 줄에는 테스트케이스의 개수 T가 주어진다. 각 테스트 케이스는 다음과 같이 주어진다. 첫째 줄에 건물의 개수 N과 건물간의 건설순서 규칙의 총 개수 K이 주어진다. (건물의 번호는 1번부

www.acmicpc.net

<문제 풀이> 위상 정렬

 

기본적인 위상 정렬 알고리즘으로 최단거리를 구하면 되는데 주의할 점은

정점 v의 최단거리를 갱신할 때 u -> v에서 u의 건설 시간이 최대가 되는 정점을 택해야 한다.

(u의 모든 정점이 건설이 완료되어야 v를 건설할 수 있으므로 가장 늦게 건설이 완료되는 u를 택함)

dist[v] = max(dist[v], dist[u] + d[v]);

 

<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
#include <iostream>
#include <string>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <utility>
#include <climits>
#include <deque>
 
using namespace std;
 
int n, k;
int d[1001];
vector<int> adj[1001];
int indegree[1001];
int dist[1001];
 
void bfs() {
    queue<int> Q;
    for (int i = 1; i <= n; i++) {
        if (indegree[i] == 0) {
            Q.push(i);
            dist[i] = d[i];
        }
    }
    while (!Q.empty()) {
        int u = Q.front(); Q.pop();
        for (auto& v : adj[u]) {
            dist[v] = max(dist[v], dist[u] + d[v]);
            indegree[v]--;
            if (indegree[v] == 0) {
                Q.push(v);
            }
        }
    }
}
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
 
    int test_case; cin >> test_case;
    while (test_case--) {
        cin >> n >> k;
        for (int i = 1; i <= n; i++) {
            cin >> d[i];
        }
        for (int i = 0; i < k; i++) {
            int x, y;
            cin >> x >> y;
            adj[x].push_back(y);
            indegree[y]++;
        }
        int w; cin >> w;
        bfs();
        cout << dist[w] << '\n';
        fill(dist, dist + 10010);
        fill(indegree, indegree + 10010);
        fill(d, d + 10010);
        for (int i = 0; i < 1001; i++) {
            adj[i].clear();
        }
 
 
    }
 
    return 0;
}
 
cs
반응형

'알고리즘 문제풀이 > 백준' 카테고리의 다른 글

[백준 1780번] 종이의 개수  (0) 2021.12.27
[백준 1766번] 문제집  (0) 2021.12.20
[백준 1516번] 게임 개발  (0) 2021.12.20
[백준 1516번] 게임 개발  (0) 2021.12.20
[백준 14675번] 단절점과 단절선  (0) 2021.12.19
반응형

문제 링크: https://www.acmicpc.net/problem/1516

 

1516번: 게임 개발

첫째 줄에 건물의 종류 수 N(1 ≤ N ≤ 500)이 주어진다. 다음 N개의 줄에는 각 건물을 짓는데 걸리는 시간과 그 건물을 짓기 위해 먼저 지어져야 하는 건물들의 번호가 주어진다. 건물의 번호는 1부

www.acmicpc.net

<문제 풀이> 위상 정렬, 다이나믹 프로그래밍

기본적인 위상정렬 알고리즘으로 최단거리를 갱신하면 되는데 주의할 점이 하나 있습니다.

 

indegree가 0이 되는 건물을 큐에 삽입하면서 최단거리를 갱신할 때 바로 직전 노드로만 판단하면 안 됩니다.

 

 

위와 같은 상황에서 1번 정점을 처리하고 2번 정점을 처리할 때 3번 정점의 indegree가 0이 되어서 3번 정점을 큐에 넣고 바로 직전 노드인 2번 정점으로 최단거리를 갱신하면 올바른 답인 24 가 나오지만

 

위와 같은 상황에서는 1번 정점을 고려하지 않기 때문에 24가 아닌 14가 나오게 됩니다.

 

1번 정점과 2번 정점 모두 건설이 완료되어야 3번 정점을 건설할 수 있으므로,

3번 정점을 건설하는데 걸리는 시간은 

(1번 정점과 2번 정점 중 건설이 가장 오래 걸리는 정점의 건설 시간 + 3번 정점의 건설 시간)이 됩니다

=dist[v] = max(dist[v], dist[u] + takeTime[v]);

 

<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
#include <iostream>
#include <string>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <utility>
#include <climits>
#include <deque>
 
using namespace std;
 
int n;
vector<int> adj[501];
int indegree[501];
int dist[501];
int takeTime[501];
 
void bfs() {
    queue<int> Q;
    for (int i = 1; i <= n; i++) {
        if (indegree[i] == 0) {
            Q.push(i);
            dist[i] = takeTime[i];
        }
    }
    while (!Q.empty()) {
        int u = Q.front(); Q.pop();
        for (auto& v : adj[u]) {
            dist[v] = max(dist[v], dist[u] + takeTime[v]);
            indegree[v]--;
            if (indegree[v] == 0) {
                Q.push(v);
            }
        }
    }
}
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cin >> n;
    for (int v = 1; v <= n; v++) {
        int t;
        cin >> t;
        takeTime[v] = t;
        while (true) {
            int u;
            cin >> u;
            if (u == -1break;
            
            adj[u].push_back(v);
            indegree[v]++;
        }
    }
    bfs();
   
    for (int i = 1; i <= n; i++) {
        cout << dist[i] << '\n';
    }
    return 0;
}
 
cs

 

 

반응형

'알고리즘 문제풀이 > 백준' 카테고리의 다른 글

[백준 1766번] 문제집  (0) 2021.12.20
[뱍쥰 1005번] ACM Craft  (0) 2021.12.20
[백준 1516번] 게임 개발  (0) 2021.12.20
[백준 14675번] 단절점과 단절선  (0) 2021.12.19
[백준 2661번] 좋은수열  (0) 2021.12.16
반응형

문제 링크: https://www.acmicpc.net/problem/1516

 

1516번: 게임 개발

첫째 줄에 건물의 종류 수 N(1 ≤ N ≤ 500)이 주어진다. 다음 N개의 줄에는 각 건물을 짓는데 걸리는 시간과 그 건물을 짓기 위해 먼저 지어져야 하는 건물들의 번호가 주어진다. 건물의 번호는 1부

www.acmicpc.net

<문제 풀이> 위상 정렬, 다이나믹 프로그래밍

기본적인 위상정렬 알고리즘으로 최단거리를 갱신하면 되는데 주의할 점이 하나 있습니다.

 

indegree가 0이 되는 건물을 큐에 삽입하면서 최단거리를 갱신할 때 바로 직전 노드로만 판단하면 안 됩니다.

 

 

위와 같은 상황에서 1번 정점을 처리하고 2번 정점을 처리할 때 3번 정점의 indegree가 0이 되어서 3번 정점을 큐에 넣고 바로 직전 노드인 2번 정점으로 최단거리를 갱신하면 올바른 답인 24 가 나오지만

 

위와 같은 상황에서는 1번 정점을 고려하지 않기 때문에 24가 아닌 14가 나오게 됩니다.

 

1번 정점과 2번 정점 모두 건설이 완료되어야 3번 정점을 건설할 수 있으므로,

3번 정점을 건설하는데 걸리는 시간은 

(1번 정점과 2번 정점 중 건설이 가장 오래 걸리는 정점의 건설 시간 + 3번 정점의 건설 시간)이 됩니다

=dist[v] = max(dist[v], dist[u] + takeTime[v]);

 

<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
#include <iostream>
#include <string>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <utility>
#include <climits>
#include <deque>
 
using namespace std;
 
int n;
vector<int> adj[501];
int indegree[501];
int dist[501];
int takeTime[501];
 
void bfs() {
    queue<int> Q;
    for (int i = 1; i <= n; i++) {
        if (indegree[i] == 0) {
            Q.push(i);
            dist[i] = takeTime[i];
        }
    }
    while (!Q.empty()) {
        int u = Q.front(); Q.pop();
        for (auto& v : adj[u]) {
            dist[v] = max(dist[v], dist[u] + takeTime[v]);
            indegree[v]--;
            if (indegree[v] == 0) {
                Q.push(v);
            }
        }
    }
}
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cin >> n;
    for (int v = 1; v <= n; v++) {
        int t;
        cin >> t;
        takeTime[v] = t;
        while (true) {
            int u;
            cin >> u;
            if (u == -1break;
            
            adj[u].push_back(v);
            indegree[v]++;
        }
    }
    bfs();
   
    for (int i = 1; i <= n; i++) {
        cout << dist[i] << '\n';
    }
    return 0;
}
 
cs

 

 

반응형

'알고리즘 문제풀이 > 백준' 카테고리의 다른 글

[뱍쥰 1005번] ACM Craft  (0) 2021.12.20
[백준 1516번] 게임 개발  (0) 2021.12.20
[백준 14675번] 단절점과 단절선  (0) 2021.12.19
[백준 2661번] 좋은수열  (0) 2021.12.16
[백준 2132번] 나무 위의 벌레  (0) 2021.12.16
반응형

문제 링크: https://www.acmicpc.net/problem/14675

 

14675번: 단절점과 단절선

프로그램의 입력은 표준 입력으로 받는다. 입력의 첫 줄에는 트리의 정점 개수 N이 주어진다. (2 ≤ N ≤ 100,000) 트리의 정점은 1번부터 n번까지 존재한다. 다음 줄부터 N-1개의 줄에 걸쳐 간선의 정

www.acmicpc.net

<문제 풀이> 트리

트리의 모든 간선은 단절선이 될 수 있으므로 t == 2일 때는 무조건 "yes"을 출력하면 됩니다.

트리의 한 정점에 대해서 간선이 두 개 이상이면 무조건 단절점이 됩니다.

 

<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
#include <iostream>
#include <string>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <utility>
#include <climits>
#include <deque>
 
using namespace std;
 
int n;
int indegree[100001];
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cin >> n;
    for (int i = 0; i < n - 1; i++) {
        int a, b;
        cin >> a >> b;
        indegree[a]++;
        indegree[b]++;
    }
    int q; cin >> q;
    for (int i = 0; i < q; i++) {
        int t, k;
        cin >> t >> k;
        if (t == 1) {
            if (indegree[k] >= 2) {
                cout << "yes\n";
            }
            else {
                cout << "no\n";
            }
        }
        else if (t == 2) {
            cout << "yes\n";
        }
    }
    return 0;
}
 
cs

 

반응형

'알고리즘 문제풀이 > 백준' 카테고리의 다른 글

[백준 1516번] 게임 개발  (0) 2021.12.20
[백준 1516번] 게임 개발  (0) 2021.12.20
[백준 2661번] 좋은수열  (0) 2021.12.16
[백준 2132번] 나무 위의 벌레  (0) 2021.12.16
[백준 1167번] 트리의 지름  (0) 2021.12.16
반응형

문제 링크: https://www.acmicpc.net/problem/2661

 

2661번: 좋은수열

첫 번째 줄에 1, 2, 3으로만 이루어져 있는 길이가 N인 좋은 수열들 중에서 가장 작은 수를 나타내는 수열만 출력한다. 수열을 이루는 1, 2, 3들 사이에는 빈칸을 두지 않는다.

www.acmicpc.net

<문제 풀이> 백트래킹

DFS로 수열에 숫자를 하나씩 추가해 나가면 되는데, 숫자를 추가했을 때 좋은 수열이 되는 경우만 추가해야 된다.

121을 예를 들어보면

 

121에서 숫자 1을 추가하면 1211이 된다. 나쁜 수열이 되었으니 숫자를 추가할 수 없다.

121에서 숫자 2를 추가하면 1212가 된다. 나쁜 수열이 되었으니 숫자를 추가할 수 없다. 

121에서 숫자 3을 추가하면 1213이 된다. 좋은 수열이 되었으니 숫자를 추가할 수 있다.

 

[좋은 수열인지 판별하는 방법]

수열의 길이를 n이라고 하면 다음과 같이 비교할 수 있다

1자리로 이루어진 부분 수열 비교

2자리로 이루어진 부분 수열 비교

.

.

 

n/2자리로 이루어진 부분 수열 비교

 

->부분 수열이 모두 다르면 좋은 수열이다.

 

ex) 수열이 123123일 때

1자리로 이루어진 부분 수열 비교

1, 2, 3, 1, 2, 3

2자리로 이루어진 부분 수열 비교

12, 31, 23

6/2 == 3자리로 이루어진 부분 수열 비교

123, 123

 

이제 수열이 좋은 수열인지 판별하는 함수를 만들고 DFS를 진행하면 되는데, 숫자를 추가했을 때 좋은 수열인 경우만 숫자를 추가했으니깐 새로 추가한 숫자가 좋은 수열인지 판별할 때는 부분 수열 뒤에 2개만 확인하면 된다.

 

1자리 일 때

1, 2, 3, 1, 2, 3

2자리 일 때

12, 31, 23

3자리 일 때

123, 123

 

<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
#include <iostream>
#include <string>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <utility>
#include <climits>
#include <deque>
using namespace std;
 
int n;
 
bool isGood(string s) {
    int len = s.length();
    for (int i = 1; i <= len / 2; i++) {
        string a = s.substr(len - i, i);
        string b = s.substr(len - i * 2, i);
        if (a == b) return false;
    }
    return true;
}
 
string dfs(int depth, string &cur) {
    if (depth == n) {
        return cur;
    }
    for (int i = 1; i <= 3; i++) {
        char c = i + '0';
        string next = cur + c;
        if (isGood(next)) {
           string res = dfs(depth + 1, next);
           if (!res.empty()) return res;
        }
    }
    return "";
}
 
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
 
    cin >> n;
    string start = "1";
    cout << dfs(1, start);
    return 0;
}
 
cs

 

반응형
반응형

문제 링크: https://www.acmicpc.net/problem/2132

 

2132번: 나무 위의 벌레

첫째 줄에는 트리의 정점의 개수를 나타내는 정수 n(1 ≤ n ≤ 10,000)이 주어진다. 다음 줄에는 차례로 1번, 2번, …, n번 정점에 매달려 있는 열매의 개수가 주어진다. 다음 n-1개의 줄에는 트리의 각

www.acmicpc.net

<문제 풀이> DFS, BFS, 트리의 지름

 

각 정점에서 BFS를 돌려서 각 정점에서 시작했을 때 최대 거리를 구합니다.

최대 거리가 가장 큰 정점을 시작 정점으로 하면 됩니다.

+트리의 지름을 구하는 것과 동일합니다.

 

 

<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
#include <iostream>
#include <string>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <utility>
#include <climits>
#include <deque>
using namespace std;
 
int n;
int vertex[10001];
vector<int> adj[10001];
int dist[10001];
int max_cnt = 0;
int start = 0;
void bfs() {
    for (int i = n; i >=1; i--) {
        fill(dist, dist + 10001-1);
        queue<int> Q;
        Q.push(i);
        dist[i] = vertex[i];
        while (!Q.empty()) {
            int cur = Q.front(); Q.pop();
            if (dist[cur] >= max_cnt) {
                max_cnt = dist[cur];
                start = i;
            }
            for (auto& next : adj[cur]) {
                if (dist[next] != -1continue;
                dist[next] = dist[cur] + vertex[next];
                Q.push(next);
            }
        }
    }
 
}
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
 
    cin >> n;
    for (int i = 1; i <= n; i++) {
        cin >> vertex[i];
    }
    for (int i = 0; i < n - 1; i++) {
        int u, v;
        cin >> u >> v;
        adj[u].push_back(v);
        adj[v].push_back(u);
    }
    bfs();
    cout << max_cnt << " " << start;
    return 0;
}
 
cs

 

반응형
반응형

문제 링크: https://www.acmicpc.net/problem/1167

 

1167번: 트리의 지름

트리가 입력으로 주어진다. 먼저 첫 번째 줄에서는 트리의 정점의 개수 V가 주어지고 (2 ≤ V ≤ 100,000)둘째 줄부터 V개의 줄에 걸쳐 간선의 정보가 다음과 같이 주어진다. 정점 번호는 1부터 V까지

www.acmicpc.net

<문제 풀이> DFS

https://seokjin2.tistory.com/83

 

[백준 1967번] 트리의 지름

문제 링크:https://www.acmicpc.net/problem/1967 1967번: 트리의 지름 파일의 첫 번째 줄은 노드의 개수 n(1 ≤ n ≤ 10,000)이다. 둘째 줄부터 n-1개의 줄에 각 간선에 대한 정보가 들어온다. 간선에 대한 정보..

seokjin2.tistory.com

1967번 트리의 지름 문제에서는 N제한이 10,000이기 때문에 모든 정점에 대해서 DFS or BFS를 돌려서 O(N^2)에 트리의 지름을 구할 수 있었지만
이문제는 N제한이 100,000이기 때문에 O(N^2)을 하면 시간 초과가 나게 된다.

 

이문제는 모든 정점에 대해서 DFS를 호출하지 않고 DFS를 2번 호출해서 문제를 해결할 수 있다.

 

[트리의 지름 알고리즘]

1. 임의의 정점 x에서 가장 멀리 떨어진 정점 u를 찾는다

2. 1에서 찾은 정점 u에서 가장 멀리 떨어진 정점 v를 찾는다

3. u - v가 트리의 지름이 된다.

 

<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
#include <iostream>
#include <string>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <utility>
#include <climits>
#include <deque>
using namespace std;
 
vector<pair<intint> > adj[100001];
bool visited[100001];
int n;
int maxDist = 0;
int start = 0;
void dfs(int u, int dist) {
    visited[u] = true;
    if (dist > maxDist) {
        start = u;
        maxDist = dist;
    }
    for (auto v : adj[u]) {
        if (visited[v.first])continue;
        dfs(v.first, dist + v.second);
    }
}
 
void solve() {
    dfs(10);
    maxDist = 0;
    fill(visited, visited + 1000010);
    dfs(start, 0);
    cout << maxDist;
}
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
 
    cin >> n;
    for (int i = 1; i <= n; i++) {
        int u; cin >> u;
        while (true) {
            int v, c;
            cin >> v;
            if (v == -1break;
            cin >> c;
            adj[u].push_back({ v, c });
        }
    }
    solve();
 
 
    return 0;
}
 
cs

 

반응형

'알고리즘 문제풀이 > 백준' 카테고리의 다른 글

[백준 2661번] 좋은수열  (0) 2021.12.16
[백준 2132번] 나무 위의 벌레  (0) 2021.12.16
[백준 1967번] 트리의 지름  (0) 2021.12.13
[백준 2331번] 반복수열  (0) 2021.12.12
[백준 16920번] 확장 게임  (0) 2021.12.08
반응형

문제 링크:https://www.acmicpc.net/problem/1967

 

1967번: 트리의 지름

파일의 첫 번째 줄은 노드의 개수 n(1 ≤ n ≤ 10,000)이다. 둘째 줄부터 n-1개의 줄에 각 간선에 대한 정보가 들어온다. 간선에 대한 정보는 세 개의 정수로 이루어져 있다. 첫 번째 정수는 간선이 연

www.acmicpc.net

<문제 풀이> DFS, BFS

N <= 10,000 이기 때문에 O(N^2)으로 문제를 해결할 수 있습니다.

모든 정점에 대해서 DFS or BFS를 돌려서 거리의 최댓값을 계속 갱신하면 됩니다.

<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
#include <iostream>
#include <string>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <utility>
#include <climits>
#include <deque>
using namespace std;
 
int n;
vector<pair<intint> > adj[10001];
int dist[10001];
int res = 0;
void bfs() {
    for (int s = 1; s <= n; s++) {
        fill(dist, dist + 10001-1);
        queue<int> Q;
        Q.push(s);
        dist[s] = 0;
        while (!Q.empty()) {
            int u = Q.front(); Q.pop();
            res = max(res, dist[u]);
            for (auto& v : adj[u]) {
                if (dist[v.first] != -1continue;
                dist[v.first] = dist[u] + v.second;
                Q.push(v.first);
            }
        }
    }
}
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
 
    cin >> n;
    for (int i = 0; i < n - 1; i++) {
        int u, v, c;
        cin >> u >> v >> c;
        adj[u].push_back({ v, c });
        adj[v].push_back({ u ,c });
    }
    bfs();
    cout << res;
    return 0;
}
 
cs
반응형

'알고리즘 문제풀이 > 백준' 카테고리의 다른 글

[백준 2132번] 나무 위의 벌레  (0) 2021.12.16
[백준 1167번] 트리의 지름  (0) 2021.12.16
[백준 2331번] 반복수열  (0) 2021.12.12
[백준 16920번] 확장 게임  (0) 2021.12.08
[백준 11967번] 불켜기  (0) 2021.12.04

+ Recent posts