# 유형 : 시뮬레이션

# 난이도 : 실버 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
package bj;
 
import java.awt.Point;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
 
public class p1986 {
    static int KnightMoveX[] = {1,2,2,1,-1,-2,-2,-1};
    static int KnightMoveY[] = {-2,-1,1,2,2,1,-1,-2};
    static int QueenMoveX[] = {0,1,1,1,0,-1,-1,-1};
    static int QueenMoveY[] = {-1,-1,0,1,1,1,0,-1};
    static int N,M;
    static int Queen,Knight,Pawn;
    static Point[] queen,knight,pawn;
    static boolean visit[][];
    static int arr[][];
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
//        첫째 줄에는 체스 판의 크기 n과 m이 주어진다. (1<=n, m<=1000) 그리고 둘째 줄에는 Queen의 개수와 그 개수만큼의 Queen의 위치가 입력된다. 그리고 마찬가지로 셋째 줄에는
//        Knight의 개수와 위치, 넷째 줄에는 Pawn의 개수와 위치가 입력된다. (즉 둘째 줄~ 넷째 줄은  k,r1,c1,r2,c2,...,rk,ck 이 빈칸을 사이에 두고 주어진다는 것이다.
//        4 4
//        2 1 4 2 4
//        1 1 2
//        1 2 3
        StringTokenizer st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        visit = new boolean[N+1][M+1];
        arr = new int[N+1][M+1];
        st = new StringTokenizer(br.readLine());
        Queen = Integer.parseInt(st.nextToken());
        queen = new Point[Queen];
        for(int i=0; i<Queen; i++) {
            int y = Integer.parseInt(st.nextToken());
            int x = Integer.parseInt(st.nextToken());
            queen[i] = new Point(x,y);
            visit[y][x] = true;
            arr[y][x] = 1;
        }
        st = new StringTokenizer(br.readLine());
        Knight = Integer.parseInt(st.nextToken());
        knight = new Point[Knight];
        for(int i=0; i<Knight; i++) {
            int y = Integer.parseInt(st.nextToken());
            int x = Integer.parseInt(st.nextToken());
            knight[i] = new Point(x,y);
            visit[y][x] = true;
            arr[y][x] = 1;
        }
        st = new StringTokenizer(br.readLine());
        Pawn = Integer.parseInt(st.nextToken());
        pawn = new Point[Pawn];
        for(int i=0; i<Pawn; i++) {
            int y = Integer.parseInt(st.nextToken());
            int x = Integer.parseInt(st.nextToken());
            pawn[i] = new Point(x,y);
            visit[y][x] = true;
            arr[y][x] = 1;
        }
        
        for(int i=0; i<Knight; i++) {
            for(int d=0; d<8; d++) {
                int newX = knight[i].x + KnightMoveX[d];
                int newY = knight[i].y + KnightMoveY[d];
                if(0<newX && newX<=M && 0<newY && newY<=N && !visit[newY][newX])
                    visit[newY][newX] = true;
            }
        }
        for(int i=0; i<Queen; i++) {
            for(int d=0; d<8; d++) {
                int newX = queen[i].x + QueenMoveX[d];
                int newY = queen[i].y + QueenMoveY[d];
                while(true) {
                    if(0<newX && newX<=M && 0<newY && newY<=N && arr[newY][newX] != 1) {
                        visit[newY][newX] = true;
                        newX += QueenMoveX[d];
                        newY += QueenMoveY[d];
                    }else
                        break;
                }
            }
        }
        int result = 0;
        for(int i=1; i<=N; i++) 
            for(int j=1; j<=M; j++) 
                if(!visit[i][j])
                    result++;
        
        System.out.println(result);
    }
}
 
 cs

'백준' 카테고리의 다른 글

#백준_17471 게리맨더링 - Java 자바  (0) 2020.03.17
#백준_17281 ⚾ - Java 자바  (0) 2020.03.16
#백준_12761 돌다리 - Java 자바  (0) 2020.03.11
#백준_2986 파스칼 - Java 자바  (0) 2020.03.11
#백준_2194 유닛 이동시키기 - Java 자바  (0) 2020.03.10

# 유형 : BFS + 시뮬레이션

