반응형

문제출처

https://www.acmicpc.net/problem/17144

 

17144번: 미세먼지 안녕!

미세먼지를 제거하기 위해 구사과는 공기청정기를 설치하려고 한다. 공기청정기의 성능을 테스트하기 위해 구사과는 집을 크기가 R×C인 격자판으로 나타냈고, 1×1 크기의 칸으로 나눴다. 구사과는 뛰어난 코딩 실력을 이용해 각 칸 (r, c)에 있는 미세먼지의 양을 실시간으로 모니터링하는 시스템을 개발했다. (r, c)는 r행 c열을 의미한다. 공기청정기는 항상 1번 열에 설치되어 있고, 크기는 두 행을 차지한다. 공기청정기가 설치되어 있지 않은 칸에는 미세먼

www.acmicpc.net

 

문제풀이

그냥 진짜 구현하는 문제다. 빡구현까지는 아니고 배열 조정을 하느라 약간 머리가 아픈 문제

문제에 나온대로 확산과 공기청정기 순환 2가지로 나눠서 구현하면 된다.

 

spreadDust() 메서드

확산은 tempMap배열을 이용해 구현했다. 확산은 queue를 이용해도 될것같다.

확산과 같은 경우 인접한 공간에 숫자가 있는경우 어떻게 처리하는지가 중요하다. 한 공간(y, x)를 기준으로 인접한 공간에 값이 없다면 그냥 4방향으로 확산시켜주면 되지만, 한 방향이라도 있는 경우 다음 탐색을 할때 영향을 주기 때문이다. 즉, 우리는 순차적으로 한 공간(y, x)에 대해 확산시키는 소스를 구현하지만 문제는 한순간에 확산하기 때문에 영향을 받기전의 값으로 확산을 시켜야 한다.

 

1. map을 tempMap에 복사하여 원래의 미세먼지 값들을 저장.

2. 확산될 먼지의 양은 원본map을 통해 계산

3. tempMap에서 먼지를 확산시킴

4. tempMap에서 확산시킨 것들 다시 map으로 옮김.

 

activateAirCleaner() 메서드

이 부분은 공기청정기를 작동시키는 메서드이다. 기존 입력을 받을때 따로 list에 저장해둔 공기청정기의 y좌표를 이용해 map배열의 값을 옮겨주면 된다. 공기청정기에 들어가는 먼지는 없어진다는 조건을 활용해서 없어지는 좌측부터 하나씩 값을 옮겨주었다. 여기서 주의할 점은 공기청정기가 위치한 y좌표의 x축을 이동시킬때 모두 이동시키고 공기청정기 다음x좌표를 0으로 다시 갱신해줘야 한다는 것이다.

 

소스코드

https://github.com/sw93/algorithm/blob/master/SW_TEST(samsung)/BOJ_17144/boj17144.java

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.StringTokenizer;

public class Main {
    private static int r, c, t;
    private static int dy[] = {0, -1, 0, 1};
    private static int dx[] = {1, 0, -1, 0};
    private static int map[][];
    private static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    private static StringTokenizer st;
    private static ArrayList<Integer> cleaner;

    public static void main(String[] args) throws Exception {
        init();
        while (true) {
            t--;
            spreadDust();
            activateAirCleaner();

            if (t == 0) {
                System.out.println(countDustVolumn());
                break;
            }
        }
    }

    private static int countDustVolumn() {
        int ret = 0;
        for (int y=0; y<r; y++) {
            for (int x=0; x<c; x++) {
                if (map[y][x] != 0 && map[y][x] != -1) ret += map[y][x];
            }
        }
        return ret;
    }

    private static void copyMap(int src[][], int dest[][]) {
        for (int y=0; y<r; y++) {
            for (int x=0; x<c; x++) {
                dest[y][x] = src[y][x];
            }
        }
    }

    private static void activateAirCleaner() {
        int upY = cleaner.get(0);
        int downY = cleaner.get(1);

        // 위쪽
        for (int y=upY-1; y>0; y--) {
            map[y][0] = map[y-1][0];
        }
        for (int x=0; x<c-1; x++) {
            map[0][x] = map[0][x+1];
        }
        for (int y=0; y<upY; y++) {
            map[y][c-1] = map[y+1][c-1];
        }
        for (int x=c-1; x>0; x--) {
            map[upY][x] = map[upY][x-1];
        }
        map[upY][1] = 0;

        // 아래쪽
        for (int y=downY+1; y<r-1; y++) {
            map[y][0] = map[y+1][0];
        }
        for (int x=0; x<c-1; x++) {
            map[r-1][x] = map[r-1][x+1];
        }
        for (int y=r-1; y>=downY; y--) {
            map[y][c-1] = map[y-1][c-1];
        }
        for (int x=c-1; x>1; x--) {
            map[downY][x] = map[downY][x-1];
        }
        map[downY][1] = 0;
    }

