www.acmicpc.net/problem/2606

 

2606번: 바이러스

첫째 줄에는 컴퓨터의 수가 주어진다. 컴퓨터의 수는 100 이하이고 각 컴퓨터에는 1번 부터 차례대로 번호가 매겨진다. 둘째 줄에는 네트워크 상에서 직접 연결되어 있는 컴퓨터 쌍의 수가 주어

www.acmicpc.net

처음에 1번 컴퓨터가 바이러스에 걸리고 이 컴퓨터로 인해 바이러스에 걸리는 컴퓨터가 몇 대인지 출력하는 문제입니다.

 

이 문제는 간단한 bfs로 해결할 수 있습니다.

입력으로 u와 v가 주어지면 둘이 연결되어있다는 말입니다.

이 그래프는 양방향 그래프이기 때문에 u의 간선에도 v를 추가하고, v의 간선에도 u를 추가해야합니다.

 

그 다음 1번부터 시작하여 bfs로 연결되어있는 컴퓨터 수를 구하시면 됩니다.

 

 

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.InputStreamReader;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;
 
public class Main {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st;
    static ArrayList<Integer> list[];
    static boolean visit[];
    static int N, M, ans;
 
    static void bfs() {
        Queue<Integer> q = new LinkedList<>();
        q.add(1);
        visit[1= true;
        while (!q.isEmpty()) {
            int v = q.peek();
 
            q.remove();
 
            for (int i = 0; i < list[v].size(); i++) {
                int next = list[v].get(i);
 
                if (visit[next])
                    continue;
 
                q.add(next);
                visit[next] = true;
                ans++;
            }
        }
    }
 
    static void input() throws Exception {
        int u, v;
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        list = new ArrayList[N + 1];
        visit = new boolean[N + 1];
        for (int i = 1; i <= N; i++) {
            list[i] = new ArrayList<>();
        }
 
        st = new StringTokenizer(br.readLine());
        M = Integer.parseInt(st.nextToken());
 
        while (M-- > 0) {
            st = new StringTokenizer(br.readLine());
            u = Integer.parseInt(st.nextToken());
            v = Integer.parseInt(st.nextToken());
 
            list[u].add(v);
            list[v].add(u);
        }
    }
 
    public static void main(String[] args) throws Exception {
        input();
        bfs();
        System.out.println(ans);
    }
}
cs

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

boj 14502 연구소  (0) 2021.02.12
boj 20304 비밀번호 제작  (0) 2021.02.08
boj 1012 유기농 배추  (0) 2021.02.03
boj 16956 늑대와 양  (0) 2021.02.03
boj 20419 화살표 미로 (Easy)  (0) 2021.01.23

www.acmicpc.net/problem/1012

 

1012번: 유기농 배추

차세대 영농인 한나는 강원도 고랭지에서 유기농 배추를 재배하기로 하였다. 농약을 쓰지 않고 배추를 재배하려면 배추를 해충으로부터 보호하는 것이 중요하기 때문에, 한나는 해충 방지에 

www.acmicpc.net

배추영역 하나에 지렁이 한마리가 들어가고 최종적으로 배추밭에 필요한 지렁이의 수를 구하는 문제이며

탐색을 통해 배추영역의 갯수를 구하는 문제입니다.

 

저는 bfs를 사용했습니다.

입력으로 배추의 위치가 X, Y로 주어지면 list[X][Y] = 1로 표시합니다.

모든 입력을 다 받고 2중 for문을 돌려서 해당 칸이 1이면서 아직 방문하지 않은 위치면 그 위치를 시작으로 bfs를 돌립니다.

 

bfs로 현재 위치에서 주변에 1이 있는 좌표들을 큐에 넣고 중복체크를 해줍니다.

bfs 탐색이 종료되면 한 구역 탐색이 끝난 것이므로 ans를 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
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
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;
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 boolean visit[][];
    static int direct[][] = { { 01 }, { 10 }, { 0-1 }, { -10 } };
    static int list[][];
    static int N, M, K, ans;
 
    static void print() {
        sb.append(ans + "\n");
        ans = 0;
    }
 
    static void bfs(int sx, int sy) {
        Queue<int[]> q = new LinkedList<>();
        q.add(new int[] { sx, sy });
        visit[sx][sy] = true;
        while (!q.isEmpty()) {
            int x = q.peek()[0];
            int y = q.peek()[1];
 
            q.remove();
 
            for (int i = 0; i < 4; i++) {
                int nx = x + direct[i][0];
                int ny = y + direct[i][1];
 
                if (nx < 0 || ny < 0 || nx >= N || ny >= M)
                    continue;
                if (visit[nx][ny] || list[nx][ny] == 0)
                    continue;
 
                q.add(new int[] { nx, ny });
                visit[nx][ny] = true;
            }
        }
    }
 
