작심 24/7

힙 (Heap)

모닝수박 — Mon, 14 Feb 2022 23:07:14 +0900

<배열 사용 버전>

최소힙, 루트 노드를 0번으로 지정.

(1번으로 지정하는 게 더 편리하긴 함)

int heap[100];
int heapSize = 0;

void init(){
    heapSize = 0;
}

int push(int value){
    if (heapSize == 100) return 0; // 최대 사이즈를 넘어가면 나가리
    heap[heapSize] = value; // 마지막 노드에 값 추가
    // 마지막 노드에 추가한 값을 올바른 위치로 옮김
    int current = heapSize; // 현재 위치 저장
    while(current > 0 && heap[(current - 1) / 2] > heap[current]){ // 최소힙인데 부모 > 자식이면 안 되니까 바꿔주기
        // 부모랑 자식 swap
        int tmp = heap[(current - 1) / 2];
        heap[(current - 1) / 2] = heap[current];
        heap[current] = tmp;
        current = (current - 1) / 2; // current는 부모
    }
    ++heapSize; // 다음 노드
    return 1; // push 성공
}

int pop(){ // top(루트 노드) 뺌
    if (heapSize == 0) return -1; // empty인 경우
    int value = heap[0]; // 뻴 루트 노드
    --heapSize; // heap 사이즈 줄여주기
    heap[0] = heap[heapSize]; // 루트에 마지막 노드 저장

    int current = 0; // 현재 노드 = 루트 노드
    while(current * 2 + 1 < heapSize){
        int child, left = current * 2 + 1, right = left + 1;
        if (right == heapSize) child = left;  // 오른쪽 자식이 없는 경우 child는 무조건 왼쪽
        else child = left <= right ? left : right; //  더 작은 놈을 올려야 함
        if (heap[current] <= heap[child]) break; // 부모 <= 자식이면 더 이상 바꿔줄 필요가 없으므로 나옴

        int tmp = heap[current];
        heap[current] = heap[child];
        heap[child] = tmp;
        current = child; // current는 자식
    }
    return value; // 뺀 노드 리턴
}

<연결 리스트 사용 버전>

최소힙, 루트 노드를 1번으로 지정.

배열을 사용하게 되면 실행 속도는 빠르지만

메모리가 커질 땐 좋은 방법이 아닐 수 있다.

ex) 1000명의 user가 있고, user들에게 총 1000000개의 데이터를 할당하려 할 때,

1명에게 1000000개의 데이터가 몰릴 수도 있으니까

user들에게 각각 1000000개씩 데이터를 할당해야 하는데

그렇게 되면 메모리가 어마무시하게 커지기 때문에 배열로 구현하기 어렵다.

그래서 이런 경우에는 속도에서 손해를 좀 보더라도

연결 리스트로 구현해야 한다.

(코드가 예쁘진 않다^^..)

struct Node{
    int val;
    Node* parent;
    Node* child[2];
    Node(){}
    Node(int val){
        this->val = val;
        parent = child[0] = child[1] = nullptr;
    }
} memPool[1000001];
int memPoolCnt, heapSize;
Node* root;  // 항상 루트 노드를 가리킴
Node* findNode(int cur){
    if (cur == 1) return root;
    return findNode(cur / 2)->child[cur % 2]; // cur노드가 부모의 왼쪽이었는지 오른쪽이었는지 찾아서 리턴
}
int push(int val) {
    if (memPoolCnt > 1000000) return 0;
    memPool[memPoolCnt] = {val};
    Node* newNode = &memPool[memPoolCnt++];
    if(heapSize++ == 0) root = newNode;
    else{
        Node* parent = findNode(heapSize / 2); // heapSize 늘려서 새 노드 넣을 위치 확보 후 그의 부모 찾음
        newNode->parent = parent;
        parent->child[heapSize % 2] = newNode;  // 맨 마지막 노드에 새 노드 넣기

        Node* current = newNode;
        whlie(current != root && current->parent->val >= current->val){ // 최소힙인데 부모 > 자식 이면 안 되니까 바꿔주기
            int tmp = current->val;
            current->val = current->parent->val;
            current->parent->val = tmp;
            current = current->parent;
        }
    }
    return 1;
}