    private static void spreadDust() {
        int tempMap[][] = new int[r][c];
        copyMap(map, tempMap);

        for (int y=0; y<r; y++) {
            for (int x=0; x<c; x++) {
                if (map[y][x] != 0 && map[y][x] != -1) {
                    int count = 0;
                    int dust = map[y][x] / 5;
                    for (int i=0; i<4; i++) {
                        int ny = y+dy[i];
                        int nx = x+dx[i];

                        if (ny<0 || nx<0 || ny>=r || nx>=c || map[ny][nx] == -1) continue;
                        tempMap[ny][nx] += dust;
                        count++;
                    }
                    tempMap[y][x] -= (count * dust);
                }
            }
        }
        copyMap(tempMap, map);
    }

    private static void init() throws Exception {
        st = new StringTokenizer(br.readLine());
        r = Integer.parseInt(st.nextToken());
        c = Integer.parseInt(st.nextToken());
        t = Integer.parseInt(st.nextToken());
        map = new int[r][c];
        cleaner = new ArrayList<>();

        for (int y=0; y<r; y++) {
            st = new StringTokenizer(br.readLine(), " ");
            for (int x=0; x<c; x++) {
                map[y][x] = Integer.parseInt(st.nextToken());
                if (map[y][x] == -1) cleaner.add(y);
            }
        }
    }
}

 

반응형

'Algorithm' 카테고리의 다른 글

[프로그래머스 17681 - 카카오 2018 1차] 비밀지도  (2) 2020.04.29
[BOJ 16234] 인구 이동  (0) 2020.04.27
[BOJ 14500] 테트노미로  (0) 2020.04.24
[BOJ 10819] 차이를 최대로  (0) 2020.04.21
[BOJ 16236] 아기상어  (0) 2020.04.21
반응형

문제출처

https://www.acmicpc.net/problem/14500

 

14500번: 테트로미노

폴리오미노란 크기가 1×1인 정사각형을 여러 개 이어서 붙인 도형이며, 다음과 같은 조건을 만족해야 한다. 정사각형은 서로 겹치면 안 된다. 도형은 모두 연결되어 있어야 한다. 정사각형의 변끼리 연결되어 있어야 한다. 즉, 꼭짓점과 꼭짓점만 맞닿아 있으면 안 된다. 정사각형 4개를 이어 붙인 폴리오미노는 테트로미노라고 하며, 다음과 같은 5가지가 있다. 아름이는 크기가 N×M인 종이 위에 테트로미노 하나를 놓으려고 한다. 종이는 1×1 크기의 칸으로 나누

www.acmicpc.net

 

문제풀이

N x M 배열에 테트리스 도형들을 적절히 회전하여 1개를 놓았을때 놓인 칸들의 최대 합을 구하는 문제입니다.

삼성 기출문제답게 map위에서 동,북,서,남 방향으로 탐색해서 풀이하면 될것이라 생각했지만 'ㅜ'모양은 기존 dfs와 다른 방식으로 탐색해야했습니다.

'ㅜ' 모양을 탐색하는 제 아이디어는 다음과 같습니다.

 

1. 해당 위치를 기준으로 동,북,서,남 방향 모두 탐색하며 map에 저장된 값들을 더한다.

2. 탐색 시 매번 map의 최소값을 구한다.

3. 모두 탐색한 뒤 최소값을 빼준다.

즉, 현재위치 + 4방향 - 4방향중 최소값으로 'ㅜ'모양을 탐색했습니다.

+ 모양으로 탐색한 뒤 가장 최소값을 빼주면 'ㅜ'의 회전체 모양이 나오기 때문입니다.

 

소스코드

https://github.com/sw93/algorithm/blob/master/SW_TEST(samsung)/BOJ_14500/boj14500.java

 

sw93/algorithm

problem solve. Contribute to sw93/algorithm development by creating an account on GitHub.

github.com

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
    private static int n, m, ans=0;
    private static int dy[] = {0, -1, 0, 1};
    private static int dx[] = {1, 0, -1, 0};
    private static int map[][];
    private static boolean visit[][];

    public static void main(String[] args) throws Exception {
        init();
        for (int y=0; y<n; y++) {
            for (int x=0; x<m; x++) {
                dfs(y, x, 0, 0);
                checkException(y, x);
            }
        }
        System.out.println(ans);
    }

    private static void dfs(int y, int x, int sum, int count) {
        if (count == 4) {
            ans = Math.max(ans, sum);
            return;
        }

        for (int i=0; i<4; i++) {
            int ny = y+dy[i];
            int nx = x+dx[i];
            if (ny<0 || nx<0 || ny>=n || nx>=m || visit[ny][nx]) continue;
            visit[ny][nx] = true;
            dfs(ny, nx, sum+map[ny][nx], count+1);
            visit[ny][nx] = false;
        }
    }

    private static void checkException(int y, int x) {
        int sum = map[y][x];
        int count = 1;
        int min = 987654321;

        for (int i=0; i<4; i++) {
            int ny = y+dy[i];
            int nx = x+dx[i];
            if (ny<0 || nx<0 || ny>=n || nx>=m) continue;
            sum += map[ny][nx];
            min = Math.min(min, map[ny][nx]);
            count++;
        }

        if (count == 5) {
            sum -= min;
        }
        ans = Math.max(ans, sum);
    }

    private static void init() 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());
        map = new int[n][m];
        visit = new boolean[n][m];

        for (int y = 0; y < n; y++) {
            st = new StringTokenizer(br.readLine());
            for (int x = 0; x < m; x++) {
                map[y][x] = Integer.parseInt(st.nextToken());
            }
        }
    }
}
반응형