    static void func() {
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                if (list[i][j] == 1) {
                    if (visit[i][j])
                        continue;
 
                    bfs(i, j);
                    ans++;
                }
            }
        }
    }
 
    static void input() throws Exception {
        int u, v;
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        K = Integer.parseInt(st.nextToken());
        list = new int[N][M];
        visit = new boolean[N][M];
 
        while (K-- > 0) {
            st = new StringTokenizer(br.readLine());
            u = Integer.parseInt(st.nextToken());
            v = Integer.parseInt(st.nextToken());
 
            list[u][v] = 1;
        }
    }
 
    public static void main(String[] args) throws Exception {
        st = new StringTokenizer(br.readLine());
        int tc = Integer.parseInt(st.nextToken());
        while (tc-- > 0) {
            input();
            func();
            print();
        }
        
        System.out.println(sb.toString());
    }
}
cs

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

boj 20304 비밀번호 제작  (0) 2021.02.08
boj 2606 바이러스  (0) 2021.02.03
boj 16956 늑대와 양  (0) 2021.02.03
boj 20419 화살표 미로 (Easy)  (0) 2021.01.23
boj 2638 치즈  (0) 2021.01.22

www.acmicpc.net/problem/16956

 

16956번: 늑대와 양

크기가 R×C인 목장이 있고, 목장은 1×1 크기의 칸으로 나누어져 있다. 각각의 칸에는 비어있거나, 양 또는 늑대가 있다. 양은 이동하지 않고 위치를 지키고 있고, 늑대는 인접한 칸을 자유롭게

www.acmicpc.net

 

문제 분류는 bfs로 되어있지만 bfs를 사용하지 않아도 해결 가능한 문제입니다.

저는 bfs방식으로 양의 위치를 큐에 담아서 하나씩 꺼내 확인하는 방법과

2중 for문을 이용해서 양의 위치에서 확인하는 방법으로 2가지로 해결해 보았습니다.

 

두 방법 모두 양의 위치에서 상, 하, 좌, 우 방향에 늑대가 있는지 확인합니다.

늑대가 있으면 0출력후 리턴, 없으면 놓을 수 있는 모든 방향에 울타리를 설치합니다.

 

문제가 스페셜저지이기 때문에 예제와 답이 다르게 나와도 늑대가 양이 있는 칸으로 갈수없다면 정답으로 할 수 있습니다. (물론 첫째줄에 출력하는 0과 1은 맞아야합니다.)

 

[bfs 방식을 통한 탐색]

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
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;
 
public class Main {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st;
    static Queue<int[]> q = new LinkedList<>();
    static int direct[][] = { { 01 }, { 10 }, { 0-1 }, { -10 } };
    static boolean chk;
    static char list[][];
    static int N, M;
 
    static void print() {
        if (chk) {
            System.out.println(0);
            return;
        }
 
        StringBuffer sb = new StringBuffer();
        sb.append("1\n");
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                sb.append(list[i][j]);
            }
            sb.append("\n");
        }
 
        System.out.println(sb.toString());
    }
 
    static void func() {
        while (!q.isEmpty()) {
            int x = q.peek()[0];
            int y = q.peek()[1];
            q.remove();
 
            for (int i = 0; i < 4; i++) {
                int nx = x + direct[i][0];
                int ny = y + direct[i][1];
 
                if (nx < 0 || ny < 0 || nx >= N || ny >= M)
                    continue;
                if (list[nx][ny] == 'S' || list[nx][ny] == 'D')
                    continue;
                if (list[nx][ny] == 'W') {
                    chk = true;
                    break;
                }
 
                list[nx][ny] = 'D';
            }
 
            if (chk)
                break;
        }
    }
 
    static void input() throws Exception {
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        list = new char[N][M];
 
        for (int i = 0; i < N; i++) {
            st = new StringTokenizer(br.readLine());
            list[i] = st.nextToken().toCharArray();
            for (int j = 0; j < M; j++) {
                if (list[i][j] == 'S') {
                    q.add(new int[] { i, j });
                }
            }
        }
    }
 
    public static void main(String[] args) throws Exception {
        input();
        func();
        print();
    }
}
cs

 

[2중 for문을 통한 탐색]

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
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
 
public class Main {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st;
    static int direct[][] = { { 01 }, { 10 }, { 0-1 }, { -10 } };
    static char list[][];
    static int N, M;
    static boolean chk;
 
    static void print() {
        if (chk) {
            System.out.println(0);
            return;
        }
 
        StringBuffer sb = new StringBuffer();
        sb.append("1\n");
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                sb.append(list[i][j]);
            }
            sb.append("\n");
        }
 
        System.out.println(sb.toString());
    }
 
    static void func() {
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                if (list[i][j] == 'S') {
                    for (int k = 0; k < 4; k++) {
                        int nx = i + direct[k][0];
                        int ny = j + direct[k][1];
 
                        if (nx < 0 || ny < 0 || nx >= N || ny >= M)
                            continue;
                        if (list[nx][ny] == 'S' || list[nx][ny] == 'D')
                            continue;
                        if (list[nx][ny] == 'W') {
                            chk = true;
                            return;
                        }
 
                        list[nx][ny] = 'D';
                    }
                }
            }
        }
    }
 
    static void input() throws Exception {
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        list = new char[N][M];
 
        for (int i = 0; i < N; i++) {
            st = new StringTokenizer(br.readLine());
            list[i] = st.nextToken().toCharArray();
        }
    }
 
    public static void main(String[] args) throws Exception {
        input();
        func();
        print();
    }
}
cs

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