int pop(){
    if (heapSize == 0) return -1;
    int val = root->val;
    if(heapSize == 1){
        --heapSize;
        root = nullptr;
        return val;
    }
    Node* current = findNode(heapSize); // 맨 마지막 노드
    root->val = current->val;
    current->parent->child[heapSize % 2] = nullptr; // 마지막 노드 연결 제거
    --heapSize; // 힙 사이즈 줄임
    current = root;  // 루트부터 내려가면서 재정렬
    while (current->child[0] != nullptr) {
        int childIdx = 0;
        if (current->child[1] != nullptr) childIdx = current->child[0] <= current->child[1] ? 0 : 1;
        if (current->parent <= current->child[childIdx]) break; // 부모 <= 자식 이면 나옴
        int tmp = current->child[childIdx]->val;
        current->child[childIdx]->val = current->parent->val;
        current->parent->val = tmp;
        current = current->child[childIdx];
    }
    return val;
}
int main() { return 0; }

이진 탐색 (Binary Search)

모닝수박 — Wed, 2 Feb 2022 16:21:29 +0900

#include <iostream>
using namespace std;
int arr[8] = {1, 2, 4, 5, 10, 21, 21, 22};
int binarySearch(int st, int en, int target) { // target 찾음
    while (st <= en) {
        int mid = (st + en) / 2;
        if (arr[mid] == target) return mid;
        if (arr[mid] < target) st = mid + 1;
        else en = mid - 1;
    }
    return -1;
}
int upperBound(int st, int en, int target){ // target보다 큰 첫 번째 수 찾음
    int res = -1;
    while (st <= en) {
        int mid = (st + en) / 2;
        if (arr[mid] > target){
            res = mid;
            en = mid - 1;
        }
        else st = mid + 1;
    }
    return res;
}
int lowerBound(int st, int en, int target){ // target보다 크거나 같은 첫 번째 수 찾음
    int res = -1;
    while (st <= en) {
        int mid = (st + en) / 2;
        if(arr[mid] >= target){
            res = mid;
            en = mid - 1;
        }
        else st = mid + 1;
    }
    return res;
}
int main(){
    cout << binarySearch(0, 7, 21) << "\n";
    cout << upperBound(0, 7, 21) << "\n";
    cout << lowerBound(0, 7, 21) << "\n";
    return 0;
}

[SWEA] 8935번 스팟마트 (C++)

모닝수박 — Mon, 31 Jan 2022 17:40:25 +0900

SW Expert Academy

SW 프로그래밍 역량 강화에 도움이 되는 다양한 학습 컨텐츠를 확인하세요!

swexpertacademy.com

DP 너무 어려워..

#include <iostream>
#include <cstring>
#include <algorithm>
#include <functional>
using namespace std;
int T, N, M;
int arr[3002], brr[102];
int dp[3002][102][102][2];  // a, b 고른 수, b 버린 수, 가져가거나 안 가져가거나

int play(int a, int i, int j, int picked){
    if (dp[a][i][j][picked] != -1) return dp[a][i][j][picked];
    int val1 = 0, val2 = 0, val3 = 0, val4 = 0;
    if (picked) {  // 직전에 가져갔다면
        if(a < N) val1 = play(a + 1, i, j, 0); // a를 버리는 경우
        if(i + j < M) val2 = play(a, i, j + 1, 0); // b를 버리는 경우
    } else {  // 직전에 안 가져갔다면
        if(a < N) {
            val1 = play(a + 1, i, j, 1) + arr[a]; // a를 가져가는 경우
            val2 = play(a + 1, i, j, 0); // a를 버리는 경우
        }
        if(i + j < M){
            val3 = play(a, i + 1, j, 1) + brr[i]; // b를 가져가는 경우
            val4 = play(a, i + 1, j, 0); // b를 버리는 경우
        }
    }
    return dp[a][i][j][picked] = max(val1, max(val2, max(val3, val4)));
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cin >> T;
    for (int t = 1; t <= T; t++){
        memset(dp, -1, sizeof(dp));
        memset(brr, 0, sizeof(brr));
        cout << "#" << t << " ";
        cin >> N;
        for (int i = 0; i < N; i++) cin >> arr[i];
        cin >> M;
        for (int i = 0; i < M; i++) cin >> brr[i];
        sort(brr, brr + 102, greater<int>());
        cout << play(0, 0, 0, 0) << "\n";
    }
    return 0;
}

