10814번: 나이순 정렬

온라인 저지에 가입한 사람들의 나이와 이름이 가입한 순서대로 주어진다. 이때, 회원들을 나이가 증가하는 순으로, 나이가 같으면 먼저 가입한 사람이 앞에 오는 순서로 정렬하는 프로그램을

www.acmicpc.net

 

Language: Java

 

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
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;
 
public class Main {
 
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
 
        int N = Integer.parseInt(br.readLine());
 
        Map<Integer, ArrayList<String>> listMap = new HashMap<>();
 
        for (int i = 0; i < N; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            int age = Integer.parseInt(st.nextToken());
            String name = st.nextToken();
 
            if (!listMap.containsKey(age)) {
                listMap.put(age, new ArrayList<>());
            }
 
            listMap.get(age).add(name);
 
        }
 
        Object[] mapKeys = listMap.keySet().toArray();
        Arrays.sort(mapKeys);
 
        for (Object key : mapKeys) {
            for (String s : listMap.get(key)) {
                bw.write(key + " " + s + "\n");
            }
        }
 
        bw.flush();
        bw.close();
    }
 
}
 
 
 

🤔 해설

1. Map<Integer, ArrayList<String>> listMap = new HashMap<>();

    - Key를 나이로, Value는 이름으로 선언하되

    - Key가 중복되지 않으므로, Value를 List로 선언

    - 자료 타입: (21, {Junkyu, Dohyun})

 

2. listMap.put(age, new ArrayList<>());

    - Key값이 기존 map에 없을 경우, List 생성

 

3. listMap.get(age).add(name);

    - map에 생성된 List에 이름 추가

    - List는 입력 순서를 유지

 

4. Arrays.sort(mapKeys);

    - key값인 나이에 따라 오름차순

 

😮 찾아본 풀이

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
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Arrays;
import java.util.Comparator;
import java.util.StringTokenizer;
 
public class Main {
 
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
 
        int N = Integer.parseInt(br.readLine());
 
        String[][] sArr = new String[N][2];
 
        for (int i = 0; i < N; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            sArr[i][0= st.nextToken();
            sArr[i][1= st.nextToken();
        }
 
        Arrays.sort(sArr, new Comparator<String[]>() {
 
            @Override
            public int compare(String[] s1, String[] s2) {
                return Integer.parseInt(s1[0]) - Integer.parseInt(s2[0]);
            }
 
        });
 
        StringBuilder sb = new StringBuilder();
 
        for (int i = 0; i < N; i++) {
            sb.append(sArr[i][0+ ' ' + sArr[i][1+ '\n');
        }
        
        bw.write(sb + "");
 
        bw.flush();
        bw.close();
    }
 
}
 
 
 

1. return Integer.parseInt(s1[0]) - Integer.parseInt(s2[0]);

    - s1의 0번째 요소로 오름차순 정렬

 

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
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Arrays;
import java.util.Comparator;
import java.util.StringTokenizer;
 
public class Main {
 
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
 
        int N = Integer.parseInt(br.readLine());
 
        Participant[] pArr = new Participant[N];
 
        for (int i = 0; i < N; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine(), " ");
            int age = Integer.parseInt(st.nextToken());
            String name = st.nextToken();
 
            pArr[i] = new Participant(age, name);
        }
 
        Arrays.sort(pArr, new Comparator<>() {
 
            @Override
            public int compare(Participant p1, Participant p2) {
                return p1.age - p2.age;
            }
        });
 
        StringBuilder sb = new StringBuilder();
 
        for (int i = 0; i < N; i++) {
            sb.append(pArr[i].toString());
        }
 
        bw.write(sb + "");
 
        bw.flush();
        bw.close();
    }
 
    public static class Participant {
        int age;
        String name;
 
        public Participant(int age, String name) {
            this.age = age;
            this.name = name;
        }
 
        @Override
        public String toString() {
            return age + " " + name + "\n";
        }
 
    }
 
}
 
 
 

1. Participant[] pArr = new Participant[N];

    - Participant class 생성: 필드 - age, name

 

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
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.StringTokenizer;
 
public class Main {
 
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
 
        int N = Integer.parseInt(br.readLine());
 
        StringBuilder[] sbArr = new StringBuilder[201];
 
        for (int i = 0; i < sbArr.length; i++) {
            sbArr[i] = new StringBuilder();
        }
 
        for (int i = 0; i < N; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine(), " ");
            int age = Integer.parseInt(st.nextToken());
            String name = st.nextToken();
 