boj 2606 바이러스  (0) 2021.02.03
boj 1012 유기농 배추  (0) 2021.02.03
boj 20419 화살표 미로 (Easy)  (0) 2021.01.23
boj 2638 치즈  (0) 2021.01.22
boj 17142 연구소 3  (0) 2021.01.22

www.acmicpc.net/problem/3190

 

3190번: 뱀

 'Dummy' 라는 도스게임이 있다. 이 게임에는 뱀이 나와서 기어다니는데, 사과를 먹으면 뱀 길이가 늘어난다. 뱀이 이리저리 기어다니다가 벽 또는 자기자신의 몸과 부딪히면 게임이 끝난다. 게임

www.acmicpc.net

입력으로 보드의 크기와 사과의 갯수, 좌표, 방향 회전 정보가 주어집니다.

여기서 좌표는 (1, 1) ~ (N, N)으로 주어지기 때문에 주어지는 크기에 맞게 접근을 해야합니다.

(그거때문에 런타임에러가 떴었습니다... 문제좀 제대로 읽어봐야하는데..)

 

저는 뱀의 위치를 덱으로 구현하여 덱의 맨 앞에는 뱀의 머리, 맨 뒤에는 뱀의 꼬리로 두었습니다.

그리고 뱀의 방향전환 정보가 최대 10000개라서 char배열을 이용하여 하였습니다.

 

뱀을 움직일 때는

1. 뱀이 움직인다. (움직인 곳으로 push)

2. 다음 칸이 사과면 꼬리가 위치한 칸을 그대로 둔다. (길이 +1)

3. 다음 칸이 사과가 아닌 빈칸이면 꼬리가 위치한 칸을 비운다. (길이 그대로)

4. 뱀을 움직이고 해당 시간에 회전명령이 있으면 회전한다.

5. 다음 칸이 뱀이 있는 위치이거나 맵 밖이면 게임이 끝난다. (T 출력)

위의 규칙대로 움직여주시면 됩니다.

 

 

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
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.StringTokenizer;
 
public class Main {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st;
    static char ch[] = new char[10001];
    static int direct[][] = { { 01 }, { 10 }, { 0-1 }, { -10 } };
    static int list[][];
    static Deque<int[]> dq = new ArrayDeque<>();
    static int N, K, L;
 
    static void func() {
        int idx = 0;
        dq.addLast(new int[] { 11 });
        list[1][1= 1;
        for (int T = 1;; T++) {
            int x = dq.peekFirst()[0];
            int y = dq.peekFirst()[1];
 
            int nx = x + direct[idx][0];
            int ny = y + direct[idx][1];
            if (nx <= 0 || ny <= 0 || nx > N || ny > N) {
                System.out.println(T);
                return;
            }
 
            if (list[nx][ny] == 2) {
                dq.addFirst(new int[] { nx, ny });
            } else if (list[nx][ny] == 0) {
                dq.addFirst(new int[] { nx, ny });
                list[dq.peekLast()[0]][dq.peekLast()[1]] = 0;
                dq.removeLast();
            } else {
                System.out.println(T);
                return;
            }
 
            if (ch[T] == 'L')
                idx = (idx + 3) % 4;
            else if (ch[T] == 'D')
                idx = (idx + 1) % 4;
 
            list[nx][ny] = 1;
        }
    }
 
    static void input() throws Exception {
        int x, y;
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        list = new int[N + 1][N + 1];
 
        st = new StringTokenizer(br.readLine());
        K = Integer.parseInt(st.nextToken());
        while (K-- > 0) {
            st = new StringTokenizer(br.readLine());
            x = Integer.parseInt(st.nextToken());
            y = Integer.parseInt(st.nextToken());
 
            list[x][y] = 2;
        }
 
        st = new StringTokenizer(br.readLine());
        L = Integer.parseInt(st.nextToken());
        while (L-- > 0) {
            st = new StringTokenizer(br.readLine());
            x = Integer.parseInt(st.nextToken());
            char c = st.nextToken().charAt(0);
            ch[x] = c;
        }
    }
 
    public static void main(String[] args) throws Exception {
        input();
        func();
    }
}
cs

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

boj 2493 탑  (0) 2021.02.04
boj 6416 트리인가?  (0) 2021.02.04
boj 2346 풍선 터뜨리기  (0) 2021.02.02
boj 5397 키로거  (0) 2021.02.02
boj 10866 덱  (0) 2021.02.02

www.acmicpc.net/problem/9202

 

9202번: Boggle

각각의 Boggle에 대해, 얻을 수 있는 최대 점수, 가장 긴 단어, 찾은 단어의 개수를 출력한다. 한 Boggle에서 같은 단어를 여러 번 찾은 경우에는 한 번만 찾은 것으로 센다. 가장 긴 단어가 여러 개

www.acmicpc.net

먼저 사전에 들어갈 N개의 단어가 주어지고, 4*4크기의 그리드가 주어집니다.

이 그리드에서 가로, 세로, 대각선으로 인접한 글자로 사전의 단어를 몇 개 만들 수 있는지 찾는 문제입니다.

출력해야 할 것은 게임에서 얻을 수 있는 최대 점수, 찾은 단어 중 가장 긴 단어, 찾은 단어의 갯수 입니다.

 

저는 사전의 단어를 dfs로 하나씩 확인하였습니다.

(1,1) -> (1,2) -> (1,1)와 같은 중복방문이 없어야하므로 visit를 이용해 방문체크를 하였고,

한 인덱스에서 단어찾기에 실패하면 그 인덱스의 방문처리는 false로 하여 재방문 할 수 있게 하였습니다.

 

단어 찾는데 성공하면 가장 긴 단어를 최신화하고, 단어 길이에 맞는 점수 증가와 단어 갯수를 1 증가시킵니다.

그리고 같은 단어를 여러번 찾을 필요가 없으므로 찾았다는 표시로 chk = true를 해서 다음 단어로 바로 넘어갑니다.

 

가장 긴 단어를 출력할 때는 길이가 긴 것, 길이가 같으면 사전 순으로 앞서는 것을 출력합니다.

 

 

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
import java.io.BufferedReader;
import java.io.InputStreamReader;
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 int direct[][] = { { 01 }, { 11 }, { 10 }, { 1-1 }, { 0-1 }, { -1-1 }, { -10 }, { -11 } };
    static int score[] = { 0001123511 };
    static String dict[];
    static char list[][];
    static boolean visit[][], chk;
    static String maxlength = "";
    static int N, M, maxscore, ans;
 