[SWEA] 1230번 암호문 3 (C++)

모닝수박 — Thu, 27 Jan 2022 19:49:36 +0900

SW Expert Academy

SW 프로그래밍 역량 강화에 도움이 되는 다양한 학습 컨텐츠를 확인하세요!

swexpertacademy.com

링크드 리스트를 직접 구현하여 풀었다.

메모리 풀을 이용하여 메모리를 아껴준다.

#include <iostream>
using namespace std;
struct Node
{
    int data;
    Node *next;
};
Node memPool[10000]; // 사용할 노드 미리 정의 (메모리 풀)
Node *head;         // 링크드 리스트의 대가리
int N, M, num, memPoolCnt, x, y, s;
char order;

Node *getNode(int num)
{
    memPool[memPoolCnt].data = num;
    memPool[memPoolCnt].next = nullptr;
    return &memPool[memPoolCnt++];
}

int main()
{
    for (int t = 1; t <= 10; t++)
    {
        cin >> N;
        memPoolCnt = 0; // 메모리 풀 초기화
        head = nullptr; // 링크드 리스트 초기화
        int tmp =0;
        Node *ptr = nullptr;
        // 원본 암호문
        for (int i = 0; i < N; i++)
        {
            cin >> num;
            Node *newNode = getNode(num);
            if (head == nullptr) {
                head = newNode; // head가 null이면 새로 만듦
                ptr = head;
            }
            else
            {
                ptr->next = newNode; // head의 맨 뒤에 새 노드 추가
                ptr = ptr->next; // 다음 노드 가리킴
                tmp++;
            }
        }
        cin >> M;
        // 명령어 수행
        for (int i = 0; i < M; i++){
            cin >> order;
            switch (order)
            {
                case 'I': // 삽입
                {
                    cin >> x >> y;
                    Node *ptr = head;
                    int cnt = x;
                    while(cnt > 1) {
                        ptr = ptr->next; // x번째 위치 찾음
                        cnt--;
                    }
                    for(int i = 0; i < y; i++){
                        cin >> s;
                        Node *newNode = getNode(s);
                        if(i == 0 && x == 0) { // x가 0이면 맨 앞에 집어 넣음
                            newNode->next = head;
                            head = newNode;
                            ptr = head;
                            continue;
                        }
                        newNode->next = ptr->next; // 새 노드의 next는 현재 노드의 next
                        ptr->next = newNode; // 현재 노드의 next는 새 노드
                        ptr = ptr->next; // 바로 다음 노드 가리킴
                    }
                }
                	break;
                case 'D': // 삭제
                {
                    cin >> x >> y;
                    Node *ptr = head;
                    int cnt = x;
                    while(cnt > 1) {
                        ptr = ptr->next; // x번째 위치 찾음
                        cnt--;
                    }
                    for(int i = 0; i < y; i++){
                        if(ptr->next == nullptr){
                            ptr = nullptr; // 다음 노드가 없으면 현재 노드를 nullptr로 만듦
                            break;
                        } 
                        if(x == 0){
                            head = head->next;
                            ptr = head;
                            continue;
                        } 
                        ptr->next = ptr->next->next; // 현재 노드의 next를 다음 노드의 next로 지정
                    }
                }
                	break;
                case 'A': // 추가
                {
                    cin >> y;
                    Node* ptr = head;
                    while(ptr->next) ptr = ptr->next; // 맨 뒤 노드 찾음
                    for (int i = 0; i < y; i++){
                        cin >> s;
                        Node *newNode = getNode(s);
                        ptr->next = newNode; // 맨 뒤 노드에 새 노드 추가
                        ptr = ptr->next; // 다음 노드를 가리킴
                    }
                }
                	break;
            }
        }
        // 수정 후 암호문 10개 출력
        cout << "#" << t << " ";
        for (int i = 0; i < 10; i++){
            cout << head->data << " ";
            head = head->next;
        }
        cout << "\n";
    }
}

