www.acmicpc.net/problem/1912

 

1912번: 연속합

첫째 줄에 정수 n(1 ≤ n ≤ 100,000)이 주어지고 둘째 줄에는 n개의 정수로 이루어진 수열이 주어진다. 수는 -1,000보다 크거나 같고, 1,000보다 작거나 같은 정수이다.

www.acmicpc.net

배열이 주어지면 연속된 수를 선택하여 얻을 수 있는 합을 최대로 해야합니다.

dp를 이용하여 간단하게 해결하였지만 분할정복 기법으로 사용한 소스도 같이 올리겠습니다.

 

우선 dp는 간단합니다.

(i번째 수)와 (i - 1까지의 연속합 최대에 i번째 수를 더한 값) 중 최댓값이 dp[i]가 됩니다.

입력이 음수로 들어오기때문에 ans를 미리 Integer.MIN_VALUE로 최솟값을 만들어 놓고 진행합니다.

합의 최대가 N번째에 온다는 보장이 없기때문에 dp를 구할때마다 갱신해줍니다.

 

 

[dp]

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
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 dp[];
    static int N, ans = Integer.MIN_VALUE;
 
    static void input() throws Exception {
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        dp = new int[N + 1];
        st = new StringTokenizer(br.readLine());
        for (int i = 1; i <= N; i++) {
            dp[i] = Integer.parseInt(st.nextToken());
            dp[i] = Math.max(dp[i], dp[i - 1+ dp[i]);
            ans = Math.max(ans, dp[i]);
        }
    }
 
    public static void main(String[] args) throws Exception {
        input();
        System.out.println(ans);
    }
}
 
cs

 

다음은 분할정복 기법입니다. 시간상으로는 dp가 더 빠르지만 오늘 배운내용으로 한번 해보았습니다.

구간 1 ~ N 에서의 최대 연속합을 구합니다.

1. 왼쪽(l ~ m) 구간

2. 오른쪽(m + 1 ~ r)

3. 1과 2 모두 포함하는 부분배열의 합을 모두 구해주시면 됩니다.

 

1, 2번은 이분탐색 방식으로 나눠주시면 되고,

3번을 구할때는 m은 무조건 포함하기 때문에 m부터 왼쪽(l까지)으로 인덱스를 옮겨가며 sum에 더해줍니다.

이 때, 더하면서 leftmax를 계속 갱신시켜줍니다.

그리고 m + 1부터 오른쪽(r까지)으로 인덱스를 옮겨가며 sum에 더해줍니다.

이 때도 마찬가지로 더하면서 rightmax를 계속 갱신시켜줍니다.

 

이 문제의 답은 1, 2, 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
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 list[];
    static int N, ans = Integer.MIN_VALUE;
 
    static int binarysearch(int l, int r) {
        if (l == r)
            return list[l];
 
        int m = (l + r) / 2;
        int leftmax = Integer.MIN_VALUE;
        int rightmax = Integer.MIN_VALUE;
        int sum = 0;
        for (int i = m; i >= l; i--) {
            sum += list[i];
            leftmax = Math.max(leftmax, sum);
        }
 
        sum = 0;
        for (int i = m + 1; i <= r; i++) {
            sum += list[i];
            rightmax = Math.max(rightmax, sum);
        }
 
        return Math.max(leftmax + rightmax, Math.max(binarysearch(l, m), binarysearch(m + 1, r)));
    }
 
    static void func() {
        System.out.println(binarysearch(1, N));
    }
 
    static void input() throws Exception {
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        list = new int[N + 1];
 
        st = new StringTokenizer(br.readLine());
        for (int i = 1; i <= N; i++) {
            list[i] = Integer.parseInt(st.nextToken());
        }
    }
 
    public static void main(String[] args) throws Exception {
        input();
        func();
    }
}
cs

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

boj 11049 행렬 곱셈 순서  (0) 2021.02.20
boj 1915 가장 큰 정사각형  (0) 2021.02.20
boj 10211 Maximum Subarray  (0) 2021.02.18
boj 10826 피보나치 수 4  (0) 2021.02.08
boj 5569 출근 경로  (0) 2021.02.06

www.acmicpc.net/problem/10211

 

10211번: Maximum Subarray

크기 N인 정수형 배열 X가 있을 때, X의 부분 배열(X의 연속한 일부분) 중 각 원소의 합이 가장 큰 부분 배열을 찾는 Maximum subarray problem(최대 부분배열 문제)은 컴퓨터 과학에서 매우 잘 알려져 있

www.acmicpc.net

www.acmicpc.net/problem/1912

 

1912번: 연속합

첫째 줄에 정수 n(1 ≤ n ≤ 100,000)이 주어지고 둘째 줄에는 n개의 정수로 이루어진 수열이 주어진다. 수는 -1,000보다 크거나 같고, 1,000보다 작거나 같은 정수이다.

www.acmicpc.net

위의 문제와 같은문제이지만 N의 범위가 적게 들어옵니다.

저는 dp와 세그먼트 트리 두가지 방법으로 해결하였습니다.

이 문제는 당연히 dp로 해결한 것이 속도가 빠르기 때문에 dp로 접근하시면 됩니다.

세그먼트 트리는 그냥 해본거에요..

근데 이문제는 그냥 브루트포스로 모든경우를 다구해도 풀립니다.. 밑에 소스첨부합니다

 

dp의 점화식은 이전 인덱스까지 더한 dp값에 현재 자신의 값을 더한것과 자신의 값 중 큰 값이되어

dp[i] = max(dp[i - 1] + list[i], list[i]) 가 되겠습니다.

 

 