# 난이도 : 실버4 

# 현 위치 기준 +1, -1, +A, -A, +B, -B, *A, *B 8가지를 인덱스 주의하며 탐색을 돌려주면 된다.

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
package bj;
 
import java.awt.Point;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;
 
public class p12761 {
    static int A,B,N,M, result=0;
    static boolean visit[] = new boolean[100001];
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        A = Integer.parseInt(st.nextToken());
        B = Integer.parseInt(st.nextToken());
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        
        bfs();
        System.out.println(result);
    }
    private static void bfs() {
        // TODO Auto-generated method stub
        Queue<Point> queue = new LinkedList<Point>();
        queue.add(new Point(N,0));
        visit[N] = true;
        while(!queue.isEmpty()) {
            
            Point po = queue.poll();
            
            if(po.x == M) {
                result = po.y;
                return;
            }
            
            if(po.x + 1 < 100001 && !visit[po.x+1]) {
                visit[po.x+1] = true;
                queue.add(new Point(po.x+1, po.y+1));
            }
            if(po.x - 1 >= 0 && !visit[po.x-1]) {
                visit[po.x-1] = true;
                queue.add(new Point(po.x-1, po.y+1));
            }
            if(po.x + A < 100001 && !visit[po.x+A]) {
                visit[po.x+A] = true;
                queue.add(new Point(po.x+A, po.y+1));
            }
            if(po.x - A >= 0 && !visit[po.x-A]) {
                visit[po.x-A] = true;
                queue.add(new Point(po.x-A, po.y+1));
            }
            if(po.x + B < 100001 && !visit[po.x+B]) {
                visit[po.x+B] = true;
                queue.add(new Point(po.x+B, po.y+1));
            }
            if(po.x - B >= 0 && !visit[po.x-B]) {
                visit[po.x-B] = true;
                queue.add(new Point(po.x-B, po.y+1));
            }
            if(po.x * A < 100001 && !visit[po.x*A]) {
                visit[po.x*A] = true;
                queue.add(new Point(po.x*A, po.y+1));
            }
            if(po.x * B < 100001 && !visit[po.x*B]) {
                visit[po.x*B] = true;
                queue.add(new Point(po.x*B, po.y+1));
            }
        }
    }
}
 
 cs

'백준' 카테고리의 다른 글

#백준_17281 ⚾ - Java 자바  (0) 2020.03.16
#백준_1986 체스 - Java 자바  (1) 2020.03.12
#백준_2986 파스칼 - Java 자바  (0) 2020.03.11
#백준_2194 유닛 이동시키기 - Java 자바  (0) 2020.03.10
#백준_2589 보물섬 - Java 자바  (1) 2020.03.10

# 유형 : 구현

# 난이도 : 실버2

# 주어진 숫자 - 자기 자신을 제외한 가장 큰 자기자신의 약수 를 구하는 문제였는데, 주어진 알고리즘을 그대로 구현했더니 통과하였다. 시간초과는 발생하지않았는데, 발생한다면 에라토스테네스의 접근을 이용하여 해결할 수 있을것 같다.

 

** 주어진 자연수 N이 소수이기 위한 필요충분 조건은 N이 N의 제곱근보다 크지 않은 어떤 소수로도 나눠지지 않는다. 수가 수를 나누면 몫이 발생하게 되는데 몫과 나누는 수, 둘 중 하나는 반드시 N의 제곱근 이하이기 때문이다.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package bj;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
 
public class p2986 {
    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.parseInt(br.readLine());
        
        int count = 0;
        for(int i=N-1; i>0; i--) {
            count++;
            if(N%i==0)
                break;
        }
        System.out.println(count);
    }
}
 
 cs

'백준' 카테고리의 다른 글

#백준_1986 체스 - Java 자바  (1) 2020.03.12
#백준_12761 돌다리 - Java 자바  (0) 2020.03.11
#백준_2194 유닛 이동시키기 - Java 자바  (0) 2020.03.10
#백준_2589 보물섬 - Java 자바  (1) 2020.03.10
#백준_4948 베르트랑 공준 - Java 자바  (0) 2020.03.07

# 유형 : 탐색 + 시뮬레이션