            sbArr[age].append(age + " " + name + "\n");
        }
 
        StringBuilder sb = new StringBuilder();
 
        for (StringBuilder stringBuilder : sbArr) {
            sb.append(stringBuilder);
        }
 
        bw.write(sb + "");
 
        bw.flush();
        bw.close();
    }
 
}
 
 
 

1. StringBuilder[] sbArr = new StringBuilder[201];

    - 나이만큼 StringBuilder 배열 생성

 

2. sbArr[age].append(age + " " + name + "\n");

    - 나이와 동일한 배열의 순번에 나이 및 이름 입력

 

3. for (StringBuilder stringBuilder : sbArr) {...}

    - 나이가 입력되지 않은 StringBuffer는 출력되지 않으므로 모든 sbArr 출력

 

 

 

⭐ StringBuilder()와 StringBuilder() 차이

StringBuilder()

    - 동기화 처리 방식

    - 멀티 스레드 환경에서 안전

    - 단일 스레드 환경에서는 동기화 추가 비용으로 인한 성능 저하가 발생할 수 있음

StringBuilder()

    - 비동기화 처리 방식

    - 멀티 스레드 환경에서 불안정

    - 동기화 처리를 하지 않으므로 단일 스레드 환경에서 속도가 빠름

 

 

 

🔗 소스 코드
HJ0216/TIL/BOJ

 

📚 참고 자료

 

[백준] 10814번 : 나이순 정렬 - JAVA [자바]

 

st-lab.tistory.com

 

 

1181번: 단어 정렬

첫째 줄에 단어의 개수 N이 주어진다. (1 ≤ N ≤ 20,000) 둘째 줄부터 N개의 줄에 걸쳐 알파벳 소문자로 이루어진 단어가 한 줄에 하나씩 주어진다. 주어지는 문자열의 길이는 50을 넘지 않는다.

www.acmicpc.net

 

Language: Java

 

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
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;
 
public class Main {
 
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
 
        int N = Integer.parseInt(br.readLine());
 
        Map<String, Integer> map = new HashMap<>();
 
        for (int i = 0; i < N; i++) {
            String s = br.readLine();
            map.put(s, s.length());
        }
 
        Object[] mapKeys = map.keySet().toArray();
        Arrays.sort(mapKeys);
 
        List<Object> keys = new ArrayList<>();
        for (Object key : mapKeys) {
            keys.add(key);
        }
        Collections.sort(keys, ((k1, k2) -> (map.get(k1).compareTo(map.get(k2)))));
 
        for (Object key : keys) {
            bw.write(key + "\n");
        }
 
        bw.flush();
        bw.close();
    }
 
}
 
 
 

🤔 해설

1. Map<String, Integer> map = new HashMap<>();

    - Key: 이름, Value: 이름 길이

 

2. Arrays.sort(mapKeys);

    - 이름 길이에 따라 정렬 전에 이름(key)을 기준으로 정렬 수행

    - toArray(): 기본 return type이 Object[]

    - String 배열 선언 방법: String[] mapKeys =  map.keySet().toArray(new String[0]);

      ⭐ String[] mapKeys =  (String[]) map.keySet().toArray(); 시, ClassCastException 발생

        - [해결 방법] java.lang.ClassCastException

 

3. List<Object> keys = new ArrayList<>();

    - Collections.sort를 사용하기 위해, keys에 해당하는 List 선언

 

4. Collections.sort(keys, ((k1, k2) -> (map.get(k1).compareTo(map.get(k2)))));

    - value(map.get())에 따른 오름차순으로 정렬

    - 내림차순 정렬: map.get(k2).compareTo(map.get(k1))

    - 오름차순 정렬: map.get(k1).compareTo(map.get(k2))

    - A.compareTo(B)

        - -1: A < B ▶ A(앞)가 B(뒤)의 뒤에 위치

        - 0: A == B ▶위치 변화 X

        - 1: A > B ▶ A(앞)가 B(뒤)의 앞에 위치

 

5. map 자료형은 중복을 허용하지 않으므로, 중복 조건은 따로 신경쓰지 않아도 됨

 

😮 찾아본 풀이

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
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Arrays;
import java.util.Comparator;
 
public class Main {
 
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        int N = Integer.parseInt(br.readLine());
 
        String[] sArr = new String[N];
 
        for (int i = 0; i < N; i++) {
            sArr[i] = br.readLine();
        }
 