[dp]

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
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 list[], dp[];
    static int N;
 
    static void func() {
        int ans = Integer.MIN_VALUE;
        for (int i = 1; i <= N; i++) {
            dp[i] = Math.max(dp[i - 1+ list[i], list[i]);
            ans = Math.max(ans, dp[i]);
        }
        
        sb.append(ans).append("\n");
    }
 
    static void input() throws Exception {
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        list = new int[N + 1];
        dp = new int[N + 1];
 
        st = new StringTokenizer(br.readLine());
        for (int i = 1; i <= N; i++) {
            list[i] = Integer.parseInt(st.nextToken());
        }
    }
 
    public static void main(String[] args) throws Exception {
        st = new StringTokenizer(br.readLine());
        int tc = Integer.parseInt(st.nextToken());
        while (tc-- > 0) {
            input();
            func();
        }
        
        System.out.println(sb.toString());
    }
}
cs

 

세그먼트 트리 방법으로는 입력으로 list를 받으면

init함수로 각 구간의 합을 미리 구해놓습니다.

이중 for문으로 (i, i ~ N)까지 구간 합의 최대를 구해주시면 됩니다.

 

 

[세그먼트 트리]

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
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 tree[] = new int[4004];
    static int list[] = new int[1001];
    static int N;
 
    static int init(int node, int s, int e) {
        if (s == e)
            return tree[node] = list[s];
 
        int m = (s + e) / 2;
        return tree[node] = init(node * 2, s, m) + init(node * 2 + 1, m + 1, e);
    }
 
    static int query(int node, int s, int e, int l, int r) {
        if (s > r || l > e)
            return 0;
        if (l <= s && e <= r)
            return tree[node];
 
        int m = (s + e) / 2;
        return query(node * 2, s, m, l, r) + query(node * 2 + 1, m + 1, e, l, r);
    }
 
    static void func() {
        int ans = Integer.MIN_VALUE;
        for (int i = 1; i <= N; i++) {
            for (int j = i; j <= N; j++) {
                ans = Math.max(ans, query(11, N, i, j));
            }
        }
        
        sb.append(ans).append("\n");
    }
 
    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++) {
            list[i] = Integer.parseInt(st.nextToken());
        }
        init(11, N);
    }
 
    public static void main(String[] args) throws Exception {
        st = new StringTokenizer(br.readLine());
        int tc = Integer.parseInt(st.nextToken());
        while (tc-- > 0) {
            input();
            func();
        }
        
        System.out.println(sb.toString());
    }
}
cs

 

[브루트포스]

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
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 list[];
    static int N;
 
    static void func() {
        int ans = Integer.MIN_VALUE;
        for (int i = 0; i < N; i++) {
            for (int j = i; j < N; j++) {
                int sum = 0;
                for (int k = i; k <= j; k++) {
                    sum += list[k];
                }
                ans = Math.max(ans, sum);
            }
        }
        sb.append(ans).append("\n");
    }
 
    static void input() throws Exception {
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        list = new int[N];
        st = new StringTokenizer(br.readLine());
        for (int i = 0; i < N; i++) {
            list[i] = Integer.parseInt(st.nextToken());
        }
    }
 
    public static void main(String[] args) throws Exception {
        st = new StringTokenizer(br.readLine());
        int tc = Integer.parseInt(st.nextToken());
        while (tc-- > 0) {
            input();
            func();
        }
 
        System.out.println(sb.toString());
    }
}
cs

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

boj 1915 가장 큰 정사각형  (0) 2021.02.20
boj 1912 연속합  (0) 2021.02.18
boj 10826 피보나치 수 4  (0) 2021.02.08
boj 5569 출근 경로  (0) 2021.02.06
boj 1010 다리 놓기  (0) 2021.02.05

www.acmicpc.net/problem/1987

 

1987번: 알파벳

세로 R칸, 가로 C칸으로 된 표 모양의 보드가 있다. 보드의 각 칸에는 대문자 알파벳이 하나씩 적혀 있고, 좌측 상단 칸 (1행 1열) 에는 말이 놓여 있다. 말은 상하좌우로 인접한 네 칸 중의 한 칸으

www.acmicpc.net

 

문제에서 요구하는 조건은

1. 말은 (0, 0)에서 출발합니다.

2. 말은 상하좌우 방향으로 움직일 수 있습니다.

3. 말이 지나가는 동안 밟은 칸의 알파벳은 모두 달라야합니다.

 

말이 (0, 0)에서 출발하여 지나갈 수 있는 최대의 칸 수를 출력해야합니다.

저는 백트래킹으로 해결하였고 해당 칸을 방문체크하는 visit배열과 칸에 있는 알파벳 중복체크를 위한 alphachk 배열을 사용하였습니다.

 

재귀를 돌릴때마다 답을 갱신해주고, 해당 칸과 알파벳에 방문처리합니다.

그 다음 4방향 탐색하여 맵 밖으로 나갔는지, 이미 방문하였거나 밟은 적이 있는 알파벳인지 체크를 해줍니다.

모두 통과하면 nx, ny, cnt+1를 재귀로 넘겨주고, 빠져나오면 true했던 boolean배열을 모두 false로 바꿔줍니다.

마지막으로 정답을 출력합니다.

 

 

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.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 boolean visit[][], alphachk[];
    static char list[][];
    static int N, M, ans;
 
    static void dfs(int x, int y, int cnt) {
        ans = Math.max(ans, cnt);
        visit[x][y] = true;
        alphachk[list[x][y] - 'A'= true;
 
        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] || alphachk[list[nx][ny] - 'A'])
                continue;
 
            dfs(nx, ny, cnt + 1);
            alphachk[list[nx][ny] - 'A'= false;
            visit[nx][ny] = false;
        }
    }
 
    static void input() throws Exception {
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        list = new char[N][];
        visit = new boolean[N][M];
        alphachk = new boolean[26];
 
        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();
        dfs(001);
        System.out.println(ans);
    }
}
cs

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