'Algorithm' 카테고리의 다른 글

[BOJ 16234] 인구 이동  (0) 2020.04.27
[BOJ 17144] 미세먼지 안녕!  (0) 2020.04.24
[BOJ 10819] 차이를 최대로  (0) 2020.04.21
[BOJ 16236] 아기상어  (0) 2020.04.21
[BOJ 15683] 감시  (0) 2020.04.20
반응형

문제 출처

https://www.acmicpc.net/problem/10819

 

10819번: 차이를 최대로

첫째 줄에 N (3 ≤ N ≤ 8)이 주어진다. 둘째 줄에는 배열 A에 들어있는 정수가 주어진다. 배열에 들어있는 정수는 -100보다 크거나 같고, 100보다 작거나 같다.

www.acmicpc.net

 

문제 풀이

next_permutation을 사용해 다음 순열을 구하고 차이값을 계속 갱신해서 최대값을 구한다.

 

소스코드

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int calc(vector<int>& v) {
    int sum = 0;
    for (int i = 1; i < v.size(); i++) {
        sum += abs(v[i] - v[i - 1]);
    }
    return sum;
}
int main() {
    ios_base::sync_with_stdio(0); cin.tie(0);
    int n;
    cin >> n;
    vector<int> v(n);
    for (int i = 0; i < n; i++) cin >> v[i];
    sort(v.begin(), v.end());
    int ans = 0;
    do {
        int tmp = calc(v);
        ans = max(ans, tmp);
    } while (next_permutation(v.begin(), v.end()));
    cout << ans << "\n";
    return 0;
}
반응형

'Algorithm' 카테고리의 다른 글

[BOJ 17144] 미세먼지 안녕!  (0) 2020.04.24
[BOJ 14500] 테트노미로  (0) 2020.04.24
[BOJ 16236] 아기상어  (0) 2020.04.21
[BOJ 15683] 감시  (0) 2020.04.20
[BOJ 17140] 이차원 배열과 연산  (0) 2020.04.17
반응형

문제출처

https://www.acmicpc.net/problem/16236

 

문제풀이

BFS로 풀이했다. 일반적인 BFS와 다르게 먹이를 찾으면 더이상 탐색을 하지 않는게 포인트였다. 처음 입력을 받을때 아기상어의 위치를 구조체에 저장하고 map에는 0으로 저장해 조건탐색을 쉽게 할 수 있었다.

이 문제도 na982님 강의를 보고 구현했다. 점점 난이도가 올라가는데 혼자 풀수있도록 구현방법들을 잘 익혀둬야겠다.

 

소스코드

#include <iostream>
#include <queue>
using namespace std;
struct SHARK {
	int y, x, time;
};
SHARK shark;
int n, sharkSize, eatCount;
const int dy[] = { -1, 1, 0, 0 };
const int dx[] = { 0, 0, -1, 1 };
int map[20][20];
void init() {
	cin >> n;
	for (int y = 0; y < n; y++) {
		for (int x = 0; x < n; x++) {
			cin >> map[y][x];
			if (map[y][x] == 9) {
				shark.y = y, shark.x = x, shark.time = 0;
				sharkSize = 2, eatCount = 0;
				map[y][x] = 0;
			}
		}
	}
}
void bfs() {
	bool existFood = 1;
	while (existFood) {
		existFood = 0;
		bool visit[20][20] = { 0 };
		queue<SHARK> q;
		q.push(shark);
		visit[shark.y][shark.x] = 1;

		SHARK nextFood;	// 다음 먹이 정보
		nextFood.y = 20;
		nextFood.time = -1;
		while (!q.empty()) {

			// 탐색 현재 위치
			SHARK cur = q.front();
			q.pop();
			
			// 먹이를 찾은경우
			if (map[cur.y][cur.x] != 0 && map[cur.y][cur.x] < sharkSize) {
				existFood = 1;

				// 새로 찾은 먹이의 좌표가 위쪽이거나 왼쪽에 있는경우
				if (cur.y < nextFood.y || (cur.y == nextFood.y && cur.x < nextFood.x)) {
					nextFood = cur;
				}
			}

			// 다음 먹이의 위치를 찾은 경우 탐색 중단
			if (nextFood.time != -1 && cur.time > nextFood.time) break;

			// 4방향 탐색
			for (int i = 0; i < 4; i++) {
				int ny = cur.y + dy[i];
				int nx = cur.x + dx[i];
				int time = cur.time + 1;
				if (ny < 0 || nx < 0 || ny >= n || nx >= n || visit[ny][nx]) continue;
				if (map[ny][nx] > sharkSize) continue;
				visit[ny][nx] = 1;
				q.push({ ny,nx, time });
			}
		}

		// 탐색 종료후 먹이를 찾은경우
		if (existFood) {
			eatCount++;
			shark = nextFood;
			if (sharkSize == eatCount) {
				sharkSize++;
				eatCount = 0;
			}
			map[shark.y][shark.x] = 0;
		}
	}
}
int main() {
	ios_base::sync_with_stdio(0); cin.tie(0);
	init();
	bfs();
	cout << shark.time;
	return 0;
}
반응형

