#유형 : 수학

#난이도 : lv2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Solution {
    public long solution(long w, long h) {
        long answer = 1;
        
        long tmp = Math.max(w,h);
        long tmp2 = Math.min(w,h);
        
        w = tmp2;
        h = tmp;
        answer = w * h - (w+h-gcd(h,w));
        return answer;
    }
    
    public long gcd(long x, long y){
        
        if(x % y == 0)
            return y;
        
        return gcd(y, x%y);
    }
}
cs

이런 문제의 경우, 보통 여러 케이스를 그려가며 반복되는 공통점을 찾는다.

 

우선 짝수의 경우를 먼저 살펴보자

8 x 12의 경우 96 - 16개

6 x 9의 경우 54 - 12개

4 x 6 의 경우 24 - 8

 

이 때, 사용할 수 없는 직사각형의 공통점은 w+h-(w,h)의 최대공약수 라는 것을 확인할 수 있다. 

 

그렇다면 홀수의 경우에도 같은 방법이 적용되는지 확인해보자.

 

 

위 그림은 (3,3)도 지나게 될것

3 x 4 의 경우 12 - 6 

 

 

2 x 3 의 경우 6 - 4 

 

둘다 홀수인 경우에도 W + H - ((W,H)의 최대공약수 1) 이 적용되는 것을 확인할 수 있다.

 

마지막으로, 홀수와 짝수가 같이 있는 경우를 살펴보자

 

 

1 x 2 의 경우 2 - 2 

5 x 2 의 경우 10 - 6

 

아까와 동일하다.

 

결과로, 사용할 수 없는 직사각형의 공통점은 w+h-(w,h)의 최대공약수가 맞다는 것을 확인할 수 있다.

 

# 유형 : 그래프 탐색, BFS

# 난이도 : 실버 2

# 울타리로 구분되어있는 부분을 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
76
package bj;
 
import java.awt.Point;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;
 
public class p3187 {
    static int R,C;
    static char arr[][];
    static boolean visit[][];
    static int moveX[] = {0,1,0,-1};
    static int moveY[] = {-1,0,1,0};
    public static void main(String[] args) throws Exception{
        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];
        int sheep = 0;
        int wolf = 0;
        for(int r=0; r<R; r++) {
            String str = br.readLine();
            for(int c=0; c<C; c++) {
                arr[r][c] = str.charAt(c);
            }
        }
        for(int r=0; r<R; r++) {
            for(int c=0; c<C; c++) {
                if(arr[r][c] != '#' && !visit[r][c]) {
                    Point po = bfs(r,c);
                    wolf += po.x;
                    sheep += po.y;
                }
            }
        }
        System.out.println(sheep +" " +wolf);
    }
    private static Point bfs(int row, int col) {
        // TODO Auto-generated method stub
        Queue<Point> queue = new LinkedList<Point>();
        visit[row][col] = true;
        queue.add(new Point(col, row));
        int sheep = 0;
        int wolf = 0;
        while(!queue.isEmpty()) {
            Point po = queue.poll();
            if(arr[po.y][po.x] == 'v')
                wolf++;
            else if(arr[po.y][po.x] == 'k')
                sheep++;
            
            for(int d=0; d<4; d++) {
                int newY = po.y + moveY[d];
                int newX = po.x + moveX[d];
                
                if(0<=newY && newY<&& 0<=newX && newX<&& !visit[newY][newX] && arr[newY][newX] != '#') {
                    visit[newY][newX] = true;
                    queue.add(new Point(newX, newY));
                }
            }
        }
        if(wolf>=sheep) {
            sheep = 0;
        }else {
            wolf = 0;
        }
        
        return new Point(wolf, sheep);
    }
}
 
cs

+ Recent posts