        Arrays.sort(sArr, new Comparator<String>() {
 
            public int compare(String s1, String s2) {
                if (s1.length() == s2.length()) {
                    return s1.compareTo(s2);
                } else {
                    return s1.length() - s2.length();
                }
            }
 
        });
 
        StringBuffer sb = new StringBuffer();
 
        sb.append(sArr[0+ "\n");
 
        for (int i = 1; i < N; i++) {
            if (!sArr[i].equals(sArr[i - 1])) {
                sb.append(sArr[i] + "\n");
            }
        }
 
        bw.write(sb + "");
 
        bw.flush();
        bw.close();
    }
 
}
 
 
 

1. Arrays.sort(sArr, new Comparator<String>() {...}

    - 입력값을 String 배열로 저장해서 정렬

 

2. public int compare(String s1, String s2) {...}

    - 길이가 같을 경우, 오름차순 정렬(사전식 정렬)

    - 길이가 다를 경우, 길이가 짧은 문자열부터 정렬

  ▶ Arrays.sort() 결과는 단어의 길이가 짧은 순서 + 단어의 길이가 같은 경우에는 사전순으로 출력됨

 

3. if (!sArr[i].equals(sArr[i - 1])) {...}

    - 중복 제거

 

 

 

🔗 소스 코드
HJ0216/TIL/BOJ

 

📚 참고 자료

 

[백준] 1181번 : 단어 정렬 - JAVA [자바]

www.acmicpc.net/problem/1181 1181번: 단어 정렬 첫째 줄에 단어의 개수 N이 주어진다. (1≤N≤20,000) 둘째 줄부터 N개의 줄에 걸쳐 알파벳 소문자로 이루어진 단어가 한 줄에 하나씩 주어진다. 주어지는 문

st-lab.tistory.com

 

 

1018번: 체스판 다시 칠하기

첫째 줄에 N과 M이 주어진다. N과 M은 8보다 크거나 같고, 50보다 작거나 같은 자연수이다. 둘째 줄부터 N개의 줄에는 보드의 각 행의 상태가 주어진다. B는 검은색이며, W는 흰색이다.

www.acmicpc.net

 

Language: Java

 

🚨 3일을 고민해도 풀 수 없어 풀이를 열심히 찾아봄

 

😮 찾아본 풀이

 
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
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.StringTokenizer;
 
public class Main {
 
    public static boolean[][] arr;
    public static int min = 64;
 
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
 
        StringTokenizer st = new StringTokenizer(br.readLine(), " ");
 
        int ROW = Integer.parseInt(st.nextToken());
        int COL = Integer.parseInt(st.nextToken());
 
        arr = new boolean[ROW][COL];
 
        for (int i = 0; i < ROW; i++) {
            String s = br.readLine();
            
            for (int j = 0; j < COL; j++) {
                if (s.charAt(j) == 'W') {
                    arr[i][j] = true;
                }
            }
        }
 
        for (int i = 0; i < ROW - 7; i++) {
            for (int j = 0; j < COL - 7; j++) {
                check(i, j);
            }
        }
 
        bw.write(min + "");
 
        bw.flush();
        bw.close();
    }
 
    public static void check(int x, int y) {
        int cnt = 0;
        
        boolean value = arr[x][y];
 
        for (int i = x; i < x + 8; i++) {
            for (int j = y; j < y + 8; j++) {
                if (arr[i][j] != value) {
                    cnt++;
                }
                value = (!value);
            }
            value = (!value);
        }
 
        cnt = Math.min(cnt, 64 - cnt);
 
        min = Math.min(min, cnt);
    }
}
 
 
 

1. boolean[][] arr

    - boolean 타입 이중 배열을 전역으로 설정하여, main()과 check()에서 공유하여 사용

 

2. arr = new boolean[ROW][COL]

    - 입력된 행렬의 크기에 맞춰 이중 배열 선언

 

3. if (s.charAt(j) == 'W') {arr[i][j] = true;}

    - 'W'일 경우, true 입력

    - boolean 배열의 기본값은 false이므로 B일 경우 false 처리는 생략

 

4. check()

    - 행렬의 범위를 i < x + 8, j < y + 8로 설정하여 반복문 실행: 0~7, 1~8, 2~9, ... 탐색

    - 체스판 크기 8 * 8에 맞춰 check() 호출

 

5. boolean value = arr[x][y]

    - 체스판의 시작값을 기준값으로 설정하는 변수 value 선언

 