'Algorithm' 카테고리의 다른 글

[BOJ 14500] 테트노미로  (0) 2020.04.24
[BOJ 10819] 차이를 최대로  (0) 2020.04.21
[BOJ 15683] 감시  (0) 2020.04.20
[BOJ 17140] 이차원 배열과 연산  (0) 2020.04.17
[BOJ 15685] 드래곤 커브  (0) 2020.04.13
반응형

문제출처

https://www.acmicpc.net/problem/15683

 

문제풀이

8대의 카메라가 4방향 모두 탐색하는 경우가 총 64개의 공간에서 일어날 수 있으므로 이 문제의 시간복잡도는 대략 4^8*64이므로 완전탐색으로 1초안에 풀이 가능하다.

입력을 받을때 cctv의 타입과 좌표를 따로 저장하고 dfs로 완전탐색해서 풀이했다. 처음에 어떻게 탐색을 해야하는지 고생을 했는데 1시간동안 탐색방법이 떠오르지 않아 na982님의 풀이를 확인하고 문제풀이를 했다. 그러다보니 na982님 풀이에 생각이 박혀서 다시 풀어도 같은 소스코드가 나왔다. 이 풀이에서 4방향 탐색을 할때 하나의 함수를 만들어 안에서 분기처리 하는 방법이 매우 마음에 들었다. 비록 이 문제는 내가 처음부터 끝까지 풀지는 못했으나 좋은 아이디어를 얻는 계기가 된듯 하다.

풀이방법은 https://na982.tistory.com/95 여기를 참조하자. 정말 잘 설명해주시는듯 ㅠㅠ

 

소스코드

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
struct CCTV {
	int type, y, x;
};
int n, m, ans = 987654321;
const int rotateCount[] = { 4,2,4,4,1 };
int map[8][8];
vector<CCTV> cctv;
void init() {
	cin >> n >> m;
	for (int y = 0; y < n; y++) {
		for (int x = 0; x < m; x++) {
			cin >> map[y][x];
			if (map[y][x] != 0 && map[y][x] != 6) {
				cctv.push_back({ map[y][x], y, x });
			}
		}
	}
}
void copyMap(int src[8][8], int desc[8][8]) {
	for (int y = 0; y < n; y++) {
		for (int x = 0; x < m; x++) {
			desc[y][x] = src[y][x];
		}
	}
}
void rotateCamera(int dir, CCTV cctv) {
	dir %= 4;

	if (dir == 0) {
		for (int x = cctv.x + 1; x < m; x++) {
			if (map[cctv.y][x] == 6) break;
			map[cctv.y][x] = -1;
		}
	} else if (dir == 1) {
		for (int y = cctv.y - 1; y >= 0; y--) {
			if (map[y][cctv.x] == 6) break;
			map[y][cctv.x] = -1;
		}
	} else if (dir == 2) {
		for (int x = cctv.x - 1; x >= 0; x--) {
			if (map[cctv.y][x] == 6) break;
			map[cctv.y][x] = -1;
		}
	} else if (dir == 3) {
		for (int y = cctv.y + 1; y < n; y++) {
			if (map[y][cctv.x] == 6) break;
			map[y][cctv.x] = -1;
		}
	}
}
void dfs(int index) {
	if (index == cctv.size()) {
		int safeArea = 0;
		for (int y = 0; y < n; y++) {
			for (int x = 0; x < m; x++) {
				if (map[y][x] == 0) safeArea++;
			}
		}
		ans = min(ans, safeArea);
		return;
	}
	int type = cctv[index].type;
	int backup[8][8] = { 0, };
	for (int i = 0; i < rotateCount[type-1]; i++) {
		copyMap(map, backup);
		if (type == 1) {
			rotateCamera(i, cctv[index]);
		} else if (type == 2) {
			rotateCamera(i, cctv[index]);
			rotateCamera(i + 2, cctv[index]);
		} else if (type == 3) {
			rotateCamera(i, cctv[index]);
			rotateCamera(i + 1, cctv[index]);
		} else if (type == 4) {
			rotateCamera(i, cctv[index]);
			rotateCamera(i + 1, cctv[index]);
			rotateCamera(i + 2, cctv[index]);
		} else if (type == 5) {
			rotateCamera(i, cctv[index]);
			rotateCamera(i + 1, cctv[index]);
			rotateCamera(i + 2, cctv[index]);
			rotateCamera(i + 3, cctv[index]);
		}
		dfs(index + 1);
		copyMap(backup, map);
	}

}
int main() {
	ios_base::sync_with_stdio(0); cin.tie(0);
	init();
	dfs(0);
	cout << ans << "\n";
	return 0;
}
반응형

'Algorithm' 카테고리의 다른 글