[SWEA] 1288번 새로운 불면증 치료법 (C++)

모닝수박 — Tue, 18 Jan 2022 15:23:10 +0900

SW Expert Academy

SW 프로그래밍 역량 강화에 도움이 되는 다양한 학습 컨텐츠를 확인하세요!

swexpertacademy.com

0~9까지의 숫자가 모두 있는 경우는

chk = 1111111111

로 표시된다.

OR 연산자를 이용하여

chk에 표시돼있는지 확인할 숫자를 확인한다.

#include <iostream>
using namespace std;
int T, N;
int main() {
	cin >> T;
	for (int t = 1; t <= T; t++) {
		cin >> N;
		int cnt = 0, chk = 0, num = N;
		while (++cnt) {
			num = N * cnt;
			while (num) { // 각 자릿수 하나씩 돌기
				chk |= 1 << (num % 10);
				num /= 10;
			}
			if (chk == (1 << 10) - 1) { // 0 ~ 9까지 1로 표시되면 끝
				cout << "#" << t << " " << cnt * N << "\n";
				break;
			}
		}
	}
}

[백준] 11723번 집합 (C++)

모닝수박 — Sat, 7 Aug 2021 19:46:47 +0900

11723번: 집합

첫째 줄에 수행해야 하는 연산의 수 M (1 ≤ M ≤ 3,000,000)이 주어진다. 둘째 줄부터 M개의 줄에 수행해야 하는 연산이 한 줄에 하나씩 주어진다.

www.acmicpc.net

비트마스크를 이용해 집합을 표현해서 푸는 문제이다.

S {1, 4, 5} = 11001

이렇게 S에 들어가 있는 원소는 1로, 없으면 0으로

생각하면 된다.

연산의 핵심은

1 << x

이다.

SHIFT로 1의 위치를 적절하게 조절하여 비트연산을 하면 된다.

ex)

S {1, 5} = 10001에 4를 add하고 싶다면,

1을 왼쪽으로 3bit 만큼 옮겨준다.

1 << 3

그러면 1000이 되는데,

이 값을 S와 OR 연산 해주면

01000

10001

----------

11001

4도 추가된 S {1, 4, 5} = 11001을 얻을 수 있다.

코드 작성하는 건 쉬웠는데..

완성하고 보니 한 눈에 알아보기 어려워서

나중에 다시 볼 때 왜 이렇게 했는지 해석하기 쉽지 않을 거 같다ㅎㅎ

익숙해지면 나아지겠지?

#include <iostream>
#include <bitset>
using namespace std;
int M, S, x;
string order;
bitset <20> bit;

int main() {
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cin >> M;
	for (int i = 0; i < M; i++) {
		cin >> order;
		if (!(order == "all" || order == "empty")) cin >> x; // all이나 empty는 x를 받을 필요 없음

		if (order == "add") S |= 1 << x - 1;
		else if (order == "remove") S &= ~(1 << x - 1);
		else if (order == "check") cout << ((S & (1 << x - 1)) ? 1 : 0) << "\n";
		else if (order == "toggle") S ^= 1 << x - 1;
		else if (order == "all") S = ~(0 << 19);
		else S = 0;
		bit = bitset<20>(S); // 디버깅 용
	}
	return 0;
}

비트마스크 (BitMask)

모닝수박 — Sat, 7 Aug 2021 16:57:57 +0900