boj 14500 테트로미노  (0) 2021.03.15
boj 16922 로마 숫자 만들기  (0) 2021.02.24
boj 3109 빵집  (0) 2021.02.18
boj 17406 배열 돌리기 4  (0) 2021.02.10
boj 16927 배열 돌리기 2  (0) 2021.02.10

www.acmicpc.net/problem/3109

 

3109번: 빵집

유명한 제빵사 김원웅은 빵집을 운영하고 있다. 원웅이의 빵집은 글로벌 재정 위기를 피해가지 못했고, 결국 심각한 재정 위기에 빠졌다. 원웅이는 지출을 줄이고자 여기저기 지출을 살펴보던

www.acmicpc.net

 

파이프는 오른쪽, 대각선 오른쪽 위, 대각선 오른쪽 아래 방향으로 연결할 수 있고,

0번 열에서 M - 1번 열까지 파이프를 이어야하며 최종적으로 파이프라인의 최대 갯수를 출력하는 문제입니다.

 

저는 여기서 앞의 열에서 최대한 앞쪽의 열에 파이프를 연결하면 될것이라는 생각을 하여 백트래킹에 그리디알고리즘을 사용하였습니다.

 

(0, 0) ~ (N - 1, 0)까지 각각 dfs로 끝 열에 도달할 수 있는지 확인해줍니다.

그리디를 사용했기때문에 오른쪽 위 -> 오른쪽 -> 오른쪽 아래 방향 순으로 탐색해줍니다.

끝 열에 도달하면 true를 리턴해주고, 도달하지 못하면 false를 리턴합니다.

true일 경우에만 ans++를 하여 최종 답을 출력합니다.

 

visit배열을 초기화하지 않은 이유는

파이프는 겹칠수 없어서 앞쪽에서 연결한 파이프와 겹칠 수 있기 때문입니다.

만약 최종적으로 연결한 파이프가 아니라고 해도 그 위치에서는 파이프를 연결할 수 없다는 뜻이 되므로 초기화를 하지 않아야합니다.

 

 

[C++]

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
#include <iostream>
using namespace std;
 
bool visit[10010][510];
char list[10010][510];
int direct[3][2= { {-1,1},{0,1},{1,1} };
int N, M, ans;
 
bool dfs(int x, int y) {
    visit[x][y] = true;
    if (y == M - 1return true;
 
    for (int i = 0; i < 3; 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] == 'x'continue;
 
        bool chk = dfs(nx, ny);
        if (chk)
            return true;
    }
 
    return false;
}
 
void func() {
    for (int i = 0; i < N; i++) {
        if (dfs(i, 0)) ans++;
    }
 
    cout << ans << '\n';
}
 
void input() {
    cin >> N >> M;
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < M; j++) {
            cin >> list[i][j];
        }
    }
}
 
int main() {
    cin.tie(NULL); cout.tie(NULL);
    ios::sync_with_stdio(false);
 
    input();
    func();
 
    return 0;
}
cs

 

 

[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
53
54
55
56
57
58
59
60
61
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[][] = { { -11 }, { 01 }, { 11 } };
    static boolean visit[][];
    static char list[][];
    static int N, M, ans;
 
    static boolean dfs(int x, int y) {
        visit[x][y] = true;
        if (y == M - 1)
            return true;
 
        for (int i = 0; i < 3; 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] == 'x')
                continue;
 
            boolean chk = dfs(nx, ny);
            if (chk)
                return true;
        }
 
        return false;
    }
 
    static void func() {
        for (int i = 0; i < N; i++) {
            if (dfs(i, 0))
                ans++;
        }
 
        System.out.println(ans);
    }
 
    static void input() throws Exception {
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        list = new char[N][];
        visit = new boolean[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();
    }
}
cs

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

boj 16922 로마 숫자 만들기  (0) 2021.02.24
boj 1987 알파벳  (0) 2021.02.18
boj 17406 배열 돌리기 4  (0) 2021.02.10
boj 16927 배열 돌리기 2  (0) 2021.02.10
boj 16926 배열 돌리기 1  (0) 2021.02.10

www.acmicpc.net/problem/10157

 

10157번: 자리배정

첫 줄에는 공연장의 격자 크기를 나타내는 정수 C와 R이 하나의 공백을 사이에 두고 차례대로 주어진다. 두 값의 범위는 5 ≤ C, R ≤ 1,000이다. 그 다음 줄에는 어떤 관객의 대기번호 K가 주어진다.

www.acmicpc.net

문제의 그림은 이렇게 나와있지만

 

저는 편의를 위해 이렇게 옆으로 회전시켜서 구현하였습니다.

 

그 다음 (x, y) = (0, 0)으로 초기값을 잡고 시뮬레이션을 돌렸습니다.

진행방향은 오른쪽 -> 아래쪽 -> 왼쪽 -> 위쪽 순서입니다.

(nx ,ny)이 맵 밖으로 나가거나 방문한 좌표면 방향을 바꿔주고 다시 돌려줍니다.

이 과정에서 번호가 K에 도달하면 좌표를 출력해줍니다.

 