[BOJ 10819] 차이를 최대로  (0) 2020.04.21
[BOJ 16236] 아기상어  (0) 2020.04.21
[BOJ 17140] 이차원 배열과 연산  (0) 2020.04.17
[BOJ 15685] 드래곤 커브  (0) 2020.04.13
[BOJ 17142] 연구소3  (0) 2020.04.12
반응형

문제출처

https://www.acmicpc.net/problem/17140

 

17140번: 이차원 배열과 연산

첫째 줄에 r, c, k가 주어진다. (1 ≤ r, c, k ≤ 100) 둘째 줄부터 3개의 줄에 배열 A에 들어있는 수가 주어진다. 배열 A에 들어있는 수는 100보다 작거나 같은 자연수이다.

www.acmicpc.net

 

문제풀이

R연산과 C연산을 반복하여 a[r][c]의 값이 k가 몇번째에 나오는지 출력하는 문제입니다. (100번 이상 연산이 필요할 시 -1 출력)

R연산과 C연산은 row기준인지 column기준인지에 따라 방향만 바뀌므로 R연산 기준으로 풀이하겠습니다.

코딩하기 전에 제가 생각한 알고리즘은 다음과 같습니다.

 

1. rowSize와 columnSize를 통해 R연산 C연산 구분

2. 100번 초과시 프로그램 종료

-- 연산로직

3. 함수 호출마다 새로운 사이즈가 결정된다. 때문에 R연산은 newColSize에 갱신하여 전역변수인 colSize를 갱신한다.

4. 새로운 행마다 열에 대해 어떤 숫자가 몇개 있는지 카운팅한다.

4-1) 카운팅한 숫자를 0을 제외하고 벡터에 카운팅한 개수와 해당 숫자를 넣어준다. 이때 pair를 sorting할 때 first값을 기준으로 정렬되는 특징을 활용해 카운팅한 개수를 first에 저장한다.

4-2) vector는 pair이기 때문에 새로 등록할 크기는 vector사이즈의 2배이다. 모든 행에 대해 실행할 때마다 큰 값을 newColSize에 저장한다.

4-3) vector를 순회하면서 a배열을 갱신해주고 사이즈가 줄어들 경우 0으로 저장한다.

 

이 문제는 단순 구현만 해주면 되는 문제입니다. 때문에 생각을 위와 같이 하나씩 정리한 뒤 소스를 작성하는게 좋습니다. 특히 이 문제에서는 rowSize와 colSize가 계속 늘어났다 줄어들기 때문에 이 처리를 잘 해줘야 하며 sorting시 사용자 함수를 사용하던지 first값 기준으로 정렬되는 특징을 사용할 수 있어야 합니다. 아무래도 시뮬레이션 문제는 직접 손으로 그려보고 문제를 파악한뒤 로직을 어떻게 구현할 것인지 먼저 구상하는게 문제풀이에서 가장 중요한 것 같습니다.

 

소스코드

https://github.com/sw93/algorithm/blob/master/SW_TEST(samsung)/BOJ_17140/BOJ_17140/boj17140.cpp

 

sw93/algorithm

problem solve. Contribute to sw93/algorithm development by creating an account on GitHub.

github.com

#include <iostream>
#include <vector>
#include <cstring>
#include <algorithm>
using namespace std;
int r, c, k, rowSize = 3, colSize = 3;
int a[100][100];
int numberCount[101];
void init() {
	cin >> r >> c >> k;
	r--, c--;
	for (int y = 0; y < 3; y++) {
		for (int x = 0; x < 3; x++) {
			cin >> a[y][x];
		}
	}
}
void rCalc() {
	int newColSize = 0;

	for (int y = 0; y < rowSize; y++) {
		memset(numberCount, 0, sizeof(numberCount));
		vector<pair<int, int> > v;
		for (int x = 0; x < colSize; x++) numberCount[a[y][x]]++;

		for (int i = 1; i <= 100; i++) {
			if (numberCount[i] == 0) continue;
			v.push_back(make_pair(numberCount[i], i));
		}
		
		sort(v.begin(), v.end());
		int curColSize = v.size() * 2;
		newColSize = max(newColSize, curColSize);

		int xIndex = 0;
		for (vector<pair<int, int>>::iterator it = v.begin(); it != v.end(); it++) {
			a[y][xIndex] = it->second;
			a[y][xIndex + 1] = it->first;
			xIndex += 2;
		}
		for (int x = curColSize; x < colSize; x++) a[y][x] = 0;
		
	}
	colSize = newColSize;
}
void cCalc() {
	int newRowSize = 0;
	
	for (int x = 0; x < colSize; x++) {
		memset(numberCount, 0, sizeof(numberCount));
		vector<pair<int, int> > v;
		for (int y = 0; y < rowSize; y++) numberCount[a[y][x]]++;

		for (int i = 1; i <= 100; i++) {
			if (numberCount[i] == 0) continue;
			v.push_back(make_pair(numberCount[i], i));
		}

		sort(v.begin(), v.end());
		int curRowSize = v.size() * 2;
		newRowSize = max(newRowSize, curRowSize);

		int yIndex = 0;
		for (vector<pair<int, int>>::iterator it = v.begin(); it != v.end(); it++) {
			a[yIndex][x] = it->second;
			a[yIndex + 1][x] = it->first;
			yIndex += 2;
		}
		for (int y = curRowSize; y < rowSize; y++) a[y][x] = 0;
	}
	rowSize = newRowSize;
}
void solve() {
	int ans = 0;
	while (1) {
		if (ans > 100) {
			cout << -1 << "\n";
			break;
		} else if (a[r][c] == k) {
			cout << ans << "\n";
			break;
		}
		if (rowSize >= colSize) rCalc();
		else cCalc();
		ans++;
	}
}
int main() {
	ios_base::sync_with_stdio(0); cin.tie(0);
	init();
	solve();
	return 0;
}
반응형