AND ( a & b )

둘 다 1이면 1, 아니면 0

OR ( a | b )

둘 다 0이면 0, 아니면 1

XOR ( a ^ b )

둘이 다르면 1, 아니면 0

NOT ( ~a )

반대

LEFT SHIFT ( a << b )

a를 b비트만큼 왼쪽으로 shift. 빈 공간은 0으로 채움

a * 2^b 와 같음

RIGHT SHIFT ( a >> b )

a를 b비트만큼 오른쪽으로 shift. 빈 공간은 0으로 채움

a / 2^b 와 같음

집합의 표현

집합의 i 번째 요소가 존재하면 1, 아니면 0으로 표현 가능

ex) {1, 2, 5} => 10011

연산자 우선순위

NOT

∨

산술연산자

∨

SHIFT

∨

비교연산자

∨

AND

∨

XOR

∨

논리연산자

[백준] 13460번 구슬 탈출 2 (C++) - 2

모닝수박 — Fri, 23 Apr 2021 01:44:31 +0900

13460번: 구슬 탈출 2

첫 번째 줄에는 보드의 세로, 가로 크기를 의미하는 두 정수 N, M (3 ≤ N, M ≤ 10)이 주어진다. 다음 N개의 줄에 보드의 모양을 나타내는 길이 M의 문자열이 주어진다. 이 문자열은 '.', '#', 'O', 'R', 'B'

www.acmicpc.net

▷다른 방식 풀이 보러가기

최대 10번 움직여서 빨간 구슬을 빼내야 하므로

상, 하, 좌, 우로 기울이는 순서를 1~10 까지 중복 순열로 지정한다.

대신, 같은 방향이 연속되지 않게 한다.

ex)

1번 움직일 경우 가능한 순서 :

1) 상(↑)

2) 하(↓)

3) 좌(←)

4) 우(→)

2번 움직일 경우 가능한 순서 :

1) 상(↑) 하(↓)

2) 상(↑) 좌(←)

3) 상(↑) 우(→)

4) 하(↓) 상(↑)

5) 하(↓) 좌(←)

6) 하(↓) 우(→)

...

11) 우(→) 하(↓)

12) 우(→) 좌(←)

3번 움직일 경우 가능한 순서 :

1) 상(↑) 하(↓) 상(↑)

2) 상(↑) 하(↓) 좌(←)

3) 상(↑) 하(↓) 우(→)

4) 상(↑) 좌(←) 상(↑)

5) 상(↑) 좌(←) 하(↓)

6) 상(↑) 좌(←) 우(→)

...

35) 우(→) 좌(←) 하(↓)

36) 우(→) 좌(←) 우(→)

이런 식으로 1번일 때부터 최대 10번까지 순서를 구한다.

r번 기울이는 순서를 구하면 move() 함수에서 그 순서대로 구슬을 움직인다.

이때 주의할 사항은

구슬은 동시에 움직인다는 조건이 있기 때문에

기울이는 방향을 향해 맨 앞에 있는 구슬부터 움직여 줘야 한다.

그래서 기울이는 방향에 따라 두 구슬의 위치를 정렬해주었다.

상(↑) : x 좌표가 더 큰 거부터

하(↓) : x 좌표가 더 작은 거부터

좌(←) : y 좌표가 더 작은 거부터

우(→) : y 좌표가 더 큰 거부터

r번일 때 해당 순서대로 움직여서 성공하면 r을 출력하면 된다.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int N, M, res = -1, d;
int dx[4] = { -1,1,0,0 }, dy[4] = { 0,0,-1,1 };
char board[11][11];
vector<int>order; // 기울이는 순서 -> 중복 순열
vector<pair<int,int> > ball; // 맨 처음 빨간 구슬과 파란 구슬 위치 저장

bool compare(pair<int, int> a, pair<int, int> b) { // 기울이는 방향에 따라 정렬이 달라짐 (먼저 위치해 있는 구슬 구분 위해)
	if (d == 0) return a.first < b.first; 
	else if (d == 1) return a.first > b.first;
	else if (d == 2) return a.second < b.second;
	else return a.second > b.second;
}

