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

 

1135번: 뉴스 전하기

민식이는 회사의 매니저이다. 그리고, 민식이는 회사의 중요한 뉴스를 모든 직원에게 빠르게 전달하려고 한다. 민식이의 회사는 트리 구조이다. 모든 직원은 정확하게 한 명의 직속 상사가 있다

www.acmicpc.net

 

TreeDP는 난이도도 생각보다 높고, 많이 못 풀어봤어서 그런지 어렵네요..

 

0번 직원부터 시작해서 모든 직원에게 뉴스를 전하는데 최소 시간을 구하는 문제입니다.

한 번에 한 명에게만 전파가 가능하므로 전파하는 시간이 가장 오래걸리는 직속 부하에게 먼저 전파를 해야합니다.

 

list라는 벡터에 자신의 직속 부하에게 전파하는 시간을 모두 저장한 후에 내림차순으로 정렬합니다.

먼저 전파하는 부하에게는 추가적인 시간이 필요하지 않으므로 +0,

두 번째 전파하는 부하에게는 추가적인 시간이 +1,

마지막에 전파하는 부하에게는 list.size() - 1 만큼 추가적인 시간이 추가됩니다.

이 경우들의 최댓값이 자신의 부하직원에게 소식을 전하는데 걸리는 최소 시간입니다.

 

24번째 줄 +1을 한 이유는 부하가 없는 직원에게서 오는 값은 0이기 때문에 1을 더한 것입니다.

 

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
#include <iostream>
#include <algorithm>
#include <vector>
#define MAX 50
using namespace std;
 
vector<int> graph[MAX];
int N;
 
int dfs(int v) {
    vector<int> list;
    int ret = 0;
 
    for (int i = 0; i < graph[v].size(); i++) {
        int next = graph[v][i];
 
        list.push_back(dfs(next));
    }
    sort(list.begin(), list.end(), [](int a, int b) {
        return a > b;
    });
 
    for (int i = 0; i < list.size(); i++) {
        ret = max(ret, list[i] + i + 1);
    }
 
    return ret;
}
 