6. if (arr[i][j] != value) {cnt++;}

    - 체스판과 다른 패턴일 경우, cnt 변수 1 증가

 

7. value = (!value)

    - 바둑판 무늬이므로 1번 사용 시마다 TF 변경

    - 행이 변경될 경우, TF가 변경되므로 inner for문이 종료될 경우도 TF 변환

 

8. cnt = Math.min(cnt, 64 - cnt)

    - 체스판 시작(arr[x][y])이 B인 경우에는 W기준으로, W인 경우에는 B를 기준으로 변경을 가장 적게하는 방법 탐색

 

9. int min = 64

    - int 타입 변수 min을 전역으로 설정하여, main()과 check()에서 공유하여 사용

 

10. min = Math.min(min, cnt)

    - 체스판 크기인 8*8에 맞춰 0~7, 1~8, ...을 탐색하므로 check() 호출 시마다 가장 변경이 적은 min값 갱신

 

 

 

🔗 소스 코드
HJ0216/TIL/BOJ

 

📚 참고 자료

 

[백준] 1018번 : 체스판 다시 칠하기 - JAVA [자바]

www.acmicpc.net/problem/1018 1018번: 체스판 다시 칠하기 첫째 줄에 N과 M이 주어진다. N과 M은 8보다 크거나 같고, 50보다 작거나 같은 자연수이다. 둘째 줄부터 N개의 줄에는 보드의 각 행의 상태가 주어

st-lab.tistory.com

 

 

10816번: 숫자 카드 2

첫째 줄에 상근이가 가지고 있는 숫자 카드의 개수 N(1 ≤ N ≤ 500,000)이 주어진다. 둘째 줄에는 숫자 카드에 적혀있는 정수가 주어진다. 숫자 카드에 적혀있는 수는 -10,000,000보다 크거나 같고, 10,0

www.acmicpc.net

 

Language: Java

 

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
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.StringTokenizer;
 
public class Main {
 
    public static int[] iArr;
 
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
 
        int N = Integer.parseInt(br.readLine());
 
        iArr = new int[N];
        StringTokenizer st1 = new StringTokenizer(br.readLine());
        for (int i = 0; i < N; i++) {
            iArr[i] = Integer.parseInt(st1.nextToken());
        }
 
        int M = Integer.parseInt(br.readLine());
 
        StringTokenizer st2 = new StringTokenizer(br.readLine());
        for (int i = 0; i < M; i++) {
            bw.write(check(Integer.parseInt(st2.nextToken())) + " ");
        }
 
        bw.flush();
        bw.close();
    }
 
    public static int check(int num) {
        int cnt = 0;
 
        for (int i = 0; i < iArr.length; i++) {
            if (iArr[i] == num) {
                cnt++;
            }
        }
 
        return cnt;
 
    }
}
 
 
 

🚨 이중 for문에 의해서 시간복잡도가 n^2까지 커질 수 있어 시간 초과

- int[]

    - 정적 변수로 선언해서 main()과 check()이 공유

    - 초기값이 0이므로 따로 기본값 설정 X

 

😮 찾아본 풀이

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
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.HashMap;
import java.util.Map;
import java.util.StringTokenizer;
 
public class Main {
 
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
 
        int N = Integer.parseInt(br.readLine());
 
        Map<Integer, Integer> map = new HashMap<>();
        StringTokenizer st = new StringTokenizer(br.readLine(), " ");
        for (int i = 0; i < N; i++) {
            int key = Integer.parseInt(st.nextToken());
 
            map.put(key, map.getOrDefault(key, 0+ 1);
        }
 
        int M = Integer.parseInt(br.readLine());
 
        st = new StringTokenizer(br.readLine());
        for (int i = 0; i < M; i++) {
            int key = Integer.parseInt(st.nextToken());
 
            bw.write(map.getOrDefault(key, 0+ " ");
        }
 
        bw.flush();
        bw.close();
    }
 
}
 
 
 

1. HashMap

    - 시간복잡도가 1로 검색 속도가 빠름

    - getOrDefault(): value값을 찾거나 초기값 선언

       map은 key값이 중복되지 않음

        - key값이 없을 경우, 0 입력

        - key값이 있을 경우, get(key) + 1

2. getOrDefault()

    - 입력값마다 value 검색 후, 없을 경우 초기값을 0으로 설정