'Algorithm' 카테고리의 다른 글

[BOJ 16236] 아기상어  (0) 2020.04.21
[BOJ 15683] 감시  (0) 2020.04.20
[BOJ 15685] 드래곤 커브  (0) 2020.04.13
[BOJ 17142] 연구소3  (0) 2020.04.12
[BOJ 14888] 연산자 끼워넣기  (0) 2020.01.02
반응형

문제출처

https://www.acmicpc.net/problem/15685

 

15685번: 드래곤 커브

첫째 줄에 드래곤 커브의 개수 N(1 ≤ N ≤ 20)이 주어진다. 둘째 줄부터 N개의 줄에는 드래곤 커브의 정보가 주어진다. 드래곤 커브의 정보는 네 정수 x, y, d, g로 이루어져 있다. x와 y는 드래곤 커브의 시작 점, d는 시작 방향, g는 세대이다. (0 ≤ x, y ≤ 100, 0 ≤ d ≤ 3, 0 ≤ g ≤ 10) 입력으로 주어지는 드래곤 커브는 격자 밖으로 벗어나지 않는다. 드래곤 커브는 서로 겹칠 수 있다. 방향은 0, 1, 2,

www.acmicpc.net

 

문제풀이

정말 어려웠던 문제였다. 문제풀이의 핵심은 세대가 증가할 때 마다 방향전환의 규칙성을 찾는것이 핵심이다.

0 (동쪽)방향을 기준으로 예시를 들어보면 이해하는데 조금 더 편하다.

 

0세대 : 0

1세대 : 0 1

2세대 : 0 1 | 2 1

3세대 : 0 1 2 1 | 2 3 2 1

4세대 : 0 1 2 1 2 3 2 1 | 2 3 0 3 2 3 2 1

 

예시를 보면 알 수 있듯이 1세대에서 2세대의 방향정보를 만드는 규칙은 마지막 부분 +1을 추가하는 것이다. 2세대에서 3세대를 만들때도 같은 규칙을 사용한다. 하지만 +1을 계속하면 {0,1,2,3}의 인덱스가 깨지므로 +1한 값의 %4를 해주면 해당 세대의 방향정보를 알 수 있다.

 

그다음부터는 정말 단순한 구현이다. 이때 문제에서는 꼭지점을 기준으로 드래곤 커브를 그리고 있다. 이 기준을 단순 2차원 배열로 바꾸어 계산해 주면 된다. 2차원 배열에 표현하기 때문에 (x,y) <= 100인 조건은 (x,y) <= 101로 변환하여 풀이한다.

개인적으로 저 규칙을 알아내는것이 매우 힘들었다. 시간이 지나고 다시 풀어봐야 겠다.

 

소스코드

https://github.com/sw93/algorithm/blob/master/SW_TEST(samsung)/BOJ_15685/BOJ_15685/boj15685.cpp

 

sw93/algorithm

problem solve. Contribute to sw93/algorithm development by creating an account on GitHub.

github.com

#include <iostream>
#include <vector>
using namespace std;
const int MAX = 101;
const int dy[] = { 0, -1, 0, 1 };
const int dx[] = { 1, 0, -1, 0 };
int n, y, x, d, g;
int map[MAX][MAX];
int solve() {
	cin >> n;
	while (n--) {
		cin >> x >> y >> d >> g;
		vector<int> dir;
		dir.push_back(d);
		map[y][x] = 1;
		for (int i = 0; i < g; i++) {
			int dirSize = dir.size();
			for (int j = dirSize - 1; j >= 0; j--) {
				dir.push_back((dir[j] + 1) % 4);
			}
		}
		for (int i = 0; i < dir.size(); i++) {
			y += dy[dir[i]];
			x += dx[dir[i]];
			if (y < 0 || x < 0 || y >= MAX || x >= MAX) continue;
			map[y][x] = 1;
		}
	}
	int ret = 0;
	for (int r = 0; r < MAX - 1; r++) {
		for (int c = 0; c < MAX - 1; c++) {
			if (map[r][c] == 1 && map[r + 1][c] == 1 && map[r][c + 1] == 1 && map[r + 1][c + 1] == 1) {
				ret++;
			}
		}
	}
	return ret;
}
int main() {
	ios_base::sync_with_stdio(0); cin.tie(0);
	cout<<solve();
	return 0;
}
반응형

'Algorithm' 카테고리의 다른 글