bool move() {
	bool success = false;
	vector<pair<int, int> > tmp, tmp2; // tmp2는 갱신되는 구슬 위치 저장용
	char arr[11][11] = { 0 };
	copy(&board[0][0], &board[0][0] + 11 * 11, &arr[0][0]); // 배열 복사
	copy(ball.begin(), ball.end(), back_inserter(tmp)); // 벡터 복사

	for (int t = 0; t < order.size(); t++) {
		d = order[t];
		sort(tmp.begin(), tmp.end(), compare); // 기울이는 방향에 먼저 있는 구슬부터 움직일 거임
		for (int k = 0; k < 2; k++) {
			int x = tmp[k].first, y = tmp[k].second;
			char currentBall = arr[x][y];
			arr[x][y] = '.'; // 구슬 흔적 지워주기
			if (currentBall == 'B') { // 파란 구슬
				while (1) {
					x += dx[order[t]], y += dy[order[t]];
					if (arr[x][y] == '#' || arr[x][y] == 'R') { // 파란 구슬이 벽이나 빨간 구슬에 부딪히면
						x -= dx[order[t]], y -= dy[order[t]];
						arr[x][y] = 'B';
						tmp2.push_back({ x,y }); // 파란 구슬의 새로운 위치 갱신
						break;
					}
					else if (arr[x][y] == 'O') return false; // 파란 구슬이 구멍에 빠진다면 실패
				}
			}
			else { // 빨간 구슬
				while (1) {
					x += dx[order[t]], y += dy[order[t]];
					if (arr[x][y] == '#' || arr[x][y] == 'B') { // 빨간 구슬이 벽이나 파란 구슬에 부딪히면
						x -= dx[order[t]], y -= dy[order[t]];
						arr[x][y] = 'R';
						tmp2.push_back({ x,y }); // 빨간 구슬의 새로운 위치 갱신
						break;
					}
					else if (arr[x][y] == 'O') {
						success = true; // 구슬이 동시에 빠지면 실패니까 일단 체크만 해둠
						break;
					}
				}
			}
		}
		tmp.clear();
		copy(tmp2.begin(), tmp2.end(), back_inserter(tmp)); // 벡터 복사
		tmp2.clear();
	}
	if (success) return true; // 빨간 구슬만 빠졌다면 성공
	return false;
}

void permutation(int before, int cnt, int r) { // 중복 순열. 단, 이전 방향과 겹치지 않게
	if (cnt == r) {
		if (move()) res = r;
		return;
	}
	for (int i = 0; i < 4; i++) {
		if (before == i) continue; // 이전 방향과 같으면 넘김
		order.push_back(i);
		permutation(i, cnt + 1, r);
		if (res != -1) return; // 성공이면 빠져나옴
		order.pop_back();
	}
}

int main() {
	cin >> N >> M;
	for (int i = 0; i < N; i++) {
		for (int j = 0; j < M; j++) {
			cin >> board[i][j];
			if (board[i][j] == 'R' || board[i][j] == 'B') ball.push_back({ i,j });
		}
	}
	for (int i = 1; i <= 10; i++) { // 1부터 10까지 뽑는 중복 순열
		permutation(-1, 0, i);
		if (res != -1) break; // 성공이면 빠져나옴
	}
	cout << res;
	return 0;
}

[SWEA] 5656번 벽돌 깨기 (C++)

모닝수박 — Thu, 15 Apr 2021 11:10:11 +0900

SW Expert Academy

SW 프로그래밍 역량 강화에 도움이 되는 다양한 학습 컨텐츠를 확인하세요!

swexpertacademy.com

1. findTop

0열부터 W - 1열까지 돌면서

0행부터 탐색하며

맨 위에 있는 벽돌을 찾아내는 함수이다.

이 행위를 재귀로 N번 반복하면