  ⭐ 1개의 map에는 상근이가 갖고 있는 카드 및 상근이가 갖고 있는지 확인 할 카드가 함께 저장되어 있음

 

 

 

🔗 소스 코드
HJ0216/TIL/BOJ

 

📚 참고 자료

 

[백준] 10816번 : 숫자 카드 2 - JAVA [자바]

https://www.acmicpc.net/problem/10816 10816번: 숫자 카드 2 첫째 줄에 상근이가 가지고 있는 숫자 카드의 개수 N(1 ≤ N ≤ 500,000)이 주어진다. 둘째 줄에는 숫자 카드에 적혀있는 정수가 주어진다. 숫자 카드

st-lab.tistory.com

 

 

7785번: 회사에 있는 사람

첫째 줄에 로그에 기록된 출입 기록의 수 n이 주어진다. (2 ≤ n ≤ 106) 다음 n개의 줄에는 출입 기록이 순서대로 주어지며, 각 사람의 이름이 주어지고 "enter"나 "leave"가 주어진다. "enter"인 경우는

www.acmicpc.net

 

Language: Java

 

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
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;
 
public class Main {
 
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
 
        int num = Integer.parseInt(br.readLine());
 
        Map<StringString> map = new HashMap<>();
        for (int i = 0; i < num; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            String name = st.nextToken();
            String status = st.nextToken();
 
            if (!map.containsKey(name)) {
                map.put(name, status);
            } else {
                map.remove(name);
            }
        }
 
        List<String> keyList = new ArrayList<>(map.keySet());
        keyList.sort((s1, s2) -> s2.compareTo(s1));
 
        for (String s : keyList) {
            bw.write(s + "\n");
        }
 
        bw.flush();
        bw.close();
    }
 
}
 
 
 

🤔 해설

1. map

    - key: name, value: status(enter or leave)

    - if 조건문

        - 회사에 동명이인은 없는 것으로 전제, 만일 동일한 이름이 입력되면 map에서 제거

 

2. keyList

    - 퇴근하지 않은 사람의 이름을 출력하기 위해 keySet으로만 구성된 List 선언

    - sort((s1, s2) -> s2.compareTo(s1)): 내림차순 정렬

 

😮 이 외의 풀이

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
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;
 
public class Main {
 
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        int num = Integer.parseInt(br.readLine());
        Map<StringString> map = new HashMap<>();
        for (int i = 0; i < num; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            String name = st.nextToken();
            String status = st.nextToken();
            if (!map.containsKey(name)) {
                map.put(name, status);
            } else {
                map.remove(name);
            }
        }
        List<String> keyList = new ArrayList<>(map.keySet());
 
        Collections.sort(keyList, Collections.reverseOrder());
 
        for (String s : keyList) {
            bw.write(s + "\n");
        }
 
        bw.flush();
        bw.close();
    }
 
}
 
 
 

- 정렬: Collections.sort() + Collections.reverseOrder() 사용

 

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
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
 
public class Main {
 
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        int N = Integer.parseInt(br.readLine());
 
        Set<String> set = new HashSet<>();
 
        for (int i = 0; i < N; i++) {
            String[] input = br.readLine().split(" ");
            String name = input[0];
            String status = input[1];
 
            if (set.contains(name)) {
                set.remove(name);
            } else {
                set.add(name);
            }
 
        }
 
        List<String> list = new ArrayList<>();
        Iterator<String> it = set.iterator();
 
        while (it.hasNext()) {
            list.add(it.next());
        }
 
        Collections.sort(list, Collections.reverseOrder());
 
        for (String name : list) {
            bw.write(name + "\n");
        }
 
        bw.flush();
        bw.close();
    }
 
}
 
 
 

- HashSet

   - 같은 이름이 없을 경우에는 set에 추가하고, 있을 경우에는 set에서 제거

- List

    - Collections.sort 대상은 list만 가능하므로 Iterator를 통해서 set 요소를 list에 저장

- Iterator

    - it.hasNext(): 현재 반복자가 다음 요소가 있는지 여부를 확인

    - it.next(): 현재 반복자가 가리키고 있는 요소를 반환하고, 반복자를 다음 요소로 이동

 

 

 

🔗 소스 코드
HJ0216/TIL/BOJ

 

📚 참고 자료

 

[백준 7785번] 회사에 있는 사람 (java)

7785번: 회사에 있는 사람 첫째 줄에 로그에 기록된 출입 기록의 수 n이 주어진다. (2 ≤ n ≤ 106) 다음 n개의 줄에는 출입 기록이 순서대로 주어지며, 각 사람의 이름이 주어지고 "enter"나 "leave"가 주

lotuslee.tistory.com