[BOJ 15683] 감시  (0) 2020.04.20
[BOJ 17140] 이차원 배열과 연산  (0) 2020.04.17
[BOJ 17142] 연구소3  (0) 2020.04.12
[BOJ 14888] 연산자 끼워넣기  (0) 2020.01.02
[BOJ 9021] 괄호  (0) 2019.12.18
반응형

문제출처

https://www.acmicpc.net/problem/17142

 

17142번: 연구소 3

인체에 치명적인 바이러스를 연구하던 연구소에 승원이가 침입했고, 바이러스를 유출하려고 한다. 바이러스는 활성 상태와 비활성 상태가 있다. 가장 처음에 모든 바이러스는 비활성 상태이고, 활성 상태인 바이러스는 상하좌우로 인접한 모든 빈 칸으로 동시에 복제되며, 1초가 걸린다. 승원이는 연구소의 바이러스 M개를 활성 상태로 변경하려고 한다. 연구소는 크기가 N×N인 정사각형으로 나타낼 수 있으며, 정사각형은 1×1 크기의 정사각형으로 나누어져 있다. 연구소는

www.acmicpc.net

 

문제풀이

연구소에 이어 조금 예외가 추가된 문제이다. 기본적으로는 완전탐색을 통해 풀면 된다 생각되었다.

소스코드 작성에 앞서 문제 풀이 방법은 다음과 같이 생각해봤다.

1. 활성화할 바이러스를 선택한다(selectVirus)

- 선택한 바이러스가 m개라면 바이러스를 퍼트린다.

2. 바이러스를 퍼뜨릴때 모든 경우를 다 사용해야 하기 때문에 새로운 2차원 배열을 생성한다.

- 활성화할 바이러스를 큐에 담는다.

- 문제에서 제시한 조건을 따라 벽이거나 이미 바이러스가 전파된 경우를 제외하고 바이러스를 전파한다.

3. 활성화된 바이러스로 퍼지는데 걸리는 시간을 구한다.

- 이때 입력으로 받은 map이 빈칸이고 새로운 timeMap이 초기 값이라면 바이러스가 완전히 퍼지지 않은것으로 판단한다.

- 활성화된 바이러스는 제외해야하기 때문에 map이 0인 것만 카운팅한다.

4. 이후 return 받은 결과값이 최대값과 같다면 바이러스를 모든 빈 칸에 전파할 수 없는 경우이므로 -1을 출력하고 이외의 경우 최소값을 출력한다.

 

생각보다 시간이 많이 걸렸다. 처음 90%대에서 자꾸 틀렸습니다가 나왔는데 활성화된 바이러스를 제외하지 않아서 였다. 백준 게시판의 반례모음집을 보고 어디서 잘못됬는지 파악할 수 있었다.

소스 작성전에 예외없이 알고리즘을 짤 수 있도록 습관을 더 길러야겠다.

 

소스코드

#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
#include <cstring>
using namespace std;
// 2020/04/12 14:55 문제풀이 시작 -> 16:40 문제풀이 완료
struct VIRUS {
    int y, x;
};
bool isAllSpread;
int n, m, ans=987654321;
int dy[] = {0, 0, 1, -1};
int dx[] = {1, -1, 0, 0};
int map[50][50];
vector<VIRUS> virus, selected;
void init() {
    cin>>n>>m;
    for (int y=0; y<n; y++) {
        for (int x=0; x<n; x++) {
            cin>>map[y][x];
            if (map[y][x] == 2) virus.push_back({y,x});
        }
    }
}
int spreadVirus() {
    isAllSpread = 1;
    queue<VIRUS> q;
    int timeMap[50][50];
    memset(timeMap, -1, sizeof(timeMap));

    for (int i=0; i<selected.size(); i++)  {
        q.push(selected[i]);
        timeMap[selected[i].y][selected[i].x] = 0;
    }

    while (!q.empty()) {
        int y = q.front().y;
        int x = q.front().x;
        q.pop();

        for (int i=0; i<4; i++) {
            int ny=y+dy[i];
            int nx=x+dx[i];

            // out of bound
            if (ny<0 || nx<0 || ny>=n || nx>=n) continue;

            // 벽 or 이미 바이러스 퍼진 경우
            if (map[ny][nx] == 1 || timeMap[ny][nx] != -1) continue;

            q.push({ny, nx});
            timeMap[ny][nx] = timeMap[y][x] + 1;
        }
    }

    int time=0;
    for (int y=0; y<n; y++) {
        for (int x=0; x<n; x++) {

            // 전부 전파하지 못한 경우
            if (map[y][x] == 0 && timeMap[y][x] == -1) {
                isAllSpread=0;
                return 987654321;
            }
            // 활성화 하지 않은 바이러스는 제외
            else if (map[y][x] == 0) {
                time = max(time, timeMap[y][x]);
            }
        }
    }
    return time;
}
void selectVirus(int index) {
    if (selected.size() == m) {
        int time = spreadVirus();
        if (isAllSpread) ans = min(ans, time);

        return;
    }

    for (int i=index; i<virus.size(); i++) {
        selected.push_back(virus[i]);
        selectVirus(i+1);
        selected.pop_back();
    }
}
int main() {
    ios_base::sync_with_stdio(0); cin.tie(0);
    init();
    selectVirus(0);
    if (ans == 987654321) cout<<"-1"<<"\n";
    else cout<<ans<<"\n";
    return 0;
}

 