# 난이도 : 실버 1

# 조건만 따져주며 탐색을 구현하면 된다. 좌표를 옮길때마다 +A , +B 만큼의 범위를 더 탐색해주면 된다.

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
package bj;
 
import java.awt.Point;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;
 
public class p2194 {
    static int N,M,A,B,K;
    static int arr[][];
    static boolean visit[][];
    static int moveX[] = {0,1,0,-1};
    static int moveY[] = {-1,0,1,0};
    static Point start, end;
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
//        첫째 줄에 다섯 개의 정수 N, M(1≤N, M≤500), A, B(1≤A, B≤10), K(0≤K≤100,000)가 주어진다. 
//        다음 K개의 줄에는 장애물이 설치된 위치(행 번호, 열 번호)가 주어진다. 
//        그 다음 줄에는 시작점의 위치와 도착점의 위치가 주어진다. 시작점의 위치와 도착점의 위치는 제일 왼쪽 제일 위의 한 점만 주어진다.
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        A = Integer.parseInt(st.nextToken());
        B = Integer.parseInt(st.nextToken());
        K = Integer.parseInt(st.nextToken());
        
        arr = new int[N+1][M+1];
        visit = new boolean[N+1][M+1];
        for(int i=0; i<K; i++) {
            st = new StringTokenizer(br.readLine());
            int y = Integer.parseInt(st.nextToken());
            int x = Integer.parseInt(st.nextToken());
            arr[y][x] = -1;
        }
        st = new StringTokenizer(br.readLine());
        int y = Integer.parseInt(st.nextToken());
        int x = Integer.parseInt(st.nextToken());
        start = new Point(x,y);
        
        st = new StringTokenizer(br.readLine());
        y = Integer.parseInt(st.nextToken());
        x = Integer.parseInt(st.nextToken());
        end = new Point(x,y);
        
        System.out.println(bfs());
    }
    static boolean Range(int i, int j) {
        if(1<=i && i<=N && 1<=j && j<=M)
            return true;
        return false;
    }
    static boolean isPossible(int i, int j) {
        if(visit[i][j])
            return false;
        for(int i_=i; i_<i+A; i_++) {
            for(int j_=j; j_<j+B; j_++) {
                if(!Range(i_,j_))
                    return false;
                if(arr[i_][j_] == -1)
                    return false;
            }
        }
        visit[i][j] = true;
        return true;
    }
    private static int bfs() {
        // TODO Auto-generated method stub
        Queue<Point> queue = new LinkedList<Point>();
        queue.add(start);
        visit[start.y][start.x] = true;
        int result = 0;
        while(!queue.isEmpty()) {
            int size = queue.size(); 
            for(int i=0; i<size; i++) {
                Point po = queue.poll();
                if(po.x == end.x && po.y == end.y) {
                    return result;
                }
                for(int d=0; d<4; d++) {
                    int newX = po.x + moveX[d];
                    int newY = po.y + moveY[d];
                    
                    if(!Range(newY, newX))
                        continue;
                    if(!isPossible(newY, newX))
                        continue;
                    
                    queue.add(new Point(newX,newY));
                }
            }
            result++;
        }
        
        
        return -1;
    }
    
}
 
 cs

'백준' 카테고리의 다른 글

#백준_12761 돌다리 - Java 자바  (0) 2020.03.11
#백준_2986 파스칼 - Java 자바  (0) 2020.03.11
#백준_2589 보물섬 - Java 자바  (1) 2020.03.10
#백준_4948 베르트랑 공준 - Java 자바  (0) 2020.03.07
#백준_1939 중량제한 - Java 자바  (0) 2020.03.07

# 유형 : 그래프 탐색, BFS

# 난이도 : 골드 5

# 기존 bfs 문제와 비슷한데, 모든 육지에서 bfs를 돌려 가장 긴 구간을 구해야 했던 문제.

하나의 연결된 육지에서 가장 멀리 떨어져있는 두 곳을 찾아야한다. 아래의 경우 (1,2)에서 출발하는 건 최단 경로가 아니고, (4,1)에서 출발하여 (5,2)로 도착하는게 최단경로이다. 따라서 모든 육지에서 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
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;
 