    static void dfs(int k, int idx, int x, int y) {
        if (idx + 1 == dict[k].length()) {
            if (maxlength == "")
                maxlength = dict[k];
            else {
                if (maxlength.length() < dict[k].length())
                    maxlength = dict[k];
                else if (maxlength.length() == dict[k].length()) {
                    if (maxlength.compareTo(dict[k]) > 0)
                        maxlength = dict[k];
                }
            }
 
            maxscore += score[idx + 1];
            chk = true;
            return;
        }
 
        visit[x][y] = true;
 
        for (int i = 0; i < 8; i++) {
            int nx = x + direct[i][0];
            int ny = y + direct[i][1];
 
            if (nx < 0 || ny < 0 || nx >= 4 || ny >= 4)
                continue;
            if (visit[nx][ny] || list[nx][ny] != dict[k].charAt(idx + 1))
                continue;
 
            dfs(k, idx + 1, nx, ny);
            if (chk)
                return;
 
            visit[nx][ny] = false;
        }
    }
 
    static void func() {
        for (int k = 0; k < N; k++) {
            chk = false;
            for (int i = 0; i < 4; i++) {
                for (int j = 0; j < 4; j++) {
                    if (list[i][j] == dict[k].charAt(0)) {
                        visit = new boolean[4][4];
                        dfs(k, 0, i, j);
                        if (chk) {
                            ans++;
                            break;
                        }
                    }
                }
 
                if (chk)
                    break;
            }
        }
    }
 
    static void input() throws Exception {
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        dict = new String[N];
        list = new char[4][4];
 
        for (int i = 0; i < N; i++) {
            dict[i] = br.readLine();
        }
        br.readLine();
 
        st = new StringTokenizer(br.readLine());
        M = Integer.parseInt(st.nextToken());
        for (int i = 0; i < M; i++) {
            for (int j = 0; j < 4; j++) {
                st = new StringTokenizer(br.readLine());
                list[j] = st.nextToken().toCharArray();
            }
 
            func();
            sb.append(maxscore + " " + maxlength + " " + ans + "\n");
            maxscore = 0;
            maxlength = "";
            ans = 0;
 
            if (i == M - 1)
                break;
            br.readLine();
        }
    }
 
    public static void main(String[] args) throws Exception {
        input();
        System.out.println(sb.toString());
    }
}
cs

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

boj 16926 배열 돌리기 1  (0) 2021.02.10
boj 1068 트리  (0) 2021.02.09
boj 15666 N과 M (12)  (0) 2021.01.31
boj 15665 N과 M (11)  (0) 2021.01.30
boj 15664 N과 M (10)  (0) 2021.01.30

www.acmicpc.net/problem/2346

 

2346번: 풍선 터뜨리기

첫째 줄에 자연수 N(1≤N≤1,000)이 주어진다. 다음 줄에는 차례로 각 풍선 안의 종이에 적혀 있는 수가 주어진다. 편의상 0은 적혀있지 않다고 가정하자.

www.acmicpc.net