반응형

'Algorithm' 카테고리의 다른 글

[BOJ 17140] 이차원 배열과 연산  (0) 2020.04.17
[BOJ 15685] 드래곤 커브  (0) 2020.04.13
[BOJ 14888] 연산자 끼워넣기  (0) 2020.01.02
[BOJ 9021] 괄호  (0) 2019.12.18
[BOJ 1874] 스택 수열  (0) 2019.12.17
반응형

문제출처

https://www.acmicpc.net/problem/14888

 

문제풀이

 재귀함수를 이용한 완전탐색 문제입니다. n의 최대값이 11이므로 완전탐색이 가능하다고 판단되어 완전탐색으로 풀이하였습니다.

숫자 순서는 변하지 않고 연산자 우선순위도 적용되지 않기 때문에 현재까지 계산한 값과 연산자를 통한 계산을 해주면 되는 문제입니다. 처음에 최대값, 최소값을 0xfffffff으로 초기화 했는데 틀렸습니다가 나왔다. 문제를 잘 읽어보면 최댓값과 최솟값이 항상 -10억보다 크거나 같고, 10억보다 작거나 같은 결과가 나오는 입력만 주어진다. 라는 문구를 보아 10억으로 초기화 해서 해결했습니다.

 저같은 실수를 하신 분들을 위해 반례 하나 적어두겠습니다.

5

100 100 100 100 10

0 0 4 0

 

소스코드

#include <iostream>
using namespace std;
int n, mx=-1000000000, mn=1000000000;
int a[100], oper[4];

void solve(int curSum, int depth) {
    if (depth == n) {
        mx = curSum > mx ? curSum : mx;
        mn = curSum > mn ? mn : curSum;
        return;
    }

    if (oper[0] > 0) {
        oper[0]--;
        solve(curSum + a[depth], depth+1);
        oper[0]++;
    }
    if (oper[1] > 0) {
        oper[1]--;
        solve(curSum - a[depth], depth+1);
        oper[1]++;
    }
    if (oper[2] > 0) {
        oper[2]--;
        solve(curSum * a[depth], depth+1);
        oper[2]++;
    }
    if (oper[3] > 0) {
        oper[3]--;
        solve(curSum / a[depth], depth+1);
        oper[3]++;
    }
}

void init() {
    cin>>n;
    for (int i=0; i<n; i++) cin>>a[i];
    for (int i=0; i<4; i++) cin>>oper[i];
    solve(a[0], 1);
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    init();
    cout<<mx<<"\n"<<mn<<"\n";
    return 0;
}
반응형

'Algorithm' 카테고리의 다른 글

[BOJ 15685] 드래곤 커브  (0) 2020.04.13
[BOJ 17142] 연구소3  (0) 2020.04.12
[BOJ 9021] 괄호  (0) 2019.12.18
[BOJ 1874] 스택 수열  (0) 2019.12.17
[BOJ 15649] N과 M(1)  (0) 2019.10.30
반응형

문제 출처

https://www.acmicpc.net/problem/9012

 

문제 풀이

문자열을 확인하면서 "("인 경우 stack에 push

만약 문자열이 ")"이고 stack이 비어있다면 VPS가 아니라고 판단.

stack이 비어있지 않다면 top에 "("인지 확인한뒤 pop

모든 문자열을 확인한 뒤 stack이 비어있다면 VPS 비어있지 않으면 VPS가 아니라고 판단할 수 있다.

이 문제는 stack이 아닌 카운팅하면서 문제를 풀 수도 있으며 두가지 방법 모두 O(N)의 복잡도를 가진다.

 

소스 코드

//
//  main.cpp
//  BOJ_9012
//
//  Created by sw on 18/12/2019.
//  Copyright © 2019 seungwoo. All rights reserved.
//

#include <iostream>
#include <stack>

using namespace std;
int main(int argc, const char * argv[]) {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    
    int t;
    cin>>t;
    
    while (t--) {
        string input;
        cin>>input;
        stack<char> st;
        
        for (int i=0; i<input.size(); i++) {
            if (input[i] == '(') {
                st.push(input[i]);
            } else {
                if (!st.empty() && st.top() == '(') {
                    st.pop();
                } else {
                    st.push(')');
                    break;
                }
            }
    }
        if (st.empty()) cout<<"YES"<<"\n";
        else cout<<"NO"<<"\n";
    }
        
    return 0;
}
반응형

'Algorithm' 카테고리의 다른 글

[BOJ 17142] 연구소3  (0) 2020.04.12
[BOJ 14888] 연산자 끼워넣기  (0) 2020.01.02
[BOJ 1874] 스택 수열  (0) 2019.12.17
[BOJ 15649] N과 M(1)  (0) 2019.10.30
[BOJ 13460] 구슬 탈출2  (0) 2019.10.09

+ Recent posts