N개 중 N개를 중복 포함에서 뽑는 중복 순열이 된다.

맨 위에 있는 벽돌을 찾아내면 거기에 구슬을 떨어뜨리고

다음 동작들을 (연쇄 벽돌 없애기, 벽돌 재 정렬하기) 실행한 뒤

돌아와서 재귀로 구슬을 떨어뜨릴 다음 위치를 찾는다.

2. findChain

구슬을 떨어뜨린 벽돌을 기준으로

연쇄된 모든 벽돌을 찾아 0으로 바꿔주는 함수이다.

상하좌우를 DFS 탐색하며

명중된 벽돌들을 찾아서 큐에 넣어준 뒤

0으로 바꿔주고 다음 큐로 넘어간다.

3. dropBricks

중간중간에 빈 공간이 생긴 벽돌을 재 정렬하는 함수이다.

열 단위로 스택에 벽돌 종류를 담아준 다음

맨 밑에서부터 pop해준 뒤

나머지 공간엔 0으로 채워준다.

4. countBricks

남은 벽돌의 개수를 카운트하는 함수이다.

findTop을 N번 반복하지 못 하는 경우도 있기 때문에

재귀로 N번 반복했을 때 뿐만 아니라

반복문이 끝나고 나서도 호출해 주어야 한다.

#include <iostream>
#include <queue>
#include <stack>
#include <algorithm>
#include <climits>
using namespace std;

class info {
public:
	int x, y, num;
	info(int x, int y, int num) {
		this->x = x;
		this->y = y;
		this->num = num;
	}
};

int N, W, H, tot, res;
int dx[4] = { -1,1,0,0 }, dy[4] = { 0,0,-1,1 };
queue<info> shoot; // 명중하는 벽돌 위치 저장
stack<int> brick; // 재정렬 위해 벽돌 종류 저장

void countBricks(int newArr[][13]) {
	int cnt = 0;
	for (int m = 0; m < H; m++) for (int k = 0; k < W; k++) if (newArr[m][k] > 0) cnt++; // 남은 벽돌 개수 세기
	res = min(res, cnt);
}

void dropBricks(int newArr[][13]) { // 남은 벽돌들 재정렬
	for (int j = 0; j < W; j++) {
		for (int i = 0; i < H; i++) if (newArr[i][j] > 0) brick.push(newArr[i][j]);
		for (int i = H - 1; i >= 0; i--) {
			if (!brick.empty()) {
				newArr[i][j] = brick.top(); // 밑에서부터 벽돌 채워 넣음
				brick.pop();
			}
			else newArr[i][j] = 0; // 나머지는 0으로 채워 넣음
		}
	}
}

void findChain(int X, int Y, int newArr[][13]) { // 연쇄 벽돌들 찾기 - DFS
	bool chk[16][13] = { false }; // 방문 체크
	shoot.push(info(X, Y, newArr[X][Y]));
	newArr[X][Y] = 0;
	while (!shoot.empty()) {
		for (int i = 0; i < 4; i++) {
			int x = shoot.front().x, y = shoot.front().y, cnt = shoot.front().num;
			while (--cnt > 0) {
				x += dx[i], y += dy[i];
				if (x < 0 || x >= H || y < 0 || y >= W) break; // 범위 벗어나면 나옴
				if (newArr[x][y] > 0) shoot.push(info(x, y, newArr[x][y]));
				newArr[x][y] = 0;
			}
		}
		shoot.pop();
	}
}

void findTop(int arr[][13], int n) { // 맨 위의 벽돌 찾기 - 중복 순열
	if (n == N) {
		countBricks(arr);
		return;
	}
	for (int j = 0; j < W; j++) { // 각 열마다 맨 위의 벽돌 찾기
		int i = -1;
		while (true) if (++i == H || arr[i][j] > 0) break; // 범위를 벗어나거나 벽돌이면 나온다
		if (i == H) continue; // 벽돌이 없으면 다음 열로 이동

		int newArr[16][13] = { 0 };
		copy(&arr[0][0], &arr[0][0] + 16 * 13, &newArr[0][0]); // 이차원 배열 복사 후 사용
		findChain(i, j, newArr);
		dropBricks(newArr);
		findTop(newArr, n + 1);
	}
	countBricks(arr); // 재귀로 못 넘어가는 경우도 있기 때문에 여기서도 res 갱신 시켜준다.
}