list의 첫번째 풍선을 터뜨리고 안에 적혀있는 수에 맞게 이동하여 다음 풍선을 터뜨리고, 최종적으로 풍선을 터뜨리는 순서를 구하는 문제입니다.

 

저는 덱을 이용하였습니다. 풍선을 터뜨릴 위치는 무조건 덱의 맨 앞입니다.

그러면 다음 위치를 찾아서 맨 앞으로 가져다 놓아야합니다.

 

풍선에 적혀있는 수가 양수면 오른쪽으로 이동하는 것인데

덱의 맨 앞의 숫자를 맨 뒤로 보내는 것으로 해결할 수 있습니다.

하지만 양수가 적혀있는 풍선을 터뜨리면 이미 한칸은 오른쪽으로 이동한 것이기 때문에 숫자-1만큼만 이동시킵니다.

 

풍선에 적혀있는 수가 음수면 왼쪽으로 이동합니다.

덱의 맨 뒤의 숫자를 맨 앞으로 보내는 것으로 해결할 수 있습니다.

 

마지막 풍선까지 터뜨리고 덱이 비어있으면 break를 해주고 답을 출력합니다.

 

 

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
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.Deque;
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 Deque<int[]> dq = new ArrayDeque<>();
    static int N;
 
    static void func() {
        for (int i = 0; i < N; i++) {
            int next = dq.peekFirst()[0];
            sb.append(dq.peekFirst()[1+ " ");
            dq.removeFirst();
 
            if (dq.isEmpty())
                break;
            
            if (next > 0) {
                next--;
                while (next-- > 0) {
                    dq.addLast(dq.peekFirst());
                    dq.removeFirst();
                }
            } else {
                while (next++ < 0) {
                    dq.addFirst(dq.peekLast());
                    dq.removeLast();
                }
            }
        }
 
        System.out.println(sb.toString());
    }
 
    static void input() throws Exception {
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
 
        st = new StringTokenizer(br.readLine());
        for (int i = 1; i <= N; i++) {
            dq.addLast(new int[] { Integer.parseInt(st.nextToken()), i });
        }
    }
 
    public static void main(String[] args) throws Exception {
        input();
        func();
    }
}
cs

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

boj 6416 트리인가?  (0) 2021.02.04
boj 3190 뱀  (0) 2021.02.02
boj 5397 키로거  (0) 2021.02.02
boj 10866 덱  (0) 2021.02.02
boj 11000 강의실 배정  (0) 2021.02.01

www.acmicpc.net/problem/5397

 

5397번: 키로거

첫째 줄에 테스트 케이스의 개수가 주어진다. 각 테스트 케이스는 한줄로 이루어져 있고, 강산이가 입력한 순서대로 길이가 L인 문자열이 주어진다. (1 ≤ L의 길이 ≤ 1,000,000) 강산이가 백스페이

www.acmicpc.net

두 개의 덱을 이용하여 해결할 수 있습니다.

덱을 두 개 사용한 이유는 커서의 위치를 조정해주기 위함입니다.

저는 커서 좌, 우를 나누는 left와 right 덱을 선언하여 커서는 무조건 left를 가리키게 유지하였습니다.

 

우선 입력으로 '<', '>', '-' 그리고 나머지 문자가 주어집니다.

 

<이 주어지면 left에서 가장 뒤에있는 문자를 right 앞으로 push합니다. (left가 비어있으면 패스)

>이 주어지면 right에서 가장 앞에있는 문자를 left 뒤로 push합니다. (right가 비어있으면 패스)

-이 주어지면 left에서 가장 뒤에있는 문자를 pop합니다. (left가 비어있으면 패스)

나머지 문자가 주어지면 커서를 left로 유지해야하기 때문에 left 뒤로 push합니다.

 

이 과정이 끝나면 right에 있는 문자들을 앞에서부터 순서대로 left의 뒤로 차례대로 push하여 출력합니다.

 

 

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
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.Deque;
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 Deque<Character> left, right;
    static char ch[];
 
    static void print() {
        while(!left.isEmpty()) {
            sb.append(left.peekFirst());
            left.removeFirst();
        }
        
        sb.append("\n");
    }
    
    static void func() {
        for (int i = 0; i < ch.length; i++) {
            if (ch[i] == '<') {
                if (left.isEmpty())
                    continue;
                right.addFirst(left.peekLast());
                left.removeLast();
            } else if (ch[i] == '>') {
                if (right.isEmpty())
                    continue;
                left.addLast(right.peekFirst());
                right.removeFirst();
            } else if (ch[i] == '-') {
                if (left.isEmpty())
                    continue;
                left.removeLast();
            } else
                left.addLast(ch[i]);
        }
        
        while(!right.isEmpty()) {
            left.addLast(right.peekFirst());
            right.removeFirst();
        }
    }
 
    static void input() throws Exception {
        left = new ArrayDeque<>();
        right = new ArrayDeque<>();
 
        st = new StringTokenizer(br.readLine());
        ch = st.nextToken().toCharArray();
    }
 
    public static void main(String[] args) throws Exception {
        st = new StringTokenizer(br.readLine());
        int tc = Integer.parseInt(st.nextToken());
        while (tc-- > 0) {
            input();
            func();
            print();
        }
        System.out.println(sb.toString());
    }
}
cs

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