public class p2589 {
    static int R,C;
    static int moveY[] = {-1,0,1,0};
    static int moveX[] = {0,1,0,-1};
    static char arr[][];
    static boolean visit[][];
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        R = Integer.parseInt(st.nextToken());
        C = Integer.parseInt(st.nextToken());
        arr = new char[R][C];
        visit = new boolean[R][C];
        for(int i=0; i<R; i++) {
            String str = br.readLine();
            for(int j=0; j<C; j++) {
                arr[i][j] = str.charAt(j);
            }
        }
        int result = 0;
        
        for(int i=0; i<R; i++) {
            for(int j=0; j<C; j++) {
                if(arr[i][j] == 'L') {
                    visit = new boolean[R][C];
                    int val = bfs(i,j);
                    result = Math.max(result, val);
                    
                }
            }
        }
        
        System.out.println(result);
        
    }
    private static int bfs(int i, int j) {
        Queue<Po> queue = new LinkedList<>();
        int val = 0;
        visit[i][j] = true;
        queue.add(new Po(j,i,0));
        while(!queue.isEmpty()) {
            Po p = queue.poll();
            for(int d=0; d<4; d++) {
                int newX = p.x + moveX[d];
                int newY = p.y + moveY[d];
                if(0<=newX && newX<C && 0<=newY && newY<R && !visit[newY][newX] && arr[newY][newX]=='L') {
                    visit[newY][newX] = true;
                    queue.add(new Po(newX, newY, p.cnt+1));
                    val = Math.max(val, p.cnt+1);
                }
            }
        }
        return val;
    }
    public static class Po{
        int x;
        int y;
        int cnt;
        public Po(int x, int y, int cnt) {
            this.x = x;
            this.y = y;
            this.cnt = cnt;
        }
    }
}
 
 cs

'백준' 카테고리의 다른 글

#백준_2986 파스칼 - Java 자바  (0) 2020.03.11
#백준_2194 유닛 이동시키기 - Java 자바  (0) 2020.03.10
#백준_4948 베르트랑 공준 - Java 자바  (0) 2020.03.07
#백준_1939 중량제한 - Java 자바  (0) 2020.03.07
#백준_5567 결혼식 - Java 자바  (0) 2020.03.06

# 유형 : 구현, 소수 구하기, 에라토스테네스의 체

# 난이도 : 실버2

# 소수구하기, 에라토스테네스 접근을 알고있다면 정말 쉽게 풀 수 있던 문제

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
package bj;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
 
public class p4948 {
    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        while(true) {
            int from = Integer.parseInt(br.readLine());
            if(from == 0)
                break;
            int to = from * 2;
            System.out.println(getPrime(from+1, to));
        }
    
    }
    public static int getPrime(int from, int to) {
        int result = 0;
        for(int i=from; i<=to; i++) {
            boolean check = true;
            for(int j=2; j<=Math.sqrt(i); j++) {
                if(i%j == 0) {
                    check = false;
                    break;
                }
            }
            if(check)
                result++;
        }
        return result;
    }
}
 
 cs

'백준' 카테고리의 다른 글

#백준_2194 유닛 이동시키기 - Java 자바  (0) 2020.03.10
#백준_2589 보물섬 - Java 자바  (1) 2020.03.10
#백준_1939 중량제한 - Java 자바  (0) 2020.03.07
#백준_5567 결혼식 - Java 자바  (0) 2020.03.06
#백준_2981 검문 - Java 자바  (0) 2020.03.06

# 유형 : 그래프 탐색, 이분 탐색

# 난이도 : 골드 4

# 변수 3개를 갖는 객체타입을 가지는 큐로 BFS구현했는데 시간초과가 나서, 분류를 보니 이분탐색도 포함되어있었다. 어떻게 할지 고민하다가, 답은 입력받는 중량중 하나이기에 입력받은 중량 값 중  가장 낮은 값과 가장 큰 값을 기준으로 이분 탐색을 하며 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
package bj;
 