좌석은 N * M개 있으므로 만약 K가 N * M보다 크면 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
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 boolean visit[][];
    static int direct[][] = { { 01 }, { 10 }, { 0-1 }, { -10 } };
    static int N, M, K;
 
    static void func() {
        if (K > N * M) {
            System.out.println(0);
            return;
        }
 
        int x = 0;
        int y = 0;
        int idx = 0;
        for (int k = 1; k <= N * M; k++) {
            visit[x][y] = true;
            if (k == K) {
                System.out.println((x + 1+ " " + (y + 1));
                return;
            }
 
            int nx = x + direct[idx][0];
            int ny = y + direct[idx][1];
            if (nx < 0 || ny < 0 || nx >= N || ny >= M || visit[nx][ny]) {
                idx = (idx + 1) % 4;
                nx = x + direct[idx][0];
                ny = y + direct[idx][1];
            }
 
            x = nx;
            y = ny;
        }
    }
 
    static void input() throws Exception {
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        st = new StringTokenizer(br.readLine());
        K = Integer.parseInt(st.nextToken());
        visit = new boolean[N][M];
    }
 
    public static void main(String[] args) throws Exception {
        input();
        func();
    }
}
cs

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

boj 20055 컨베이어 벨트 위의 로봇  (0) 2021.02.23
boj 2331 반복수열  (0) 2021.02.23
boj 16918 봄버맨  (0) 2021.02.17
boj 16935 배열 돌리기 3  (0) 2021.02.10
boj 1914 하노이 탑  (0) 2021.02.07

www.acmicpc.net/problem/16918

 

16918번: 봄버맨

첫째 줄에 R, C, N (1 ≤ R, C, N ≤ 200)이 주어진다. 둘째 줄부터 R개의 줄에 격자판의 초기 상태가 주어진다. 빈 칸은 '.'로, 폭탄은 'O'로 주어진다.

www.acmicpc.net

1. 가장 처음에 봄버맨은 일부 칸에 폭탄을 설치합니다. (입력으로 주어집니다.)

2. 1초 후에 봄버맨은 아무것도 하지않습니다.

3. 다음 1초 후에 폭탄이 설치되어 있지 않은 모든 칸에 폭탄을 동시에 설치합니다.

4. 다음 1초 후에 3초전에 설치했던 폭탄이 터집니다. 이때 바로 옆 공간의 폭탄도 터집니다.

5. 이후 3과 4를 반복합니다.

 

저는 폭탄을 나타내는 char형 배열과 시간(카운트)를 나타내는 int형 배열을 사용하였습니다.

3번 4번 과정을 반복하고, 처음 1번과정은 입력으로 주어진 후 1초동안은 아무것도 하지않기때문에

K를 1빼주고 처음 입력으로 주어진 폭탄들의 시간은 2초로 해줍니다.

 

그리고 반복문은 2초부터 돌려줍니다.

폭탄은 짝수 초에 터지고, 홀수 초에 놓아지기때문에 홀, 짝으로 나누어 구현하였습니다.

 

폭탄을 놓을 때는 시간이 0인 모든 공간에 놓아주었고, 시간이 0이 아니면 1 감소시켰습니다.

폭탄을 터뜨릴 때는 터져야할 모든 폭탄을 덱에 넣고, bfs방식으로 인접한 폭탄들을 함께 터뜨렸습니다.

마지막으로 K초가 지난 후의 격자판 상태를 출력해주시면 됩니다.

 

 

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
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 Deque<int[]> dq = new ArrayDeque<>();
    static int direct[][] = { { 01 }, { 10 }, { 0-1 }, { -10 } };
    static char list[][];
    static int time[][];
    static int N, M, K;
 
    static void print() {
        StringBuffer sb = new StringBuffer();
        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 bfs() {
        while (!dq.isEmpty()) {
            int x = dq.peekFirst()[0];
            int y = dq.pollFirst()[1];
            
            for (int k = 0; k < 4; k++) {
                int nx = x + direct[k][0];
                int ny = y + direct[k][1];
 
                if (nx < 0 || ny < 0 || nx >= N || ny >= M)
                    continue;
                time[nx][ny] = 0;
                list[nx][ny] = '.';
            }
        }
    }
 
    static void func() {
        for (int t = 1; t <= K; t++) {
            if (t % 2 != 0) {
                for (int i = 0; i < N; i++) {
                    for (int j = 0; j < M; j++) {
                        if (time[i][j] == 0) {
                            list[i][j] = 'O';
                            time[i][j] = 3;
                        } else
                            time[i][j]--;
                    }
                }
            } else {
                for (int i = 0; i < N; i++) {
                    for (int j = 0; j < M; j++) {
                        if (time[i][j] == 0)
                            continue;
                        time[i][j]--;
                        if (time[i][j] == 0) {
                            list[i][j] = '.';
                            dq.addLast(new int[] { i, j });
                        }
                    }
                }
 
                bfs();
            }
        }
    }
 
    static void input() throws Exception {
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        K = Integer.parseInt(st.nextToken()) - 1;
        time = new int[N][M];
        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] == 'O') {
                    time[i][j] = 2;
                }
            }
        }
    }
 
    public static void main(String[] args) throws Exception {
        input();
        func();
        print();
    }
}
cs

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

boj 2331 반복수열  (0) 2021.02.23
boj 10157 자리배정  (0) 2021.02.17
boj 16935 배열 돌리기 3  (0) 2021.02.10
boj 1914 하노이 탑  (0) 2021.02.07
boj 11729 하노이 탑 이동 순서  (0) 2021.02.07

www.acmicpc.net/problem/17135

 

17135번: 캐슬 디펜스

첫째 줄에 격자판 행의 수 N, 열의 수 M, 궁수의 공격 거리 제한 D가 주어진다. 둘째 줄부터 N개의 줄에는 격자판의 상태가 주어진다. 0은 빈 칸, 1은 적이 있는 칸이다.

www.acmicpc.net

알고리즘 분류는 bfs지만 조합 + 정렬 + 시뮬레이션 + 구현 등 사용해야할 기법이 많았습니다.

 

제가 처음 접근한 방법은

우선 조합으로 궁수가 있을 자리를 모두 구해준 다음