boj 3190 뱀  (0) 2021.02.02
boj 2346 풍선 터뜨리기  (0) 2021.02.02
boj 10866 덱  (0) 2021.02.02
boj 11000 강의실 배정  (0) 2021.02.01
boj 1966 프린터 큐  (0) 2021.02.01

www.acmicpc.net/problem/10866

 

10866번: 덱

첫째 줄에 주어지는 명령의 수 N (1 ≤ N ≤ 10,000)이 주어진다. 둘째 줄부터 N개의 줄에는 명령이 하나씩 주어진다. 주어지는 정수는 1보다 크거나 같고, 100,000보다 작거나 같다. 문제에 나와있지

www.acmicpc.net

덱의 기능들을 연습해볼 수 있는 기본적인 문제입니다.

 

덱은 push와 pop이 앞, 뒤로 모두 가능한 자료구조입니다.

 

push_front X : X를 덱 앞으로 push

push_back X : X를 덱 뒤로 push

pop_front : 덱의 가장 앞에있는 정수를 pop, 만약 덱이 비어있으면 -1 출력

pop_back : 덱의 가장 뒤에있는 정수를 pop, 만약 덱이 비어있으면 -1 출력

size : 덱의 크기 출력

empty : 덱이 비어있으면 1, 아니면 0을 출력

front : 덱의 가장 앞에있는 정수 출력, 만약 덱이 비어있으면 -1 출력

back : 덱의 가장 뒤에있는 정수 출력, 만약 덱이 비어있으면 -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
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
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.Deque;
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 Deque<Integer> dq = new ArrayDeque<>();
    static int N;
 
    static void push_front(int x) {
        dq.addFirst(x);
    }
 
    static void push_back(int x) {
        dq.addLast(x);
    }
 
    static void pop_front() {
        if (dq.isEmpty()) {
            sb.append("-1\n");
            return;
        }
 
        sb.append(dq.peekFirst() + "\n");
        dq.removeFirst();
    }
 
    static void pop_back() {
        if (dq.isEmpty()) {
            sb.append("-1\n");
            return;
        }
 
        sb.append(dq.peekLast() + "\n");
        dq.removeLast();
    }
 
    static void size() {
        sb.append(dq.size() + "\n");
    }
 
    static void empty() {
        if (dq.isEmpty())
            sb.append("1\n");
        else
            sb.append("0\n");
    }
 
    static void front() {
        if (dq.isEmpty()) {
            sb.append("-1\n");
            return;
        }
 
        sb.append(dq.peekFirst() + "\n");
    }
 
    static void back() {
        if (dq.isEmpty()) {
            sb.append("-1\n");
            return;
        }
 
        sb.append(dq.peekLast() + "\n");
    }
 
    static void input() throws Exception {
        String type;
        int x;
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
 
        while (N-- > 0) {
            st = new StringTokenizer(br.readLine());
            type = st.nextToken();
 
            if ("push_front".equals(type)) {
                x = Integer.parseInt(st.nextToken());
                push_front(x);
            } else if ("push_back".equals(type)) {
                x = Integer.parseInt(st.nextToken());
                push_back(x);
            } else if ("pop_front".equals(type))
                pop_front();
            else if ("pop_back".equals(type))
                pop_back();
            else if ("size".equals(type))
                size();
            else if ("empty".equals(type))
                empty();
            else if ("front".equals(type))
                front();
            else
                back();
        }
    }
 
    public static void main(String[] args) throws Exception {
        input();
        System.out.println(sb.toString());
    }
}
cs

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

boj 2346 풍선 터뜨리기  (0) 2021.02.02
boj 5397 키로거  (0) 2021.02.02
boj 11000 강의실 배정  (0) 2021.02.01
boj 1966 프린터 큐  (0) 2021.02.01
boj 2164 카드2  (0) 2021.02.01

www.acmicpc.net/problem/11000

 

11000번: 강의실 배정

첫 번째 줄에 N이 주어진다. (1 ≤ N ≤ 200,000) 이후 N개의 줄에 Si, Ti가 주어진다. (1 ≤ Si < Ti ≤ 109)

www.acmicpc.net

수업 시작시간과 종료시간이 주어집니다.

이 정보들을 가지고 모든 수업을 진행하는데 최소의 강의실을 사용해야합니다.

 

저는 우선순위 큐를 이용하였습니다.

일단 수업시간 정보를 2차원배열을 통해 [시작시간][종료시간]으로 저장하였고,

시작 시간 빠른 순, 시작 시간 같으면 종료 시간 빠른 순으로 정렬하였습니다.

 

큐에는 수업 종료시간만 저장해주면 되고, 큐에 넣은 종료시간과 다음 수업 시작시간을 비교합니다.