import java.awt.Point;
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 p1939 {
    static int N,M;
    static ArrayList<Point> arrList[];
    static boolean visit[];
    static int begin, end;
    public static void main(String[] args) throws Exception{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        
        arrList = new ArrayList[N+1];
        for(int i=0; i<N+1; i++)
            arrList[i] = new ArrayList<>();
        
        int low = 999999, high = 0;
        
        
        for(int i=0; i<M; i++) {
            st = new StringTokenizer(br.readLine());
            int u = Integer.parseInt(st.nextToken());
            int v = Integer.parseInt(st.nextToken());
            int val = Integer.parseInt(st.nextToken());
            low = Math.min(low, val);
            high = Math.max(high, val);
            arrList[u].add(new Point(v, val));
            arrList[v].add(new Point(u, val));
        }
        st = new StringTokenizer(br.readLine());
        begin = Integer.parseInt(st.nextToken());
        end = Integer.parseInt(st.nextToken());
        
        
        while(low <= high) {
            visit = new boolean[N+1];
            int mid =(low+high)/2;
            if(bfs(mid))
                low = mid+1;
            else
                high = mid-1;
        }
        System.out.println(high);
    }
    private static boolean bfs(int val) {
        // TODO Auto-generated method stub
        Queue<Integer> queue = new LinkedList<Integer>();
        visit[begin] = true;
        queue.add(begin);
        while(!queue.isEmpty()) {
            int poll = queue.poll();
            if(poll == end)
                return true;
            
            for(int i=0; i<arrList[poll].size(); i++) {
                if(!visit[arrList[poll].get(i).x] && val <= arrList[poll].get(i).y) {
                    visit[arrList[poll].get(i).x] = true;
                    queue.add(arrList[poll].get(i).x);
                }
            }
        }
        return false;
    }
    
}
 
 cs

'백준' 카테고리의 다른 글

#백준_2589 보물섬 - Java 자바  (1) 2020.03.10
#백준_4948 베르트랑 공준 - Java 자바  (0) 2020.03.07
#백준_5567 결혼식 - Java 자바  (0) 2020.03.06
#백준_2981 검문 - Java 자바  (0) 2020.03.06
#백준_1726 로봇 - Java 자바  (0) 2020.03.05

#유형 : 그래프 탐색, BFS

# 난이도 : 실버 1

# 전형적인 BFS문제에 조건 하나 추가해준 문제. 난이도에 맞지 않게 매우 쉬웠다고 생각함. 큐에 Point형으로 x,y 값을 넣는데 친구의 친구까지만 허용되므로 2보다 큰 값인 경우에는 허용되지 않는다.

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
package bj;
 
import java.awt.Point;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;
 
public class p5567 {
    static ArrayList<Integer> arrList = new ArrayList<>();
    static int N,M;
    static int arr[][];
    static boolean visit[];
    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        N = Integer.parseInt(br.readLine());
        M = Integer.parseInt(br.readLine());
        arr = new int[N+1][N+1];
        visit = new boolean[N+1];
        for(int m=0; m<M; m++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            int u = Integer.parseInt(st.nextToken());
            int v = Integer.parseInt(st.nextToken());
            arr[u][v] = 1;
            arr[v][u] = 1;
        }
        bfs();
        System.out.println(arrList.size());
//        for(int i : arrList)
//            System.out.println(i);
    }
    private static void bfs() {
        // TODO Auto-generated method stub
        Queue<Point> queue = new LinkedList<Point>();
        queue.add(new Point(1,0));
        visit[1] = true;
        
        while(!queue.isEmpty()) {
            Point po = queue.poll();
            
            for(int i=1; i<=N; i++) {
                if(arr[po.x][i] == 1 && !visit[i] && po.y < 2) {
                    arrList.add(i);
                    visit[i] = true;
                    queue.add(new Point(i, po.y+1));
                }
            }
        }
    }
}
 
 cs

'백준' 카테고리의 다른 글

#백준_4948 베르트랑 공준 - Java 자바  (0) 2020.03.07
#백준_1939 중량제한 - Java 자바  (0) 2020.03.07
#백준_2981 검문 - Java 자바  (0) 2020.03.06
#백준_1726 로봇 - Java 자바  (0) 2020.03.05
#백준_1039 교환 - Java 자바  (0) 2020.03.04

+ Recent posts

티스토리툴바