bfs로 4방향 탐색하여 공격가능한 적을 모두 담아놓고 정렬하여 맨 첫번째에 있는 적만 제거하였고

그 다음 적들을 모두 아래로 내려 다음 bfs탐색을 하는 방식이었습니다.

 

위의 방법으로 AC를 받았지만 시간적인 손해가 많다는 생각이 들었고, 시간을 줄이기위해 다른 방법을 생각하였습니다.

 

궁수는 항상 N + 1번째 행에 있기때문에 밑을 볼 필요가 없습니다. 그래서 왼쪽, 위, 오른쪽만 탐색하면 됩니다.

여기서 문제 조건을 보시면 가장 가까운 적이 여러명이면 가장 왼쪽에 있는 적을 공격한다고 나와있습니다.

위의 조건에서 왼쪽 -> 위 -> 오른쪽 방향 순서로 탐색하면 무조건 공격해야할 대상을 먼저 찾는다는 결론이 나왔습니다. 이제 정렬은 사용하지 않아도됩니다.

 

그 다음 여러명의 궁수가 한명의 적을 공격할 수 있기때문에 궁수가 공격할 대상을 찾으면

boolean배열을 사용하여 true로 바꿔주었고, 이중 for문으로 true인 좌표의 list를 0으로 바꿔주었지만

int배열을 사용하여 모든 좌표를 다 넣어주었고, 하나의 for문으로 해결할 수 있었습니다.

 

마지막으로 적을 제거하고 난 후에 이중 for문을 돌려서 적이 모두 제거되었는지 확인하였습니다.

제거되었으면 break를 해주고, 아니면 적들을 아래로 내려야합니다.

하지만 저는 적들을 아래로 내리는것보다 궁수를 위로 올리는 것이 시간상 효율적이라는 것을 깨닫고 궁수를 위로 올리기 위해 n--를 하였습니다.

 

최종적으로 저의 로직은 이렇습니다.

1. 조합으로 궁수를 배치

2. bfs로 3방향 탐색하여 공격할 수 있는 적을 탐색 (적을 찾거나 D보다 거리가 커지면 break)

3. 2번에서 찾은 적 제거

4. 적이 모두 제거되었는지 확인

5. 적이 모두 제거되었으면 break, 아니면 궁수 한 칸 위로 이동(n--)

 

자바에서 Collection사용이 많아지면 시간적으로 비효율적이라고 생각해서 배열을 최대한 사용하였습니다.

 

 

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
132
133
134
135
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Deque;
import java.util.StringTokenizer;
 
public class Main {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st;
    static boolean visit[][];
    static int direct[][] = { { 0-1 }, { -10 }, { 01 } };
    static int list[][], copylist[][], attacker[], rkill[][];
    static int N, M, D, ans, kidx;
 
    static void bfs() {
        int n = N;
        int sum = 0;
        Deque<int[]> dq = new ArrayDeque<int[]>();
        ArrayList<int[]> kill = new ArrayList<>();
        while (true) {
            for (int k = 0; k < 3; k++) {
                dq.addLast(new int[] { n, attacker[k], 0 });
                for (int i = 0; i < n; i++)
                    Arrays.fill(visit[i], false);
 
                while (!dq.isEmpty()) {
                    int x = dq.peekFirst()[0];
                    int y = dq.peekFirst()[1];
                    int cnt = dq.pollFirst()[2];
 
                    if (cnt == D) {
                        dq.clear();
                        break;
                    }
                    boolean chk = false;
                    for (int i = 0; i < 3; 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])
                            continue;
                        if (copylist[nx][ny] == 1) {
                            chk = true;
                            kill.add(new int[] { nx, ny, cnt + 1 });
                            break;
                        } else {
                            dq.addLast(new int[] { nx, ny, cnt + 1 });
                            visit[nx][ny] = true;
                        }
                    }
                    if (chk)
                        break;
                }
                dq.clear();
 
                if (kill.isEmpty())
                    continue;
 
                rkill[kidx][0= kill.get(0)[0];
                rkill[kidx++][1= kill.get(0)[1];
                kill.clear();
            }
 
            for (int i = 0; i < kidx; i++) {
                if (copylist[rkill[i][0]][rkill[i][1]] == 1) {
                    copylist[rkill[i][0]][rkill[i][1]] = 0;
                    sum++;
                }
            }
            kidx = 0;
 
            boolean allkill = false;
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < M; j++) {
                    if (copylist[i][j] == 1) {
                        allkill = true;
                        break;
                    }
                }
                if (allkill)
                    break;
            }
            if (!allkill)
                break;
            n--;
        }
 
        ans = Math.max(ans, sum);
    }
 
    static void func(int idx, int cnt) {
        if (cnt == 3) {
            for (int i = 0; i < N; i++) {
                for (int j = 0; j < M; j++)
                    copylist[i][j] = list[i][j];
            }
            bfs();
            return;
        }
 
        for (int i = idx; i < M; i++) {
            attacker[cnt] = i;
            func(i + 1, cnt + 1);
        }
    }
 
    static void input() throws Exception {
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        D = Integer.parseInt(st.nextToken());
        list = new int[N][M];
        copylist = new int[N][M];
        attacker = new int[3];
        visit = new boolean[N][M];
        rkill = new int[226][2];
 
        for (int i = 0; i < N; i++) {
            st = new StringTokenizer(br.readLine());
            for (int j = 0; j < M; j++) {
                list[i][j] = Integer.parseInt(st.nextToken());
            }
        }
    }
 
    public static void main(String[] args) throws Exception {
        input();
        func(00);
        System.out.println(ans);
    }
}
cs

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