int main() {
	int T;
	cin >> T;
	for (int t = 1; t <= T; t++) {
		cin >> N >> W >> H;
		int arr[16][13] = { 0 };
		for (int i = 0; i < H; i++) for (int j = 0; j < W; j++) cin >> arr[i][j];
		res = INT_MAX;
		findTop(arr, 0);
		cout << "#" << t << " " << res << "\n";
	}

	return 0;
}

저번 달에 시도했을 때

명중한 벽돌을 없애지 않고 체크 배열로 표시만 해두면서 풀었더니

상하좌우에 위치한 유효 벽돌을 골라내는 게 너무 힘들어서

다음에 다시 풀어봐야지~ 하고 미룬 지 한 달이 지났다..

과제로 나와버린 김에 ~~(강제로)~~ 다시 직면했으나

몇 시간 내내 또 같은 실수를 반복하고 있는 나를 발견하고

그냥 문제에 나와있는 그대로

벽돌을 명중시키면 쿨하게 없애버리는 동작을 단계별로 구현해보았다.

그러니까 갑자기 술술 풀리길래 허무했다.

이 방법이 더 귀찮을 거 같아서 안 움직이고 체크만 하는 방식을 고집했었는데

오히려 그 반대였던 게 함정ㅠㅠ

언제쯤 시뮬레이션 문제를 고통받지 않고 한 번에 구현해낼 수 있을까,,

[SWEA] 7465번 창용 마을 무리의 개수 (JAVA)

모닝수박 — Thu, 18 Mar 2021 22:22:25 +0900

SW Expert Academy

SW 프로그래밍 역량 강화에 도움이 되는 다양한 학습 컨텐츠를 확인하세요!

swexpertacademy.com

기본적인 Union-Find 문제이다.

좀 더 효율적인 비교를 위해

union 연산에서 트리의 깊이(rank)를 이용하여

rank가 더 높은 집합에 rank가 낮은 집합을 붙이게 하였다.

rank가 같을 때는 어쩔 수 없이

둘 중 하나는 증가돼야 하므로 + 1 해주었다.

rank가 다를 때

rank가 동일할 때

import java.util.Scanner;

public class D4_7465_창용마을_무리의개수 {
	static int T, N, M, res;
	static int parentOf[], rank[];
	
	static int find(int a) {
		if(parentOf[a] == a) return a; // 자기 자신을 가리키면 부모를 찾은 거임
		return parentOf[a] = find(parentOf[a]);
	}
	
	static void union(int a, int b) {
		int parentOfA = find(a), parentOfB = find(b);
		if(rank[parentOfA] < rank[parentOfB]) { // 랭크(깊이)가 더 큰 집합에 작은 애가 붙음
			parentOf[parentOfA] = parentOfB;
			return;
		}
		if(rank[parentOfA] == rank[parentOfB]) rank[parentOfB]++; // 랭크가 같으면 하나는 + 1 해주어야 함
		parentOf[parentOfB] = parentOfA;
	}
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		T = sc.nextInt();
		for(int t = 1; t <= T; t++) {
			N = sc.nextInt(); M = sc.nextInt(); res = 0;
			parentOf = new int[N + 1]; rank = new int[N + 1];
			for(int i = 1; i <= N; i++) parentOf[i] = i; // 자기 자신을 가리키게 초기화
			for(int i = 0; i < M; i++) union(sc.nextInt(), sc.nextInt());
			for(int i = 1; i <= N; i++) if(parentOf[i] == i) res++; // 자기 자신을 가리키면 집합 하나라는 뜻
			System.out.println("#" + t + " " + res);
		}	
	}
}