종료시간보다 다음 시작시간이 빠르면 같은 강의실을 사용할 수 없으므로 큐에 push합니다.

종료시간보다 다음 시작시간이 같거나 느리면 같은 강의실을 사용할 수 있으므로 큐를 pop하고 다음 종료시간을 push합니다.

 

이 과정을 반복하여 큐의 크기가 사용중인 강의실이며, 이를 출력하시면 됩니다.

 

 

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
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.StringTokenizer;
 
public class Main {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st;
    static PriorityQueue<Integer> q = new PriorityQueue<>();
    static int list[][];
    static int N;
 
    static void func() {
        q.add(list[0][1]);
        for (int i = 1; i < N; i++) {
            int s = list[i][0];
            int e = list[i][1];
 
            if (q.peek() <= s) {
                q.remove();
                q.add(e);
            } else
                q.add(e);
        }
 
        System.out.println(q.size());
    }
 
    static void input() throws Exception {
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        list = new int[N][2];
        for (int i = 0; i < N; i++) {
            st = new StringTokenizer(br.readLine());
            list[i][0= Integer.parseInt(st.nextToken());
            list[i][1= Integer.parseInt(st.nextToken());
        }
        Arrays.sort(list, new Comparator<int[]>() {
            @Override
            public int compare(int[] a, int[] b) {
                if (a[0< b[0])
                    return -1;
                else if (a[0== b[0]) {
                    if (a[1< b[1])
                        return -1;
                    else
                        return 1;
                } else
                    return 1;
            }
        });
    }
 
    public static void main(String[] args) throws Exception {
        input();
        func();
    }
}
cs

 

 

 

그리고.... Arrays.sort로 list배열을 정렬할 때 Comparator을 사용하여 시간 순으로 정렬하고자 하였습니다.

하지만 compare함수 if에 <=라는 기호를 넣으니 런타임에러가 떴습니다... 신기하게도 <로 바꾸니 AC를 받더라고요...

저번에도 이거때문에 시간좀 많이 날렸었는데 참 신기합니다.. 자바....

공부가 좀 더 많이 필요하겠다는 생각이 드는 하루네요..

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

boj 5397 키로거  (0) 2021.02.02
boj 10866 덱  (0) 2021.02.02
boj 1966 프린터 큐  (0) 2021.02.01
boj 2164 카드2  (0) 2021.02.01
boj 10845 큐  (0) 2021.02.01

www.acmicpc.net/problem/1966

 

1966번: 프린터 큐

여러분도 알다시피 여러분의 프린터 기기는 여러분이 인쇄하고자 하는 문서를 인쇄 명령을 받은 ‘순서대로’, 즉 먼저 요청된 것을 먼저 인쇄한다. 여러 개의 문서가 쌓인다면 Queue 자료구조에

www.acmicpc.net

큐에 저장되어있는 중요도가 높은 순서대로 pop을 해야합니다.

저는 인덱스와 중요도 관리를 해주기 위해 큐에 배열(중요도, 인덱스)을 넣었습니다.

 

그리고 중요도가 입력되면 현재 최댓값을 저장하기 위해 몇번 나왔는지(num[])와 최댓값 (maxp)를 사용하였습니다.

그리고 다음과 같은 과정을 수행합니다.

1. 큐에서 원소하나를 pop

2. pop한 원소가 현재 최대 중요도인지 확인 -> 최대 중요도가 아니면 다시 큐에 push합니다.

3. 최대 중요도이면 인덱스가 M과 일치하는지 확인 -> 일치하면 그대로 출력하고 리턴합니다.

4. 인덱스가 맞지 않으면 num[x]을 1 내리고, 만약 num[x]이 0이 되었을 때 다음 최댓값을 꺼내옵니다.

 

이 과정을 반복하여 M번 인덱스가 몇 번째로 pop되는지 출력합니다.

 

 

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 java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;
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 Queue<int[]> q = new LinkedList<>();
    static int num[] = new int[10];
    static int N, M, maxp;
 
    static void func() {
        while (true) {
            int x = q.peek()[0];
            int idx = q.peek()[1];
 
            q.remove();
            if (x != maxp)
                q.add(new int[] { x, idx });
            else {
                if (idx == M) {
                    sb.append(N - q.size() + "\n");
                    return;
                }
                num[x]--;
                if (num[x] == 0) {
                    for (int i = x; i >= 1; i--) {
                        if (num[i] > 0) {
                            maxp = i;
                            break;
                        }
                    }
                }
            }
        }
    }
 
    static void input() throws Exception {
        int x;
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
 
        st = new StringTokenizer(br.readLine());
        for (int i = 0; i < N; i++) {
            x = Integer.parseInt(st.nextToken());
            q.add(new int[] { x, i });
            num[x]++;
            maxp = Math.max(maxp, x);
        }
    }
 
    static void clear() {
        maxp = 0;
        for (int i = 1; i <= 9; i++)
            num[i] = 0;
        while (!q.isEmpty())
            q.remove();
    }
 
    public static void main(String[] args) throws Exception {
        st = new StringTokenizer(br.readLine());
        int tc = Integer.parseInt(st.nextToken());
        while (tc-- > 0) {
            input();
            func();
            clear();
        }
        System.out.println(sb.toString());
    }
}
cs

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

boj 10866 덱  (0) 2021.02.02
boj 11000 강의실 배정  (0) 2021.02.01
boj 2164 카드2  (0) 2021.02.01
boj 10845 큐  (0) 2021.02.01
boj 1655 가운데를 말해요  (0) 2021.02.01

www.acmicpc.net/problem/2164

 

2164번: 카드2

N장의 카드가 있다. 각각의 카드는 차례로 1부터 N까지의 번호가 붙어 있으며, 1번 카드가 제일 위에, N번 카드가 제일 아래인 상태로 순서대로 카드가 놓여 있다. 이제 다음과 같은 동작을 카드가

www.acmicpc.net

큐에 1부터 N까지 순서대로 push가 된 상태로 있습니다.

 

여기서 다음과 같은 동작을 카드가 하나 남을때까지 반복합니다.

1. 큐의 가장 위에있는 숫자를 버린다.

2. 큐의 가장 위에있는 숫자를 큐의 맨 뒤로 보내고 삭제한다.

 

큐의 크기가 1이 되면 break을 하고 남아있는 수를 출력합니다.

 

 

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
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;
 
public class Main {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st;
    static Queue<Integer> q = new LinkedList<>();
    static int N;
 
    static void func() {
        while (true) {
            if (q.size() == 1)
                break;
            
            q.remove();
            q.add(q.peek());
            q.remove();
        }
        
        System.out.println(q.peek());
    }
 
    static void init() {
        for (int i = 1; i <= N; i++) {
            q.add(i);
        }
    }
 
    static void input() throws Exception {
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
    }
 
    public static void main(String[] args) throws Exception {
        input();
        init();
        func();
    }
}
cs

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

boj 11000 강의실 배정  (0) 2021.02.01
boj 1966 프린터 큐  (0) 2021.02.01
boj 10845 큐  (0) 2021.02.01
boj 1655 가운데를 말해요  (0) 2021.02.01
boj 11279 최대 힙  (0) 2021.01.31

www.acmicpc.net/problem/10845

 

10845번: 큐

첫째 줄에 주어지는 명령의 수 N (1 ≤ N ≤ 10,000)이 주어진다. 둘째 줄부터 N개의 줄에는 명령이 하나씩 주어진다. 주어지는 정수는 1보다 크거나 같고, 100,000보다 작거나 같다. 문제에 나와있지

www.acmicpc.net

큐의 여러가지 기능을 사용해 볼 수 있는 간단한 문제입니다.

 

입력으로 6개의 명령이 주어집니다.

push X : 정수 X를 push

pop : q.peek()를 출력 후 pop, 만약 큐가 비어있으면 -1 출력

size : 큐의 크기를 출력

empty : 큐가 비어있으면 1, 아니면 0 출력

front : q.peek()를 출력, 만약 큐가 비어있으면 -1 출력

back : 큐에 가장 최근에 push된 정수 출력, 만약 큐가 비어있으면 -1 출력

 

큐가 비어있으면 -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
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
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;
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 Queue<Integer> q = new LinkedList<>();
    static int N, last;
 
    static void push(int x) {
        q.add(x);
    }
 
    static void pop() {
        if (q.isEmpty()) {
            sb.append("-1\n");
            return;
        }
 
        sb.append(q.peek() + "\n");
        q.remove();
    }
 
    static void size() {
        sb.append(q.size() + "\n");
    }
 
    static void empty() {
        if (q.isEmpty())
            sb.append("1\n");
        else
            sb.append("0\n");
    }
 
    static void front() {
        if (q.isEmpty()) {
            sb.append("-1\n");
            return;
        }
 
        sb.append(q.peek() + "\n");
    }
 
    static void back() {
        if (q.isEmpty()) {
            sb.append("-1\n");
            return;
        }
 
        sb.append(last + "\n");
    }
 
    static void input() throws Exception {
        String type;
        int x;
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        while (N-- > 0) {
            st = new StringTokenizer(br.readLine());
            type = st.nextToken();
 
            if ("push".equals(type)) {
                x = Integer.parseInt(st.nextToken());
                push(x);
                last = x;
            } else if ("pop".equals(type))
                pop();
            else if ("size".equals(type))
                size();
            else if ("empty".equals(type))
                empty();
            else if ("front".equals(type))
                front();
            else
                back();
        }
    }
 
    public static void main(String[] args) throws Exception {
        input();
        System.out.println(sb.toString());
    }
}
cs

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

boj 1966 프린터 큐  (0) 2021.02.01
boj 2164 카드2  (0) 2021.02.01
boj 1655 가운데를 말해요  (0) 2021.02.01
boj 11279 최대 힙  (0) 2021.01.31
boj 1927 최소 힙  (0) 2021.01.31

+ Recent posts