boj 1525 퍼즐  (0) 2021.02.19
boj 7576 토마토  (0) 2021.02.19
boj 16236 아기 상어  (0) 2021.02.14
boj 10026 적록색약  (0) 2021.02.13
boj 2206 벽 부수고 이동하기  (0) 2021.02.13

www.acmicpc.net/problem/1992

 

1992번: 쿼드트리

첫째 줄에는 영상의 크기를 나타내는 숫자 N 이 주어진다. N 은 언제나 2의 제곱수로 주어지며, 1 ≤ N ≤ 64의 범위를 가진다. 두 번째 줄부터는 길이 N의 문자열이 N개 들어온다. 각 문자열은 0 또

www.acmicpc.net

한 구간에 0과 1로만 이루어져있으면 그 숫자를 출력, 아니면 괄호를 만들고 구간을 1/4로 나눠서 재귀를 돌려야하는 문제입니다.

 

우선 맨 처음 x, y에 들어있는 값을 저장해놓고, 이 값과 구간에 있는 모든 값과 비교해서

모두 같으면 ch 출력

다른게 있으면 인덱스를 이용하여 1/4로 나누었습니다.

여기서 재귀를 4번 돌리기 전에 "("를 출력해주고, 4번의 재귀가 끝나면 ")"를 출력해야합니다.

 

만약 size가 1이면 확인할 필요가 없기때문에 list[x][y]를 바로 출력하고 리턴합니다.

 

 

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
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.io.BufferedReader;
 
public class Main {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st;
    static StringBuffer sb = new StringBuffer();
    static char list[][];
    static int N;
 
    static void func(int size, int x, int y) {
        if (size == 1) {
            sb.append(list[x][y]);
            return;
        }
 
        boolean chk = false;
        char ch = list[x][y];
        for (int i = x; i < x + size; i++) {
            for (int j = y; j < y + size; j++) {
                if (ch != list[i][j]) {
                    chk = true;
                    break;
                }
            }
            if (chk)
                break;
        }
 
        if (chk) {
            sb.append("(");
            func(size / 2, x, y);
            func(size / 2, x, (y + y + size) / 2);
            func(size / 2, (x + x + size) / 2, y);
            func(size / 2, (x + x + size) / 2, (y + y + size) / 2);
            sb.append(")");
        } else {
            sb.append(ch);
        }
    }
 
    static void input() throws Exception {
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        list = new char[N][N];
        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(N, 00);
        System.out.println(sb.toString());
    }
}
cs

'algorithm > Divide-and-Conquer' 카테고리의 다른 글

boj 1074 Z  (0) 2021.02.16

 

www.acmicpc.net/problem/8980

 

8980번: 택배

입력의 첫 줄은 마을 수 N과 트럭의 용량 C가 빈칸을 사이에 두고 주어진다. N은 2이상 2,000이하 정수이고, C는 1이상 10,000이하 정수이다. 다음 줄에, 보내는 박스 정보의 개수 M이 주어진다. M은 1이

www.acmicpc.net

처음에는 보내는 마을 기준으로 오름차순 정렬하였으나, 반례를 만나고 소스를 갈아엎고 받는 마을 기준으로 오름차순 정렬하였습니다.

 

우선 to배열에는 해당 마을을 지날때 최대용량으로 초기화를 시켜놓았습니다.

다음은 예제로 설명을 하겠습니다.

4 40
6
3 4 20
1 2 10
1 3 20
1 4 30
2 3 10
2 4 20

N = 4, C = 40, M = 6

택배 정보를 받는 마을 기준으로 정렬하면 이렇게됩니다. to[1] = 40, to[2] = 40, to[3] = 40

1 2 10
1 3 20
2 3 10
1 4 30
2 4 20
3 4 20

이제 1 -> 2로 10만큼을 보냅니다.

도착마을인 2를 제외하고 1 -> 2 경로에 있는 마을의 남은 용량의 최소는 40으로 10보다 큽니다.

그러면 to[1]에서 10만큼 빼줍니다.

(ans = 10)

to[1] = 30, to[2] = 40, to[3] = 40

 

다음 1 -> 3으로 20만큼 보냅니다.

도착마을인 3을 제외하고 1 -> 3 경로에 있는 마을의 남은 용량의 최소는 30으로 20보다 큽니다.

그러면 to[1]와 to[2]에서 20만큼 빼줍니다.

(ans = 10 + 20 = 30)

to[1] = 10, to[2] = 20, to[3] = 40

 

다음 2 -> 3으로 10만큼 보냅니다.

도착마을인 3을 제외하고 2 -> 3 경로에 있는 마을의 남은 용량의 최소는 20으로 10보다 큽니다.

그러면 to[2]에 10만큼 빼줍니다.

(ans = 30 + 10 = 40)

to[1] = 10, to[2] = 10, to[3] = 40

 

다음 1 -> 4로 30만큼 보냅니다.

도착마을인 4를 제외하고 1 -> 4 경로에 있는 마을의 남은 용량의 최소는 10으로 30보다 작습니다.

따라서 남은 용량의 최소만큼인 10만큼 빼줍니다.

(ans = 40 + 10 = 50)

to[1] = 0, to[2] = 0, to[3] = 40

 

다음 2 -> 4로 20만큼 보냅니다.

도착마을인 4를 제외하고 2 -> 4 경로에 있는 마을의 남은 용량의 최소는 0이므로 보낼 수 없습니다.

(ans = 50)

to[1] = 0, to[2] = 0, to[3] = 40

 

다음 3 -> 4로 20만큼 보냅니다.

도착마을인 4를 제외하고 3 -> 4 경로에 있는 마을의 남은 용량의 최소는 40으로 20보다 큽니다.

그러면 to[3]에 20만큼 빼줍니다.

(ans = 70)