void func() {
    cout << dfs(0<< '\n';
}
 
void input() {
    int x;
    cin >> N >> x;
    for (int i = 1; i < N; i++) {
        cin >> x;
        graph[x].push_back(i);
    }
}
 
int main() {
    cin.tie(NULL); cout.tie(NULL);
    ios::sync_with_stdio(false);
 
    input();
    func();
 
    return 0;
}
cs

'algorithm > dp' 카테고리의 다른 글

boj 3673 나눌 수 있는 부분 수열  (0) 2022.01.31
boj 20500 Ezreal 여눈부터 가네 ㅈㅈ  (0) 2022.01.01
boj 17090 미로 탈출하기  (0) 2021.06.27
boj 1648 격자판 채우기  (0) 2021.06.22
boj 14700 넴모넴모 (Hard)  (0) 2021.06.22

www.acmicpc.net/problem/6416

 

6416번: 트리인가?

트리는 굉장히 잘 알려진 자료 구조이다. 트리를 만족하는 자료 구조는 비어 있거나(노드의 개수가 0개), 노드의 개수가 1개 이상이고 방향 간선이 존재하며 다음과 같은 조건을 만족해야 한다.

www.acmicpc.net

자바라서 입력 받는거부터 좀 힘들었습니다..

다행히 검색으로 다음 토큰이 있는지 확인하는 st.hasMoreTokens() 라는 것을 찾아서 입력을 받았습니다.

 

이 문제는 u v 로 입력이 주어지고 이는 u->v를 뜻합니다.

트리이기 때문에 방향 그래프이고 한 방향으로만 향합니다. 즉, v->u는 안됩니다.

 

이 문제에서는 트리가 아닌 조건들을 모두 체크해주어야합니다.

1. 부모노드가 2개 이상인지

2. 루트노드가 1개가 아닌지 (0개이거나 2개 이상인지)

3. 사이클이 있는지

 

먼저 1번, 부모노드 확인입니다.

입력을 받으면서 자식으로 등록되는 노드(v)들을 Set을 이용하여 저장했고, 만약에 Set에 있는 값을 다시 넣게 된다면 자식으로 등록이 두번 됩니다. 즉 부모노드가 2개이상이 된다는 뜻입니다. => not tree

 

2번, 루트노드 확인입니다.

입력으로 주어지는 모든 부모노드(u)를 Set을 이용하여 저장했고, 만약에 Set에 있는 원소 중에 자식으로 등록되어있지 않으면 루트노드입니다.

만약 이러한 노드가 없거나 2개 이상이면 not tree입니다.

 

3번, 사이클 확인입니다.

map을 이용하여 Key는 부모노드(u), Value는 자식노드들(v)을 Integer, ArrayList<Integer>로 구현하였습니다.

사이클 확인은 dfs로 순회하여 next가 이미 방문한 노드인지 확인하였고, 이미 방문한 노드면 사이클이 있다는 말이기 때문에 not tree입니다.

 

3번의 확인이 끝나고 셋 다 아니라면 tree입니다.

 

 

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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.StringTokenizer;
 
public class Main {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st;
    static StringBuffer sb = new StringBuffer();
    static Map<Integer, ArrayList<Integer>> m = new HashMap<>();
    static Set<Integer> findRoot = new HashSet<>();
    static Set<Integer> child = new HashSet<>();
    static Set<Integer> visit = new HashSet<>();
    static boolean tworoot, twoparents, cycle;
    static int u, v, root;
 
    static void dfs(int x) {
        visit.add(x);
 
        ArrayList<Integer> graph = m.get(x);
        if (graph == null)
            return;
 
        for (int i = 0; i < graph.size(); i++) {
            int next = graph.get(i);
 
            if (visit.contains(next)) {
                cycle = true;
                return;
            }
 
            dfs(next);
            if (cycle)
                return;
        }
    }
 
    static void rootFinding() {
        Iterator<Integer> iter = findRoot.iterator();
        while (iter.hasNext()) {
            int x = iter.next();
 
            if (!child.contains(x)) {
                if (root != 0) {
                    tworoot = true;
                    return;
                }
                root = x;
            }
        }
    }
 
    static void input() throws Exception {
        st = new StringTokenizer(br.readLine());
        while (true) {
            while (!st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
 
            u = Integer.parseInt(st.nextToken());
            v = Integer.parseInt(st.nextToken());
            if (u == 0 || u == -1)
                return;
 
            if (m.containsKey(u)) {
                m.get(u).add(v);
            } else {
                ArrayList<Integer> tmp = new ArrayList<>();
                tmp.add(v);
                m.put(u, tmp);
            }
            if (child.contains(v))
                twoparents = true;
            else
                child.add(v);
 
            findRoot.add(u);
        }
    }
 
    static void clear() {
        m.clear();
        findRoot.clear();
        child.clear();
        visit.clear();
        twoparents = false;
        tworoot = false;
        cycle = false;
        root = 0;
    }
 
    public static void main(String[] args) throws Exception {
        for (int T = 1;; T++) {
            input();
            if (u == -1)
                break;
 
            sb.append("Case " + T + " is ");
            if (child.isEmpty()) {
                sb.append("a tree.\n");
                continue;
            }
            if (twoparents) {
                sb.append("not a tree.\n");
                clear();
                continue;
            }
 
            rootFinding();
            if (root == 0 || tworoot) {
                sb.append("not a tree.\n");
                clear();
                continue;
            }
 
            dfs(root);
            if (cycle)
                sb.append("not a tree.\n");
            else
                sb.append("a tree.\n");
 
            clear();
        }
 
        System.out.println(sb.toString());
    }
}
cs

'algorithm > data-structure' 카테고리의 다른 글

boj 1935 후위 표기식2  (0) 2021.02.05
boj 2493 탑  (0) 2021.02.04
boj 3190 뱀  (0) 2021.02.02
boj 2346 풍선 터뜨리기  (0) 2021.02.02
boj 5397 키로거  (0) 2021.02.02

www.acmicpc.net/problem/5639

 

5639번: 이진 검색 트리

트리를 전위 순회한 결과가 주어진다. 노드에 들어있는 키의 값은 106보다 작은 양의 정수이다. 모든 값은 한 줄에 하나씩 주어지며, 노드의 수는 10,000개 이하이다. 같은 키를 가지는 노드는 없다

www.acmicpc.net

자바로 트리를 처음 구현해보았습니다..

 

입력이 전위순회이므로 들어오는 대로 트리에 넣어줍니다.

이진 검색 트리는 x가 들어오면 트리의 루트노드의 값부터 비교를 합니다.

노드의 값보다 작으면 왼쪽 서브트리이고,

노드의 값보다 크면 오른쪽 서브트리로 이동하면 되고

 

이동하려는 서브트리가 null이면 그곳에 newnode를 삽입하면 됩니다.

출력은 후위순회로 출력입니다.

 

 

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
import java.io.BufferedReader;
import java.io.InputStreamReader;
 
public class Main {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static StringBuffer sb = new StringBuffer();
 
    static class tree {
        int x;
        tree llink;
        tree rlink;
 
        tree() {
        }
 
        tree(int x, tree llink, tree rlink) {
            this.x = x;
            this.llink = llink;
            this.rlink = rlink;
        }
    }
 
    static tree node = new tree();
 
    static void addnode(int x) {
        tree newnode = new tree(x, nullnull);
 
        if (node.x == 0) {
            node.x = x;
            return;
        }
 
        tree p = node;
 
        while (p != null) {
            if (p.x > x) {
                if (p.llink == null) {
                    p.llink = newnode;
                    break;
                } else
                    p = p.llink;
            } else {
                if (p.rlink == null) {
                    p.rlink = newnode;
                    break;
                } else
                    p = p.rlink;
            }
        }
    }
 
    static void postorder(tree t) {
        if (t.llink != null)
            postorder(t.llink);
        if (t.rlink != null)
            postorder(t.rlink);
        sb.append(t.x + "\n");
    }
 
    static void input() throws Exception {
        String st;
        while (true) {
            st = br.readLine();
            if (st == null || st.length() == 0)
                break;
 
            int x = Integer.parseInt(st);
            addnode(x);
        }
    }
 
    public static void main(String[] args) throws Exception {
        input();
        postorder(node);
        System.out.println(sb.toString());
    }
}
cs

'algorithm > data-structure' 카테고리의 다른 글

boj 17298 오큰수  (0) 2021.01.25
boj 4358 생태학  (0) 2021.01.25
boj 1991 트리 순회  (0) 2021.01.22
boj 11003 최솟값 찾기  (0) 2021.01.22
boj 1517 버블 소트  (0) 2021.01.22

+ Recent posts