to[1] = 0, to[2] = 0, to[3] = 20

 

과정이 모두 끝났으니 ans를 출력해줍니다.

 

 

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
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.StringTokenizer;
 
public class Main {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st;
    static ArrayList<int[]> list = new ArrayList<>();
    static int to[];
    static int N, C, M, ans;
 
    static void func() {
        for (int i = 0; i < M; i++) {
            int u = list.get(i)[0];
            int v = list.get(i)[1];
            int c = list.get(i)[2];
 
            int maxC = Integer.MAX_VALUE;
            for (int j = u; j < v; j++)
                maxC = Math.min(maxC, to[j]);
 
            if (maxC >= c) {
                for (int j = u; j < v; j++)
                    to[j] -= c;
                ans += c;
            } else {
                for (int j = u; j < v; j++)
                    to[j] -= maxC;
                ans += maxC;
            }
        }
        
        System.out.println(ans);
    }
 
    static void input() throws Exception {
        int u, v, c;
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        C = Integer.parseInt(st.nextToken());
        to = new int[N + 1];
        Arrays.fill(to, C);
 
        st = new StringTokenizer(br.readLine());
        M = Integer.parseInt(st.nextToken());
        for (int i = 0; i < M; i++) {
            st = new StringTokenizer(br.readLine());
            u = Integer.parseInt(st.nextToken());
            v = Integer.parseInt(st.nextToken());
            c = Integer.parseInt(st.nextToken());
            list.add(new int[] { u, v, c });
        }
 
        Collections.sort(list, new Comparator<int[]>() {
            @Override
            public int compare(int[] a, int[] b) {
                if (a[1== b[1])
                    return a[0- b[0];
                else
                    return a[1- b[1];
            }
        });
    }
 
    public static void main(String[] args) throws Exception {
        input();
        func();
    }
}
cs

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

boj 13904 과제  (0) 2021.09.30
boj 1826 연료 채우기  (0) 2021.02.22
boj 11000 강의실 배정  (0) 2021.02.16
boj 1931 회의실 배정  (0) 2021.02.16
boj 2839 설탕 배달  (0) 2021.02.16

www.acmicpc.net/problem/17281

 

17281번: ⚾

⚾는 9명으로 이루어진 두 팀이 공격과 수비를 번갈아 하는 게임이다. 하나의 이닝은 공격과 수비로 이루어져 있고, 총 N이닝 동안 게임을 진행해야 한다. 한 이닝에 3아웃이 발생하면 이닝이 종

www.acmicpc.net

입력으로 이닝 수가 주어지고 다음 줄에는 각 이닝에서 1~9번의 선수들이 공을 쳤을 때 나오는 경우가 주어집니다.

안타 : 1

2루타 : 2

3루타 : 3

홈런 : 4

아웃 : 0

우선 1번이 무조건 4번타자이므로 1번을 제외한 2번~9번까지 브루트포스 방식으로 순열을 구합니다.

저는 cnt가 3이되면 그다음은 무조건 1번선수를 넣었습니다.

 

그 다음 게임을 시작합니다.

g : 이닝 수

t : 현재 타자

out : 아웃 수 (3 out이면 이닝 종료)

x : 현재 타자의 결과

 

저는 ground배열로 1~3루 나가있는 선수를 체크하였고, ground[3]은 점수입니다.

x가 1이면 안타이므로 모두 1칸씩 이동합니다.

x가 2이면 2루타이므로 모두 2칸씩 이동합니다.

x가 3이면 3루타이므로 모두 3칸씩 이동합니다.

x가 4이면 홈런이므로 나가있는 선수들과 본인 포함해서 점수에 더해줍니다.

x가 0이면 아웃이므로 out을 1 늘려주고 만약 out이 3이되면 이닝 종료이므로 ground를 초기화해주고 다음 이닝으로 넘어갑니다.

여기서 이닝이 바뀌어도 현재타자는 계속 유지시켜줘야합니다.

 

위와같은 방식으로 시뮬레이션을 돌려서 max점수를 출력해주시면 됩니다.

 

 

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
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.StringTokenizer;
 
public class Main {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st;
    static ArrayList<Integer> order = new ArrayList<>();
    static boolean visit[];
    static int list[][];
    static int N, ans;
 
    static void game() {
        int ground[] = new int[4];
        int g = 0;
        int t = 0;
        int out = 0;
        while (g < N) {
            int x = list[g][order.get(t)];
 
            if (x == 1) {
                ground[3+= ground[2];
                ground[2= 0;
                ground[2+= ground[1];
                ground[1= 0;
                ground[1+= ground[0];
                ground[0= 1;
            } else if (x == 2) {
                ground[3+= ground[2];
                ground[2= 0;
                ground[3+= ground[1];
                ground[1= 0;
                ground[2+= ground[0];
                ground[1= 1;
                ground[0= 0;
            } else if (x == 3) {
                ground[3+= ground[2];
                ground[3+= ground[1];
                ground[3+= ground[0];
                ground[1= 0;
                ground[0= 0;
                ground[2= 1;
            } else if (x == 4) {
                int sum = 1;
                for (int i = 0; i <= 2; i++) {
                    if (ground[i] == 1) {
                        ground[i] = 0;
                        sum++;
                    }
                }
                ground[3+= sum;
            } else {
                out++;
                if (out == 3) {
                    ground[2= 0;
                    ground[1= 0;
                    ground[0= 0;
                    out = 0;
                    g++;
                }
            }
            t = (t + 1) % 9;
        }
 
        ans = Math.max(ans, ground[3]);
    }
 
    static void func(int cnt) {
        if (cnt == 9) {
            game();
            return;
        }
 
        if (cnt == 3) {
            order.add(0);
            func(4);
            order.remove(cnt);
        }
 
        for (int i = 1; i < 9; i++) {
            if (visit[i])
                continue;
 
            visit[i] = true;
            order.add(i);
            func(cnt + 1);
            order.remove(cnt);
            visit[i] = false;
        }
    }
 
    static void input() throws Exception {
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        list = new int[N][9];
        visit = new boolean[10];
 
        for (int i = 0; i < N; i++) {
            st = new StringTokenizer(br.readLine());
            for (int j = 0; j < 9; j++) {
                list[i][j] = Integer.parseInt(st.nextToken());
            }
        }
    }
 
    public static void main(String[] args) throws Exception {
        input();
        func(0);
        System.out.println(ans);
    }
}
cs

www.acmicpc.net/problem/1074

 

1074번: Z

한수는 크기가 2N × 2N인 2차원 배열을 Z모양으로 탐색하려고 한다. 예를 들어, 2×2배열을 왼쪽 위칸, 오른쪽 위칸, 왼쪽 아래칸, 오른쪽 아래칸 순서대로 방문하면 Z모양이다. 만약, N > 1이 라서

www.acmicpc.net

분할정복으로 해결할 수 있는 문제입니다.

배열을 같은크기로 4등분하여 나눈 구간을 이런식으로 탐색하는데 r행 c열을 방문하는 순서를 출력해야합니다.

저는 4개의 구간을 인덱스를 이용하여

1구간은 (sx, sy) ~ ((sx + ex) / 2, (sy + ey) / 2)

2구간은 (sx, (sy + ey) / 2 + 1) ~ ((sx + ex) / 2, ey)

3구간은 ((sx + ex) / 2 + 1, sy) ~ (ex, (sy + ey) / 2)

4구간은 ((sx + ex) / 2 + 1, (sy + ey) / 2 + 1) ~ (ex, ey)

이렇게 나눴습니다.

 

여기서 나눈 좌표들을 (r, c)와 순서대로 비교하여 각 구간에 포함되어있는지 확인합니다.

1구간에 포함되어있으면 1구간을 탐색

2구간에 포함되어있으면 1구간의 크기만큼 ans에 더해주고 2구간을 탐색

3구간에 포함되어있으면 1, 2구간의 크기만큼 ans에 더해주고 3구간을 탐색

4구간에 포함되어있으면 1, 2, 3구간의 크기만큼 ans에 더해주고 4구간을 탐색합니다.

 

재귀를 돌리다가 size가 1이되면 해당칸에 도착했다는 뜻이니 ans++후에 리턴합니다.

문제에서 순서는 0부터 시작하니 출력은 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
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 boolean chk;
    static int N, r, c, ans;
 
    static void func(int size, int sx, int sy, int ex, int ey) {
        if (size == 1) {
            ans++;
            return;
        }
 
        if (r <= (sx + ex) / 2 && c <= (sy + ey) / 2)
            func(size / 2, sx, sy, (sx + ex) / 2, (sy + ey) / 2);
        else if (r <= (sx + ex) / 2 && c > (sy + ey) / 2) {
            ans += (size / 2 * size / 2);
            func(size / 2, sx, (sy + ey) / 2 + 1, (sx + ex) / 2, ey);
        } else if (r > (sx + ex) / 2 && c <= (sy + ey) / 2) {
            ans += (size / 2 * size / 2 * 2);
            func(size / 2, (sx + ex) / 2 + 1, sy, ex, (sy + ey) / 2);
        } else {
            ans += (size / 2 * size / 2 * 3);
            func(size / 2, (sx + ex) / 2 + 1, (sy + ey) / 2 + 1, ex, ey);
        }
    }
 
    static void input() throws Exception {
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        r = Integer.parseInt(st.nextToken());
        c = Integer.parseInt(st.nextToken());
    }
 
    public static void main(String[] args) throws Exception {
        input();
        int size = (1 << N);
        func(size, 00, size - 1, size - 1);
        System.out.println(ans - 1);
    }
}
cs

'algorithm > Divide-and-Conquer' 카테고리의 다른 글

boj 1992 쿼드트리  (0) 2021.02.17

www.acmicpc.net/problem/11000

 

11000번: 강의실 배정

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

www.acmicpc.net

N개의 수업이 주어지면 강의실을 최소로 사용해서 모든 수업을 해야합니다.

저는 강의 시작시간 기준으로 정렬하였고, 우선순위 큐에 강의 종료시간을 넣었습니다.

 

q.peek()은 현재 진행중인 강의 중 가장 빠르게끝나는 강의이며, 다음 진행할 강의와 비교를 합니다 (x <= list[i][0])

x <= list[i][0]이면 같은 강의실에서 강의를 할 수 있으므로 remove를 해줍니다.

강의는 무조건 해야하므로 마지막에 끝나는 시간을 add 해줍니다.

마지막으로 q의 크기를 출력하시면 됩니다.

 

 

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.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 int list[][];
    static int N;
 
    static void func() {
        PriorityQueue<Integer> q = new PriorityQueue<>();
        q.add(list[0][1]);
        for (int i = 1; i < N; i++) {
            int x = q.peek();
 
            if (x <= list[i][0])
                q.remove();
            q.add(list[i][1]);
        }
 
        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 a[1- b[1];
                else
                    return a[0- b[0];
            }
        });
    }
 
    public static void main(String[] args) throws Exception {
        input();
        func();
    }
}
cs

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

boj 1826 연료 채우기  (0) 2021.02.22
boj 8980 택배  (0) 2021.02.16
boj 1931 회의실 배정  (0) 2021.02.16
boj 2839 설탕 배달  (0) 2021.02.16
boj 11399 ATM  (0) 2021.01.29

+ Recent posts