그래프와 서로소 집합

 

 

10.3 개선된 서로소 집합 알고리즘 코드

#include <bits/stdc++.h>

using namespace std;

// 노드의 개수(V)와 간선(Union 연산)의 개수(E)
// 노드의 개수는 최대 100,000개라고 가정
int v, e;
int parent[100001]; // 부모 테이블 초기화

// 특정 원소가 속한 집합을 찾기
int findParent(int x) {
    // 루트 노드가 아니라면, 루트 노드를 찾을 때까지 재귀적으로 호출
    if (x == parent[x]) return x;
    return parent[x] = findParent(parent[x]);
}

// 두 원소가 속한 집합을 합치기
void unionParent(int a, int b) {
    a = findParent(a);
    b = findParent(b);
    if (a < b) parent[b] = a;
    else parent[a] = b;
}

int main(void) {
    cin >> v >> e;

    // 부모 테이블상에서, 부모를 자기 자신으로 초기화
    for (int i = 1; i <= v; i++) {
        parent[i] = i;
    }

    // Union 연산을 각각 수행
    for (int i = 0; i < e; i++) {
        int a, b;
        cin >> a >> b;
        unionParent(a, b);
    }

    // 각 원소가 속한 집합 출력하기
    cout << "각 원소가 속한 집합: ";
    for (int i = 1; i <= v; i++) {
        cout << findParent(i) << ' ';
    }
    cout << '\n';

    // 부모 테이블 내용 출력하기
    cout << "부모 테이블: ";
    for (int i = 1; i <= v; i++) {
        cout << parent[i] << ' ';
    }
    cout << '\n';
}

 

 

 

10.4 서로소 집합을 활용한 사이클 판별 코드

#include <bits/stdc++.h>

using namespace std;

// 노드의 개수(V)와 간선(Union 연산)의 개수(E)
// 노드의 개수는 최대 100,000개라고 가정
int v, e;
int parent[100001]; // 부모 테이블 초기화

// 특정 원소가 속한 집합을 찾기
int findParent(int x) {
    // 루트 노드가 아니라면, 루트 노드를 찾을 때까지 재귀적으로 호출
    if (x == parent[x]) return x;
    return parent[x] = findParent(parent[x]);
}

// 두 원소가 속한 집합을 합치기
void unionParent(int a, int b) {
    a = findParent(a);
    b = findParent(b);
    if (a < b) parent[b] = a;
    else parent[a] = b;
}

int main(void) {
    cin >> v >> e;

    // 부모 테이블상에서, 부모를 자기 자신으로 초기화
    for (int i = 1; i <= v; i++) {
        parent[i] = i;
    }

    bool cycle = false; // 사이클 발생 여부

    for (int i = 0; i < e; i++) {
        int a, b;
        cin >> a >> b;
        // 사이클이 발생한 경우 종료
        if (findParent(a) == findParent(b)) {
            cycle = true;
            break;
        }
        // 사이클이 발생하지 않았다면 합집합(Union) 연산 수행
        else {
            unionParent(a, b);
        }
    }

    if (cycle) {
        cout << "사이클이 발생했습니다." << '\n';
    }
    else {
        cout << "사이클이 발생하지 않았습니다." << '\n';
    }
}

 

 


크루스칼 알고리즘

 

크루스칼 알고리즘 동작 방식: 간선을 하나씩 확인하면서 신장 트리에 포함을 시킬지 안 시킬지 결정

 

 

 

10.5 크루스칼 알고리즘 구현

#include <bits/stdc++.h>

using namespace std;

// 노드의 개수(V)와 간선(Union 연산)의 개수(E)
// 노드의 개수는 최대 100,000개라고 가정
int v, e;
int parent[100001]; // 부모 테이블 초기화
// 모든 간선을 담을 리스트와, 최종 비용을 담을 변수
vector<pair<int, pair<int, int> > > edges;
int result = 0;

// 특정 원소가 속한 집합을 찾기
int findParent(int x) {
    // 루트 노드가 아니라면, 루트 노드를 찾을 때까지 재귀적으로 호출
    if (x == parent[x]) return x;
    return parent[x] = findParent(parent[x]);
}

// 두 원소가 속한 집합을 합치기
void unionParent(int a, int b) {
    a = findParent(a);
    b = findParent(b);
    if (a < b) parent[b] = a;
    else parent[a] = b;
}

int main(void) {
    cin >> v >> e;

    // 부모 테이블상에서, 부모를 자기 자신으로 초기화
    for (int i = 1; i <= v; i++) {
        parent[i] = i;
    }

    // 모든 간선에 대한 정보를 입력 받기
    for (int i = 0; i < e; i++) {
        int a, b, cost;
        cin >> a >> b >> cost;
        // 비용순으로 정렬하기 위해서 튜플의 첫 번째 원소를 비용으로 설정
        edges.push_back({cost, {a, b}});
    }

    // 간선을 비용순으로 정렬
    sort(edges.begin(), edges.end());

    // 간선을 하나씩 확인하며
    for (int i = 0; i < edges.size(); i++) {
        int cost = edges[i].first;
        int a = edges[i].second.first;
        int b = edges[i].second.second;
        // 사이클이 발생하지 않는 경우에만 집합에 포함
        if (findParent(a) != findParent(b)) {
            unionParent(a, b);
            result += cost;
        }
    }

    cout << result << '\n';
}

 

 

 


 

 

위상 정렬

 

위상 정렬을 다루기 전에, 그래프 관련 자료구조에 자주 나타나는 개념들을 알아보자.

 

 

 

10.6 위상 정렬 알고리즘 구현

#include <bits/stdc++.h>

using namespace std;

// 노드의 개수(V)와 간선의 개수(E)
// 노드의 개수는 최대 100,000개라고 가정
int v, e;
// 모든 노드에 대한 진입차수는 0으로 초기화
int indegree[100001];
// 각 노드에 연결된 간선 정보를 담기 위한 연결 리스트 초기화
vector<int> graph[100001];

// 위상 정렬 함수
void topologySort() {
    vector<int> result; // 알고리즘 수행 결과를 담을 리스트
    queue<int> q; // 큐 라이브러리 사용

    // 처음 시작할 때는 진입차수가 0인 노드를 큐에 삽입
    for (int i = 1; i <= v; i++) {
        if (indegree[i] == 0) {
            q.push(i);
        }
    }

    // 큐가 빌 때까지 반복
    while (!q.empty()) {
        // 큐에서 원소 꺼내기
        int now = q.front();
        q.pop();
        result.push_back(now);
        // 해당 원소와 연결된 노드들의 진입차수에서 1 빼기
        for (int i = 0; i < graph[now].size(); i++) {
            indegree[graph[now][i]] -= 1;
            // 새롭게 진입차수가 0이 되는 노드를 큐에 삽입
            if (indegree[graph[now][i]] == 0) {
                q.push(graph[now][i]);
            }
        }
    }

    // 위상 정렬을 수행한 결과 출력
    for (int i = 0; i < result.size(); i++) {
        cout << result[i] << ' ';
    }
}

int main(void) {
    cin >> v >> e;

    // 방향 그래프의 모든 간선 정보를 입력 받기
    for (int i = 0; i < e; i++) {
        int a, b;
        cin >> a >> b;
        graph[a].push_back(b); // 정점 A에서 B로 이동 가능
        // 진입 차수를 1 증가
        indegree[b] += 1;
    }

    topologySort();
}

'알고리즘 > 이것이 코딩 테스트다' 카테고리의 다른 글

[이코테/C++] 음료수 얼려 먹기  (0) 2022.05.31
09. 최단 경로  (0) 2022.05.10
08: 다이나믹 프로그래밍  (0) 2022.03.27
07: 이진 탐색  (0) 2022.03.25
06: 정렬  (0) 2022.03.20

문제 5-10. 음료수 얼려 먹기

 

N x M 크기의 얼음 틀이 있다. 구멍이 뚫려 있는 부분은 0, 칸막이가 존재하는 부분은 1로 표시된다. 구멍이 뚫려 있는 부분끼리 상, 하, 좌, 우로 붙어 있는 경우 서로 연결되어 있는 것으로 간주한다. 이때 얼음 틀의 모양이 주어졌을 때 생성되는 총 아이스크림의 개수를 구하는 프로그램을 작성하시오.
예시) 다음의 4 x 5 얼음 틀 예시에서는 아이스크림이 총 3개 생성된다.

입력 조건
첫 번째 줄에 얼음 틀의 세로 길이 N과 가로 길이 M이 주어진다.
(1 <= N, M <= 1,000)
두 번째 줄부터 N + 1번째 줄까지 얼음 틀의 형태가 주어진다.
이때 구멍이 뚫려있는 부분은 0, 그렇지 않은 부분은 1이다.

출력 조건
한 번에 만들 수 있는 아이스크림의 개수를 출력한다.

 

 

아이디어

얼음을 얼릴 수 있는 공간이 상, 하, 좌, 우로 연결되어 있다고 표현할 수 있으므로 그래프 형태로 모델링 한다. DFS를 이용하면 간단히 해결 가능하다.

물을 흘려 보낸다는 느낌으로 bool형 배열인 visited를 선언하여 방문 처리를 하고, 한 번 방문했으면 카운팅을 하지 않는 식으로 푼다.

 

#include <iostream>
#include <string>
using namespace std;

int arr[1001][1001];
bool visited[1001][1001];
int n, m;

bool dfs(int row, int col){
	if (row < 0 || row >= n || col < 0 || col >= m) return false;
	if (arr[row][col] == 1) return false;
	if (visited[row][col] == true) return false;
	visited[row][col] = true;

	dfs(row - 1, col);
	dfs(row + 1, col);
	dfs(row, col - 1);
	dfs(row, col + 1);

	return true;
}

int main() {
	cin >> n >> m;

	string s;
	for (int i = 0; i < n; i++) {
		cin >> s;
		int size = s.size();
		for (int j = 0; j < size; j++) {
			arr[i][j] = (s[j] - '0');
		}
	}

	int cnt = 0;
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < m; j++) {
			if (true == dfs(i, j)) {
				cnt++;
			}
		}
	}

	cout << cnt << "\n";
}

'알고리즘 > 이것이 코딩 테스트다' 카테고리의 다른 글

10. 그래프  (0) 2022.07.02
09. 최단 경로  (0) 2022.05.10
08: 다이나믹 프로그래밍  (0) 2022.03.27
07: 이진 탐색  (0) 2022.03.25
06: 정렬  (0) 2022.03.20

다익스트라 최단 경로 알고리즘

출발 노드로부터 각 노드로 갈 때의 최단 경로를 구한다.

단계마다 최단 거리의 노드를 하나씩 반복하여 선택 - 해당 노드를 거쳐 가는 경로 확인 - 최단 거리 테이블 갱신.

기본적으로 그리디 알고리즘으로 분류.

각 노드에 대한 현재까지의 최단 거리 정보를 1차원 리스트에 저장, 갱신

 

원리

1) 출발 노드 설정

2) 최단 거리 테이블 초기화

3) 방문하지 않은 노드 중 최단 거리 노드를 선택

4) 3에서 선택한 노드를 거쳐 다른 노드를 가는 비용 계산, 최단 거리 테이블 갱신

5) 3과 4를 반복

 

 

간단한 다익스트라 알고리즘

: 선형 탐색을 통해 비용이 가장 낮은 노드를 찾음

노드 개수가 V일 때, 시간 복잡도 O(V^2)이므로 노드의 개수가 10,000개를 넘어간다면 문제 해결이 어렵다.

#include <iostream>
#include <vector>

#define INF 1e9

using namespace std;

// 노드 개수 N, 간선 개수 M, 시작 노드 Start
// 노드 개수는 최대 100,000개라고 가정
int n, m, start; 

vector<pair<int, int>> graph[100'001];
bool visited[100'001];
int d[100'001];

int getSmall() {
	int min_value = INF;
	int index = 0;
	for (int i = 1; i <= n; i++) {
		if (d[i] < min_value && !visited[i]) {
			min_value = d[i];
			index = i;
		}
	}
}

void dijkstra(int start) {
	d[start] = 0;
	visited[start] = true;
	// 시작 노드와 연결된 노드들의 비용을 테이블에 초기화
	for (int j = 0; j < graph[start].size(); j++) {
		int val = graph[start][j].first;
		d[val] = graph[start][j].second;
	}

	// 시작 노드 제외, 전체 n-1개의 노드에 대해 반복
	for (int i = 0; i < n - 1; i++) {
		int small = getSmall();
		visited[small] = true;
		for (int j = 0; j < graph[small].size(); j++) {
			int cost = d[small] + graph[small][j].second;
			if (d[graph[small][j].first] > cost) {
				d[graph[small][j].first] = cost;
			}
		}
	}
}

int main() {

	// 입력
	cin >> n >> m >> start;
	for (int i = 0; i < m; i++) { 
		int a, b, c;
		cin >> a >> b >> c; // a-b로 가는 비용은 c
		graph[a].push_back({ b, c });
	}

	fill_n(d, 100'001, INF);

	dijkstra(start);

	// 출력
	for (int i = 1; i <= n; i++) {
		if (d[i] == INF) {
			cout << "INFINITY" << "\n";
		}
		else {
			cout << d[i] << "\n";
		}
	}

}

 

개선된 다익스트라 알고리즘

: 우선순위 큐의 성질을 이용 -> 비용이 가장 낮은 노드를 탐색하는 과정을 생략

노드의 개수가 V이고 간선의 개수가 E일 때, 시간 복잡도 O(ElogV)

#include <iostream>
#include <vector>
#include <queue>

#define INF 1e9

using namespace std;

// 노드 개수 N, 간선 개수 M, 시작 노드 Start
// 노드 개수는 최대 100,000개라고 가정
int n, m, start; 

vector<pair<int, int>> graph[100'001];
// 최단 거리 테이블
int d[100'001];

void dijkstra(int start) {
	priority_queue<pair<int, int>> pq;
	// start 노드부터 push
	pq.push({ 0, start });
    // 시작 지점까지의 거리는 0
	d[start] = 0;

	while (!pq.empty()) {
    	// 우선순위 큐의 맨 앞에 있는 원소의 거리 비용
		int dist = -pq.top().first;
        // 우선순위 큐에서 맨 앞에 있는 원소의 노드 번호
		int now = pq.top().second;
        // 우선순위 큐에서 맨 앞에 있는 원소 pop
		pq.pop();
		// 최단 거리 테이블에 있는 값보다 거리 비용이 크면 skip
		if (d[now] < dist) continue;
		// 꺼내온 원소에 대한 처리. 
        // 만약 2번이 꺼내졌다면 2번과 연결된 노드들의 거리 비용 갱신 과정
		for (int i = 0; i < graph[now].size(); i++) {
        	// 2번까지의 거리 비용 + 연결된 노드의 거리 비용
			int cost = dist + graph[now][i].second; 
            // 2번 거리 비용 + 연결 노드의 거리 비용이 최단 거리 테이블 값보다 작으면
			if (cost < d[graph[now][i].first]) {
				d[graph[now][i].first] = cost; // 갱신
                 // 연결된 노드와 연결된 노드들 push
				pq.push(make_pair(-cost, graph[now][i].first));
			}
		}

	}

}

int main() {

	// 입력
	cin >> n >> m >> start;
	for (int i = 0; i < m; i++) { 
		int a, b, c;
		cin >> a >> b >> c; // a-b로 가는 비용은 c
		graph[a].push_back({ b, c });
	}

	fill_n(d, 100'001, INF);

	dijkstra(start);

	// 출력
	for (int i = 1; i <= n; i++) {
		if (d[i] == INF) {
			cout << "INFINITY" << "\n";
		}
		else {
			cout << d[i] << "\n";
		}
	}

}

 

 

플로이드 워셜 알고리즘

모든 노드로부터 모든 노드까지의 최단 경로를 계산한다.

2차원 리스트에 모든 노드-모든 노드 거리 비용을 저장하므로, O(N^2)의 시간 복잡도

Dab = min(Dab, Dak + Dkb);

#include <iostream>
#define INF 1e9

using namespace std;

// 노드 개수 N, 간선 개수 M
int n, m;
int graph[501][501];


int main() {
	cin >> n >> m;

	for (int i = 0; i < 501; i++) {
		fill(graph[i], graph[i] + 501, INF);
	}

	for (int a = 1; a <= n; a++) {
		for (int b = 1; b <= n; b++) {
			if (a == b) {
				graph[a][b] = 0;
			}
		}
	}

	for (int i = 0; i < m; i++) {
		int a, b, c;
		cin >> a >> b >> c;
		graph[a][b] = c;
	}

	for (int k = 1; k <= n; k++) {
		for (int a = 1; a <= n; a++) {
			for (int b = 1; b <= n; b++) {
				graph[a][b] = min(graph[a][b], graph[a][k] + graph[k][b]);
			}
		}
	}


	for (int a = 1; a <= n; a++) {
		for (int b = 1; b <= n; b++) {
			if (graph[a][b] == INF) {
				cout << "INFINITY" << ' ';
			}
			else {
				cout << graph[a][b] << ' ';
			}
		}
		cout << "\n";
	}

}

 

 

문제 9-4. 미래 도시

[문제]

 미래 도시에는 1번부터 N번까지의 회사가 있는데 특정 회사끼리는 서로 도로를 통해 연결되어 있다. 방문 판매원 A는 현재 1번 회사에 위치해 있으며, X번 회사에 방문해 물건을 판매하고자 한다.

 미래 도시에서 특정 회사에 도착하기 위한 방법은 회사끼리 연결되어 있는 도로를 이용하는 방법이 유일하다. 또한 연결된 2개의 회사는 양방향으로 이동할 수 있다. 공중 미래 도시에서 특정 회사와 다른 회사가 도로로 연결되어 있다면, 정확히 1만큼의 시간으로 이동할 수 있다.

 또한 오늘 방문 판매원 A는 기대하던 소개팅에도 참석하고자 한다. 소개팅의 상대는 K번 회사에 존재한다. 방문 판매원 A는 X번 회사에 가서 물건을 판매하기 전에 먼저 소개팅 상대의 회사에 찾아가서 함께 커피를 마실 예정이다. 따라서 방문 판매원 A는 1번 회사에서 출발하여 K번 회사를 방문한 뒤에 X번 회사로 가는 것이 목표다. 이때 방문 판매원 A는 가능한 한 빠르게 이동하고자 한다. 

 방문 판매원이 회사 사이를 이동하게 되는 최소 시간을 계산하는 프로그램을 작성하시오.

 

[입력 조건]

1. 첫째 줄에 전체 회사의 개수 N과 경로의 개수 M이 공백으로 구분되어 차례대로 주어진다. (1 <= N, M <= 100)

2. 둘째 줄부터 M + 1번째 줄에는 연결된 두 회사의 번호가 공백으로 구분되어 주어진다.

 M + 2번째 줄에는 X와 K가 공백으로 구분되어 차례대로 주어진다. (1 <= K <= 100)

 

[출력 조건]

1. 첫째 줄에 방문 판매원 A가 K번 회사를 거쳐 X번 회사로 가는 최소 이동 시간을 출력한다.

2. 만약 X번 회사에 도달할 수 없다면 -1을 출력한다.

<입력 예시 1>
5 7
1 2
1 3
1 4
2 4
3 4
3 5
4 5
4 5
<출력 예시 1>
3

<입력 예시 2>
4 2
1 3
2 4
3 4
<출력 예시 2>
-1

답안

 

#include <iostream>
using namespace std;
#define INF 1e9

int n, m, x, k;
int d[101][101];
int main()
{
	cin >> n >> m;
	for (int i = 0; i < 101; i++) {
		for (int j = 0; j < 101; j++) {
			d[i][j] = INF;
		}
	}

	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++) {
			if (i == j) d[i][j] = 0;
		}
	}

	for (int i = 0; i < m; i++) {
		int val1, val2;
		cin >> val1 >> val2;
		d[val1][val2] = 1;
		d[val2][val1] = 1;
	}

	cin >> x >> k;

	for (int k = 1; k <= n; k++) {
		for (int a = 1; a <= n; a++) {
			for (int b = 1; b <= n; b++) {
				d[a][b] = min(d[a][b], d[a][k] + d[k][b]);
			}
		}
	}

	int dist = d[1][k] + d[k][x];
	if (dist >= 1e9) {
		cout << -1 << "\n";
	}
	else
		cout << dist << "\n";
}

 

 

 

 

문제 9-5. 전보

[문제]

 어떤 나라에는 N개의 도시가 있다. 그리고 각 도시는 보내고자 하는 메시지가 있는 경우, 다른 도시로 전보를 보내서 다른 도시로 해당 메시지를 전송할 수 있다. 하지만 X라는 도시에서 Y라는 도시로 전보를 보내고자 한다면, 도시 X에서 Y로 향하는 통로가 설치되어 있어야 한다. 예를 들어 X에서 Y로 향하는 통로는 있지만, Y에서 X로 향하는 통로가 없다면 Y는 X로 메시지를 보낼 수 없다. 또한 통로를 거쳐 메시지를 보낼 때는 일정 시간이 소요된다.

 

 어느 날 C라는 도시에서 위급 상황이 발생했다. 그래서 최대한 많은 도시로 메시지를 보내고자 한다. 메시지는 도시 C에서 출발하여 각 도시 사이에 설치된 통로를 거쳐, 최대한 많이 퍼져나갈 것이다. 각 도시의 번호와 통로가 설치되어 있는 정보가 주어졌을 때, 도시 C에서 보낸 메시지를 받게 되는 도시의 개수는 총 몇 개이며 도시들이 모두 메시지를 받는 데까지 걸리는 시간은 얼마인지 계산하는 프로그램을 작성하시오.

 

[입력 조건]

1. 첫째 줄에 도시의 개수 N, 통로의 개수 M, 메시지를 보내고자 하는 도시 C가 주어진다.

   (1 <= N <= 30,000, 1 <= M <= 200,000, 1 <= C <= N)

2. 둘째 줄부터 M + 1번째 줄에 걸쳐서 통로에 대한 정보 X, Y, Z가 주어진다. 이는 특정 도시 X에서 다른 특정 도시 Y로 이어지는 통로가 있으며, 메시지가 전달되는 시간이 Z라는 의미다. (1 <= X, Y <= N, 1 <= Z <= 1,000)

 

[출력 조건]

첫째 줄에 도시 C에서 보낸 메시지를 받는 도시의 총 개수와 총 걸리는 시간을 공백으로 구분하여 출력한다.

 

[입출력 예시]

<입력>
3 2 1
1 2 4
1 3 2
<출력>
2 4

 

답안

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


int n, m, c;
vector<pair<int, int>> v[30001];
int d[30001];

void dijkstra(int s) {
	priority_queue<pair<int, int>> pq;

	d[s] = 0;
	pq.push({0, s});

	while (!pq.empty()) {
		int top = pq.top().second;
		int top_dist = -pq.top().first;
		pq.pop();
		if (top_dist > d[top]) continue;
		for (int i = 0; i < v[top].size(); i++) {
			int now = v[top][i].first;
			int now_dist = v[top][i].second;
			if (d[now] > top_dist + now_dist)
				d[now] = top_dist + now_dist;
			pq.push({-now_dist, now});
		}
	}
}


int main()
{
	cin >> n >> m >> c;
	for (int i = 0; i < m; i++) {
		int x, y, z;
		cin >> x >> y >> z;
		v[x].push_back({ y, z }); // x에서 y로 가는 비용은 z
	}

	for (int i = 0; i <= 30001; i++) {
		d[i] = 1e9;
	}

	dijkstra(c);

	int cnt = 0 , time = 0;
	for (int i = 1; i < n; i++) {
		if (d[i] != 1e9) {
			cnt++;
			time = max(time, d[i]);
		}
	}

	cout << cnt << " " << time << "\n";
}

 

 

 

 

 

 

'알고리즘 > 이것이 코딩 테스트다' 카테고리의 다른 글

10. 그래프  (0) 2022.07.02
[이코테/C++] 음료수 얼려 먹기  (0) 2022.05.31
08: 다이나믹 프로그래밍  (0) 2022.03.27
07: 이진 탐색  (0) 2022.03.25
06: 정렬  (0) 2022.03.20

다이나믹 프로그래밍

메모리를 적절하게 사용하여 수행 시간의 효율을 비약적으로 향상시킨다.

이미 계산된 결과는 별도 메모리 영역에 저장하여 다시 계산하지 않도록 한다.

프로그래밍(알고리즘)에서의 다이나믹은 자료구조에서의 다이나믹과는 다른 무게를 가진다.

 

구현

탑 다운, 보텀 업

 

조건

1. 최적 부분 구조 - 큰 문제를 작은 문제들로 나눌 수 있으며, 작은 문제의 답을 모아서 큰 문제를 해결할 수 있다.

2. 중복되는 부분 문제 - 동일한 작은 문제를 반복적으로 해결해야 합니다.

 

피보나치 수열

다이나믹 프로그래밍으로 효과적으로 계산할 수 있다.

피보나치 수열의 시간 복잡도(지수)를 고려해 봤을 때 다이나믹 프로그래밍으로 효율적인 해결이 가능하다.

 

피보나치 수열: 단순 재귀 함수

#include <iostream>
using namespace std;

int fibo(int x) {
	if (x == 1 || x == 2) {
		return 1;
	}
	return fibo(x - 1) + fibo(x - 2);
}
int main() {
	cout << fibo(4) << "\n";
	return 0;
}

 

메모이제이션

다이나믹 프로그래밍을 구현하는 방법 중 하나.

한 번 계산한 결과를 메모리 공간에 메모한다. (같은 문제를 호출하면 메모했던 결과를 가져온다)

값을 기록한다는 점에서 Caching이라고도 한다.

 

탑다운과 보텀업

탑다운(메모이제이션)은 하향식, 보텀업은 상향식.

다이나믹 프로그래밍의 전형적인 방식은 보텀업이다. 결과 저장용 리스트는 DP 테이블이라고 부른다.

메모이제이션은 다이나믹 프로그래밍에 국한된 개념은 아니다.

 

피보나치 수열: 보텀업 다이나믹 프로그래밍 코드

#include <iostream>
using namespace std;

long long d[100];

int main() {
	d[1] = 1;
	d[2] = 1;
	int n = 50;

	for (int i = 3; i < n; i++) {
		d[n] = d[n - 1] + d[n - 2];
	}
	cout << d[n] << "\n";

	return 0;
}

 

피보나치 수열: 메모제이션 동작 분석

메모이제이션을 사용하는 경우 피보나치 수열 함수의 시간 복잡도는 O(N)이다. 이미 계산된 결과는 상수 시간이 걸린다.

 

다이나믹 프로그래밍 VS 분할 정복

둘 다 최적 부분 구조를 가질 때 사용할 수 있다.

차이점은 부분 문제의 중복이다. 다이나믹 프로그래밍은 부분 문제들이 서로 영향을 미치며 중복되는데, 분할 정복은 동일한 부분 문제가 반복적으로 계산되지 않는다.

분할 정복의 대표적인 예시인 퀵 정렬을 보자. pivot이 한 번 자리를 변경하면 그 기준 원소의 위치는 바뀌지 않는다. 분할 이후 해당 피벗을 처리하는 부분 문제는 호출되지 않는다.

 

다이나믹 프로그래밍: 접근 방법

주어진 문제가 다이나믹 프로그래밍 유형인지 파악하는 것이 중요.

가장 먼저 그리디, 구현, 완전 탐색 등의 아이디어로 해결할 수 있는지 검토해 보고 떠오르지 않는다면 다이나믹 프로그래밍을 고려.

일반 코딩 테스트 수준에서는 기본 유형의 다이나믹 프로그래밍 문제가 출제되는 경우가 많다.

 

문제 8-5. 1로 만들기

정수 X가 주어질 때 정수 X에 사용할 수 있는 연산은 다음과 같이 4가지이다.

  1. X가 5로 나누어떨어지면, 5로 나눈다.
  2. X가 3으로 나누어떨어지면, 3으로 나눈다.
  3. X가 2로 나누어떨어지면, 2로 나눈다.
  4. X에서 1을 뺀다.

정수 X가 주어졌을 때, 연산 4개를 적절히 사용해서 1을 만들려고 한다. 연산을 사용하는 횟수의 최솟값을 출력하시오.

아이디어 및 코드

피보나치 수열 문제를 도식화했던 것처럼 함수 호출 과정을 그림으로 그려 보면 이해하는 데 도움이 된다.

문제에서 요구하는 내용을 점화식으로 표현해 본다. 그리고 이 점화식을 토대로 보텀업 다이나믹 프로그래밍으로 코드를 작성해 본다.

#include <iostream>
#include <stdlib.h>
using namespace std;

int x;
int dp[30000];

int main() {
	cin >> x;
	
	
	for (int i = 2; i <= x; i++) {
		dp[i] = dp[i - 1] + 1;
		if (i % 2 == 0) {
			dp[i] = __min(dp[i / 2] + 1, dp[i]);
		}
		if (i % 3 == 0) {
			dp[i] = __min(dp[i / 3] + 1, dp[i]);
		}
		if (i % 5 == 0) {
			dp[i] = __min(dp[i / 5] + 1, dp[i]);
		}
	}

	cout << dp[x] << "\n";
}

 

피드백

이해하는 데 정말 오래 걸린 문제이다. 물론 풀지도 못 했다. 문제에서 요구하는 점화식을 세울 수 있도록 많은 문제를 풀어 봐야겠다.

 

문제 8-6. 개미 전사

내 코드

// 8-6. 개미 전사
// 다시 풀기 (4/3 다시 풀었으나 틀림, ** 확인)

#include <iostream>
#include <vector>
#include <stdlib.h>
using namespace std;

int dp[100];
int n;
vector<int> arr;

int main() {
	cin >> n;
	for (int i = 0; i < n; i++) {
		int x;
		cin >> x;
		arr.push_back(x);
	}

	// dynamic programming (bottom up)
	dp[0] = arr[0];
	// dp[1] = arr[1]; // ** 틀렸어!!!!!!!!!!!!!
	dp[1] = max(arr[0], arr[1]);

	for (int i = 2; i < n; i++) {
		if (dp[i - 1] < dp[i - 2] + arr[i]) {
			dp[i] = dp[i - 2] + arr[i];
		}
		else {
			dp[i] = dp[i - 1];
		}
	}
	
	cout << dp[n - 1] << "\n";
}

피드백

점화식을 직접 세워 보았더니 얼추 맞았다. 처음에 d[1] 값을 넣을 때 d[0], d[1]을 비교해서 큰 것을 넣지 않고 a[1]을 넣어 버리는 실수를 했다.

 

 

 

 

 

 

 

 

 

 

 

'알고리즘 > 이것이 코딩 테스트다' 카테고리의 다른 글

[이코테/C++] 음료수 얼려 먹기  (0) 2022.05.31
09. 최단 경로  (0) 2022.05.10
07: 이진 탐색  (0) 2022.03.25
06: 정렬  (0) 2022.03.20
05: DFS, BFS  (0) 2022.03.14

순차 탐색

데이터를 앞에서부터 하나씩 차례대로 확인하는 방법.

 

이진 탐색

데이터들의 범위를 반으로 좁혀가면서 탐색하는 방법. 데이터가 정렬되어 있어야 한다. 시간 복잡도는 O(logN)이다.

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

int n, target;
vector<int> arr;

int binary_search(vector<int>& arr, int target, int start, int end) {
	while (start < end) {
		int mid = (start + end) / 2;
		if (arr[mid] == target)
			return mid;
		else if (arr[mid] > target) {
			end = mid - 1;
		}
		else {
			start = mid + 1;
		}
	}
	return -1;
}


int main()
{
	cin >> n >> target;
	for (int i = 0; i < n; i++) {
		int val;
		cin >> val;
		arr.push_back(val);
	}

	int result = binary_search(arr, target, 0, n - 1);
	if (result == -1)
		cout << "원소가 존재 X" << "\n";
	else
		cout << result + 1 << "\n";
}

 

 

파라메트릭 서치

최적화 문제를 예 혹은 아니오의 결정 문제로 바꾸어 해결하는 기법.

일반적으로 코딩 테스트에서의 파라메트릭 서치는 이진 탐색으로 해결할 수 있다.

 

 

문제 7-8. 떡볶이 떡 만들기

오늘 동빈이는 여행 가신 부모님을 대신해서 떡집 일을 하기로 했다. 오늘은 떡볶이 떡을 만드는 날이다. 동빈이네 떡볶이 떡은 재밌게도 떡볶이 떡의 길이가 일정하지 않다. 대신에 한 봉지 안에 들어 가는 떡의 총 길이는 절단기로 잘라서 맞춰준다.
절단기에 높이(H)를 지정하면 줄지어진 떡을 한 번에 절단한다. 높이가 H보다 긴 떡은 H 위의 부분이 잘릴 것이고, 낮은 떡은 잘리지 않는다.
예를 들어 높이가 19, 14, 10, 17cm인 떡이 나란히 있고 절단기 높이를 15cm로 지정하면 자른 뒤 떡의 높이는 15, 14, 10, 15cm가 될 것이다. 잘린 떡의 길이는 차례대로 4, 0, 0, 2cm이다. 손님은 6cm 만큼의 길이를 가져간다.
손님이 왔을 때 요청한 총 길이가 M일 때 적어도 M만큼의 떡을 얻기 위해 절단기에 설정할 수 있는 높이의 최댓값을 구하는 프로그램을 작성하시오.

 

입력 조건
첫째 줄에 떡의 개수 N과 요청한 떡의 길이 M이 주어진다.
(1 <= N <= 1,000,000, 1 <= M <= 2,000,000,000)
둘째 줄에는 떡의 개별 높이가 주어진다. 떡 높이의 총합은 항상 M 이상이므로, 손님은 필요한 양만큼 떡을 사갈 수 있다. 높이는 10억보다 작거나 같은 양의 정수 또는 0이다.

출력 조건
적어도 M만큼의 떡을 집에 가져가기 위해 절단기에 설정할 수 있는 높이의 최댓값을 출력한다.

 

내 코드

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

int n, m;
vector<int> arr;


int binary_search(vector<int>& arr, int start, int end) {
	while (start < end) {
		int mid = (start + end) / 2;
		int sum = 0;
		for (int i = 0; i < n; i++) {
			if(arr[i] - mid >= 0)
				sum += (arr[i] - mid);
		}
		if (sum < m) { // sum이 m보다 작다는 건 너무 많이 잘랐다는 뜻이잖아. mid가 작아져야.
			end = mid - 1;
		}
		else if (sum > m) { // sum이 m보다 크다는 건 너무 적게 잘랐다는 뜻. mid가 커져야.
			start = mid + 1;
		}
		else {
			return mid;
		}
	}
}

int main()
{
	cin >> n >> m;
	int max = 0;
	for (int i = 0; i < n; i++) {
		int val;
		cin >> val;
		arr.push_back(val);
		if (max <= val) max = val;
	}
	int result = binary_search(arr, 0, max);

	cout << arr[result] << "\n";
	
}

 

아이디어 및 답지

이진 탐색을 반복하면 답을 도출할 수 있다.

중간점의 값은 시간이 지날수록 최적화된 값이 되기 때문에, 과정을 반복하면서 조건에 맞는 중간값을 기록해 나간다.

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

int n, m;
vector<int> arr;


int binary_search(vector<int>& arr, int start, int end) {
	int result = 0;
	while (start < end) {
		int mid = (start + end) / 2;
		long long int sum = 0; // 1억 이상 담을 거라서.	
		for (int i = 0; i < n; i++) {
			if(arr[i] - mid > 0)
				sum += (arr[i] - mid);
		}
		if (sum < m) { 
			end = mid - 1;
		}
		else if (sum > m) { // 떡의 양이 충분하므로 오른쪽 부분 탐색. 최대한 덜 자르기 위해
			result = mid;
			start = mid + 1;
		}
	}
	return result;
}

int main()
{
	cin >> n >> m;
	for (int i = 0; i < n; i++) {
		int val;
		cin >> val;
		arr.push_back(val);
	}
	int result = binary_search(arr, 0, 1e9); // le9 == 표현할 수 있는 최댓값

	cout << arr[result] << "\n";
}

 

피드백

조건에 맞는 중간값을 탐색 과정에서 계속 기록했어야.

1e9?

long long int 자료형

 

 

문제 A27. 정렬된 배열에서 특정 수의 개수 구하기

N개의 원소를 포함하고 있는 수열이 오름차순으로 정렬되어 있습니다. 이때 이 수열에서 x가 등장하는 횟수를 계산하세요.
단, 이 문제의 시간 복잡도 O(logN)으로 알고리즘을 설계하지 않으면 '시간 초과' 판정을 받습니다.

입력 예시

7 2
1 1 2 2 2 2 3

출력 예시

4

 

아이디어 및 답지

CountByRange 이거 코테에서 자주 쓰인다. 팁 노트에 적어 두라고 함.

// chap15. 정렬된 배열에서 특정 수의 개수 구하기.
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int n, x;
vector<int> arr;

int count_by_range(vector<int>& v, int rightvalue, int leftvalue) {
	vector<int>::iterator right_index = upper_bound(v.begin(), v.end(), rightvalue);
	vector<int>::iterator left_index = lower_bound(v.begin(), v.end(), leftvalue);
	return right_index - left_index;
}

int main() {
	cin >> n >> x;
	for (int i = 0; i < n; i++) {
		int val;
		cin >> val;
		arr.push_back(val);
	}

	int result = count_by_range(arr, x, x);

	if (result == 0) {
		cout << "-1" << "\n";
	}
	else {
		cout << result << "\n";
	}
}

 

 

 

 

 

 

 

 

 

'알고리즘 > 이것이 코딩 테스트다' 카테고리의 다른 글

09. 최단 경로  (0) 2022.05.10
08: 다이나믹 프로그래밍  (0) 2022.03.27
06: 정렬  (0) 2022.03.20
05: DFS, BFS  (0) 2022.03.14
04: 구현  (0) 2022.03.13

개요: 정렬 알고리즘

데이터들을 특정 기준에 따라서 순서대로 나열한다.

 

 

 

선택 정렬

데이터들 중 가장 작은 데이터를 '선택'해서 맨앞의 데이터와 바꾼다.

N번만큼 가장 작은 수를 찾아서 맨앞으로 보내므로 N + N-1 + N-2 + ... 시간 복잡도는 O(N2)이다.

특정 리스트에서 가장 작은 데이터를 찾는 일이 코딩 테스트에서 잦으므로 선택 정렬 소스 코드를 자주 작성해 볼 것을 권장한다.

#include <iostream>
using namespace std;

int n = 10;
int target[10] = { 7,5,8,0,3,1,6,2,4,8 };

int main() {
	for (int i = 0; i < n; i++) {
		int min_index = i;
		for (int j = i + 1; j < n; j++) {
			if (target[min_index] > target[j]) {
				min_index = j;
			}
		}
		swap(target[i], target[min_index]);
	}
}

 

 

삽입 정렬

처리되지 않은 특정한 데이터를 한 개씩 골라서 적절한 위치(삽입될 데이터보다 작은 데이터를 만나면 그 위치에서 멈춘다)에 삽입한다.

첫 번째는 정렬되어 있다고 가정, 두 번째 원소부터 어떤 위치에 삽입할 것인지 판단한다.

시간 복잡도는 O(N^2)이지만, 최선의 경우 O(N)이다.

#include <iostream>
using namespace std;

int n = 10;
int target[10] = { 7,5,8,0,3,1,6,2,4,8 };

int main() {
	for (int i = 1; i < n; i++) {
		for (int j = i; j > 0; j--) {
			if (target[j] < target[j - 1]) {
				swap(target[j], target[j - 1]);
			}
			else
				break;
		}
	}
}

 

 

퀵 정렬

기준 데이터 피벗을 설정하고 그 기준 데이터보다 작은 데이터와 큰 데이터의 위치를 바꾼다.

가장 기본적인 퀵 정렬은 첫 번째 원소를 기준 데이터 피벗으로 설정한다.

평균 시간 복잡도는 O(NlogN), 최악의 경우 O(N^2)이다. (너비*높이 = N * logN = NlogN)

#include <iostream>
using namespace std;

int n = 10;
int target[10] = { 7,5,8,0,3,1,6,2,4,8 };


void quick_sort(int* target, int start, int end) {
	if (start >= end) 
		return;
	int pivot = start;
	int left = start + 1;
	int right = end;

	while (left <= right) {
		while (left <= end && target[left] <= target[pivot]) {
			left++;
		}
		while (right > start && target[right] >= target[pivot]) {
			right--;
		}
		if (left > right)
			swap(target[pivot], target[right]);
		else
			swap(target[left], target[right]);
	}
	quick_sort(target, start, right - 1);
	quick_sort(target, right + 1, end);
}

int main() {
	quick_sort(target, 0, n - 1);
}

 

 

계수 정렬

데이터 크기 범위가 제한되어 정수 형태로 표현할 수 있을 때 매우 빠르게 동작하는 정렬 알고리즘.

데이터의 개수가 N, 양수 데이터 중 최댓값이 K일 때 최악의 경우에도 O(N + K)를 보장한다.

때에 따라서 심각한 비효율성을 초래할 수 있다.

#include <iostream>
using namespace std;
#define MAX_VALUE 9

int n = 15;
int arr[15] = { 7,5,9,0,3,1,6,2,9,1,4,8,0,5,2 };
int cnt[MAX_VALUE + 1];


int main() {
	for (int i = 0; i < n; i++) {
		cnt[arr[i]] += 1;
	}
	for (int i = 0; i <= MAX_VALUE; i++) {
		for (int j = 0; j < cnt[i]; j++) {
			cout << i << ' ';
		}
	}
}

 

 

문제 6-4. 두 배열의 원소 교체

설명

동빈이는 두 개의 배열 A와 B를 가지고 있다. 두 배열은 N개의 원소로 구성되어 있으며, 배열의 원소는 모두 자연수이다. 동빈이는 최대 K 번의 바꿔치기 연산을 수행할 수 있는데, 바꿔치기 연산이란 배열 A에 있는 원소 하나와 배열 B에 있는 원소 하나를 골라서 두 원소를 서로 바꾸는 것을 말한다. 동빈이의 최종 목표는 배열 A의 모든 원소의 합이 최대가 되도록 하는 것이며, 여러분은 동빈이를 도와야한다.

 

N, K, 그리고 배열 A와 B의 정보가 주어졌을 때, 최대 K 번의 바꿔치기 연산을 수행하여 만들 수 있는 배열 A의 모든 원소의 합의 최댓값을 출력하는 프로그램을 작성하라.

예를 들어 N = 5, K = 3이고, 배열 A와 B가 다음과 같다고 해보자.

배열 A = [1, 2, 5, 4, 3]
배열 B = [5, 5, 6, 6, 5]

이 경우, 다음과 같이 세 번의 연산을 수행할 수 있다.

연산 1) 배열 A의 원소 '1'과 배열 B의 원소 '6'을 바꾸기
연산 2) 배열 A의 원소 '2'와 배열 B의 원소 '6'을 바꾸기
연산 3) 배열 A의 원소 '3'과 배열 B의 원소 '5'를 바꾸기

세 번의 연산 이후 배열 A와 배열 B의 상태는 다음과 같이 구성될 것이다.

배열 A = [6, 6, 5, 4, 5]
배열 B = [3, 5, 1, 2, 5]

이때 배열 A의 모든 원소의 합은 26이 되며, 이보다 더 합을 크게 만들 수는 없다.

 

입력

  • 첫 번째 줄: N, K 가 공백으로 구분되어 입력 (1 <= N <= 100,000, 0 <= K <= N)
  • 두 번째 줄: 배열 A의 원소들이 공백으로 구분되어 입력 (원소 a < 10,000,000인 자연수)
  • 세 번째 줄: 배열 B의 원소들이 공백으로 구분되어 입력 (원소 b < 10,000,000인 자연수)

출력

  • 최대 K번 바꿔치기 연산을 수행해서 가장 최대의 합을 갖는 A의 모든 원소 값의 합을 출력

 

입력 예시

5 3
1 2 5 4 3
5 5 6 6 5

출력 예시

26

아이디어

매번 배열 A에서의 작은 원소를 골라서 배열 B의 큰 원소와 바꾼다.

A는 오름차순, B는 내림차순으로 정렬한다.

두 배열의 원소를 첫 번째 인덱스부터 확인하면서 A 원소가 B 원소보다 작을 때만 교체를 진행한다.

두 배열의 원소가 최대 100,000개까지 입력될 수 있으므로 최악의 경우 O(NlogN)을 보장하는 알고리즘인 퀵 정렬을 사용해야 한다.

 

내 코드

// 6-4. 두 배열의 원소 교체
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

int n, k;
vector<int> v_a;
vector<int> v_b;

void change() {
	// ** 작은 원소나 큰 원소를 알아낼 때 sorting!!
	sort(v_a.begin(), v_a.end());
	sort(v_b.begin(), v_b.end(), greater<>());
	for (int i = 0; i < k; i++) {
		if(v_a[i] < v_b[i]) // ** 테케 틀렸을 것임
			swap(v_a[i], v_b[i]);
	}
}

int main()
{
	cin >> n >> k;

	for (int i = 0; i < n; i++) {
		int value;
		cin >> value;
		v_a.push_back(value);
	}
	for (int i = 0; i < n; i++) {
		int value;
		cin >> value;
		v_b.push_back(value);
	}

	change();

	int result = 0;
	for (int i = 0; i < n; i++) {
		result += v_a[i];
	}
	cout << result << "\n";
}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

'알고리즘 > 이것이 코딩 테스트다' 카테고리의 다른 글

08: 다이나믹 프로그래밍  (0) 2022.03.27
07: 이진 탐색  (0) 2022.03.25
05: DFS, BFS  (0) 2022.03.14
04: 구현  (0) 2022.03.13
03: Greedy 알고리즘  (0) 2022.03.08

스택/큐

탐색이란 많은 양의 데이터 중 원하는 데이터를 찾는 것.

대표적인 그래프 탐색 알고리즘으로는 DFS/BFS가 있음.

DFS/BFS를 배우기 전에 알아 두어야 할 자료구조가 바로 스택/큐 이다.

 

스택

선입후출, 후입선출의 자료구조.

입구와 출구가 같은 형태.

 

선입선출의 자료구조.

입구와 출구가 모두 뚫려 있는 터널 형태.

 

 

재귀 함수

자기 자신을 다시 호출하는 함수.

재귀 함수를 문제 풀이에 사용할 때는 함수의 종료 조건을 반드시 명시해야 한다. (컴퓨터가 함수를 연속적으로 호출하면 함수 정보가 메모리 내부의 스택 프레임에 쌓임)

함수도 후입선출

ㄴ 그래서 스택 라이브러리 대신 재귀 함수를 사용하기도 한다.

 

재귀 함수 예제: 팩토리얼

def factorial_recursive(n):
	if n <= 1:
    	return 1
    return n * factorial_recursive(n - 1)
    
print(factorial_recursive(5))

 

 

재귀 함수 예제: 유클리드 호제법

두 자연수 A, B (A>B)가 있을 때 A와 B의 최대공약수가 R이라면, B와 R의 최대공약수는 A와 B의 최대공약수와 같다.

def gdc(a, b):
	if a % b == 0:
    	return b
    else:
    	return gdc(b, a % b)
print(gdc(192, 162))

 

 

DFS

깊이 우선 탐색 알고리즘.

스택 자료구조 혹은 재귀 함수를 이용한다.

 

DFS: 동작 과정

스택에 탐색 시작 노드를 넣고 방문 처리를 한다.

"스택의 최상단 노드의 인접한 노드가 있다면 스택에 넣고 방문 처리를 한다. 인접한 노드가 없다면 스택의 최상단 노드를 꺼낸다".

""의 과정을 수행할 수 없을 때까지 반복한다.

 

DFS: 예제 코드

bool visited[9]; 
vector<int> graph[9]; // 자신과 연결되어 있는 노드들의 정보

void dfs(int x){
	visited[x] = true;
    cout << x << ' ';
    for(int i = 0; i < graph[x].size(); i++){
    	int y = graph[x][i];
        if (!visited[y])
        	dfs(y);
    }
}

 

BFS

너비 우선 탐색 알고리즘.

그래프에서 가까운 노드부터 우선적으로 탐색한다.

큐 자료구조를 이용한다.

 

BFS: 동작 과정

탐색 시작 노드를 큐에 집어넣고 방문 처리를 한다. 큐에서 꺼낸 노드의 인접 노드들 중 방문하지 않은 노드들을 큐에 모두 집어넣고 방문 처리를 한다. 큐가 비워질 때까지 이 과정을 반복한다.

 

BFS: 예제 코드

bool visited[9];
vector<int> graph[9];

void bfs(int start) {
	queue<int> q;
    q.push(start);
    visited[start] = true;
    while(!q.empty()) {
    	for(int i = 0; i < q.size(); i++) {
        	int y = graph[start][i];
            if(!visited[y]) {
            	q.push(y);
                visited[y] = true;
            }
        }
    }
}

 

 

문제 1. 음료수 얼려 먹기

N x M 크기의 얼음 틀이 있다. 구멍이 뚫려 있는 부분은 0, 칸막이가 존재하는 부분은 1로 표시된다. 구멍이 뚫려 있는 부분끼리 상, 하, 좌, 우로 붙어 있는 경우 서로 연결되어 있는 것으로 간주한다. 이때 얼음 틀의 모양이 주어졌을 때 생성되는 총 아이스크림의 개수를 구하는 프로그램을 작성하시오.
예시) 다음의 4 x 5 얼음 틀 예시에서는 아이스크림이 총 3개 생성된다.

입력 조건
첫 번째 줄에 얼음 틀의 세로 길이 N과 가로 길이 M이 주어진다.
(1 <= N, M <= 1,000)
두 번째 줄부터 N + 1번째 줄까지 얼음 틀의 형태가 주어진다.
이때 구멍이 뚫려있는 부분은 0, 그렇지 않은 부분은 1이다.

출력 조건
한 번에 만들 수 있는 아이스크림의 개수를 출력한다.

아이디어 및 풀이

모든 노드 지점에 대해 BFS/DFS를 수행해서 방문 처리가 된 지점에 대해서만 카운트를 수행하면 전체 연결 요소가 몇 개인지 계산할 수 있다.

#include <iostream>
using namespace std;

int graph[1001][1001];
int n, m;

bool dfs(int x, int y) {
	if (x <= -1 || x >= n || y <= -1 || y >= m) {
		return false;
	}
	if (graph[x][y] == 0) {
		graph[x][y] = 1;

		dfs(x - 1, y);
		dfs(x, y - 1);
		dfs(x + 1, y);
		dfs(x, y + 1);
		return true;
	}
	return false;
}

int main()
{
	cin >> n >> m;

	for (int i = 0; i < n; i++) {
		for (int j = 0; j < m; j++) {
			scanf("%1d", &graph[i][j]);
		}
	}

	int result = 0;
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < m; j++) {
			if (dfs(i, j)) {
				result += 1;
			}
		}
	}
	cout << result << "\n";
}

 

문제 2. 미로 찾기

미로 탈출

동빈이는 N X M 크기의 직사각형 형태의 미로에 갇혀 있다. 미로에는 여러 마리의 괴물이 있어 이를 피해 탈출해야 한다. 동빈이의 위치는 (1, 1) 이고 미로의 출구는 (N, M)의 위치에 존재하며 한 번에 한 칸씩 이동할 수 있다. 이때 괴물이 있는 부분은 0으로, 괴물이 없는 부분은 1로 표시되어 있다. 미로는 반드시 탈출할 수 있는 형태로 제시된다. 이때 동빈이가 탈출하기 위해 움직여야 하는 최소 칸의 개수를 구하시오. 칸을 셀 때는 시작 칸과 마지막 칸을 모두 포함해서 계산한다.

입력 조건

첫째 줄에 두 정수 N, M (4 <=N, M <= 200)이 주어집니다. 다음 N개의 줄에는 각각 M개의 정수(0 혹은 1)로 미로의 정보가 주어진다. 각각의 수들은 공백 없이 붙어서 입력으로 제시된다. 또한 시작 칸과 마지막 칸은 항상 1이다.

출력 조건

첫째 줄에 최소 이동 칸의 개수를 출력한다.

입력 예시

5 6
101010
111111
000001
111111
111111

출력 예시

10

 

아이디어 및 풀이

BFS 알고리즘을 이용한다. 간선의 거리가 모두 같을 때 최단 거리를 탐색하기 위한 알고리즘이다.

#include <iostream>
#include <queue>
using namespace std;

int graph[201][201];
int n, m;
 
int dx[] = { -1, 1, 0, 0 };
int dy[] = { 0, 0, -1, 1 };

int bfs(int x, int y) {
	queue<pair<int, int>> q;
	q.push({ x, y });

	while (!q.empty()) {
		int x = q.front().first;
		int y = q.front().second;
		
		for (int i = 0; i < 4; ++i) {
			int nx = x + dx[i];
			int ny = y + dy[i];
			
			if (nx < 0 || nx >= n || ny < 0 || ny >= m)
				continue;
			if (graph[nx][ny] == 0)
				continue;
			if (graph[nx][ny] == 1) {
				graph[nx][ny] = graph[x][y] + 1;
				q.push({ nx, ny });
			}
		}
	}
	return graph[n - 1][m - 1];
}


int main()
{
	cin >> n >> m;

	for (int i = 0; i < n; i++) {
		for (int j = 0; j < m; j++) {
			scanf("%1d", &graph[i][j]);
		}
	}
	cout << bfs(0, 0) << "\n";
}

'알고리즘 > 이것이 코딩 테스트다' 카테고리의 다른 글

08: 다이나믹 프로그래밍  (0) 2022.03.27
07: 이진 탐색  (0) 2022.03.25
06: 정렬  (0) 2022.03.20
04: 구현  (0) 2022.03.13
03: Greedy 알고리즘  (0) 2022.03.08

개요

구현 유형의 문제란 풀이를 떠올리는 것은 쉽지만 소스 코드로 옮기기 어려운 문제.

주로 간단한 알고리즘이지만 지나치게 긴 코드, 실수 연산, 특정 소수점 자리 출력, 문자열을 특정 기준에 따라 처리, 적절한 라이브러리를 찾아서 사용하는 문제가 예시이다.

일반적으로 알고리즘 문제에서의 2차원 공간은 행렬의 의미.

시뮬레이션 및 완전 탐색 문제에서는 방향 벡터가 자주 활용.

 

 

문제 1. 상하좌우

 

  • 여행가 A는 N * N 크기의 정사각형 공간 위에 서있다. 이공간은 1 * 1 크기의 정사각형으로 나누어져 있다.
    가장 왼쪽 위 좌표는 (1, 1)이며 가장 오른 쪽 아래 좌표는 (N, N)에 해당한다. 여행가 A는 상,  , ,우 방향으로 이동할 수 있으며
    시작좌표는 항상(1, 1)이다. 우리앞에는 여행가가 A가 이동할 계획서가 놓여있다.
  • 계획서에는 하나의 줄에 띄어쓰기를 기준으로 하여 L, R, U, D중 하나의 문자가 반복적으로 적혀 있다. 각 문자의 의미는
    다음과 같다.

    L : 왼쪽으로 한 칸 이동
    R : 오른쪽으로 한 칸 이동
    U : 위로 한 칸 이동
    D : 아래로 한 칸 이동
  • 이때 여행가 A가 N × N 크기의 정사각형 공간을 벗어나는 움직임은 무시된다
    예를 들어 (1, 1)의 위치에서 L 혹은 U를 만나면 무시된다
    다음은 N = 5인 지도와 계획이다

 

내 풀이

#include <iostream>
#include <string>

using namespace std;

int main() 
{
	ios::sync_with_stdio(0);
	cin.tie(0);

	int n;
	string s;
	cin >> n;
	cin >> s;

	int x=1, y=1;
	int l = s.length();
	for (int i = 0; i < l; i++) {
		switch (s[i]) {
		case 'L':
			if (x > 1)
				x--;
			break;
		case 'R':
			if (x < n)
				x++;
			break;
		case 'U':
			if (y > 1)
				y--;
			break;
		case 'D':
			if (y < n)
				y++;
			break;
		}
	}

	cout << x << " " << y << "\n";
}

 

 

아이디어 및 풀이

요구사항대로 충실히 구현하면 된다.

일련의 명령에 따라 개체를 차례대로 이동시킨다는 점에서 시뮬레이션 유형으로 분류되기도 하나, 구현이 중요한 대표적인 문제 유형이다.

#include <iostream>
#include <string>

using namespace std;

int n;
string plans;
int x = 1, y = 1;

int dx[4] = { 0,0,-1,1 };
int dy[4] = { -1,1,0,0 };
char moveTypes[4] = { 'L', 'R', 'U', 'D' };

int main() 
{
	ios::sync_with_stdio(0);
	cin.tie(0);

	cin >> n;
	getline(cin, plans);
	
	for (int i = 0; i < plans.size(); i++) {
		char plan = plans[i];
		int nx = -1, ny = -1;
		for (int j = 0; j < 4; j++) {
			if (plan == moveTypes[j]) {
				nx = x + dx[j];
				ny = y + dy[j];
			}
		}
		if (nx < 1 || ny < 1 || nx > n || ny > n) continue;
		x = nx;
		y = ny;
	}

}

 

피드백

방향 벡터 이용

 

 

문제 2. 시각

  • 정수 N이 입력되면 00시 00분 00초부터 N시 59분 59초까지의 모든 시각 중에서 3이 하나라도 포함되는
    모든 경우의 수를 구하는 프로그램을 작성
    하세요. 예를 들어 1을 입력했을 때
    다음은 3이 하나라도 포함되어 있으므로 세어야 하는 시각입니다.
    • 00시 00분 03초
    • 00시 13분 30초
  • 반면에 다음은 3이 하나도 포함되어 있지 않으므로 세면 안 되는 시각입니다.
    • 00시 02분 55초
    • 01시 27분 45초

 

아이디어 및 풀이

하루는 24*60*60=86400초이므로, 모든 시각의 경우를 하나씩 세서 풀 수 있는 문제이다.

이러한 유형은 Brute Forcing 문제 유형이라고 불린다.

#include <iostream>
#include <string>

using namespace std;

int n;
int main() 
{
	ios::sync_with_stdio(0);
	cin.tie(0);

	cin >> n;
	string s;

	int cur = 0, result = 0;

	for (int hour = 0; hour <= n; ++hour) {
		for (int min = 0; min < 60; ++min) {
			for (int sec = 0; sec < 60; ++sec) {
				if (hour % 10 == 3 || hour / 10 == 3 
					|| min % 10 == 3 || min / 10 == 3 
					|| sec % 10 == 3 || sec / 10 == 3) {
					result++;
				}
			}
		}
	}
	cout << result << "\n";
}

 

 

문제 3. 왕실의 나이트

행복 왕국의 왕실 정원은 체스판과 같은 8 x 8 좌표 평면이다. 왕실 정원의 특정한 한 칸에 나이트가 서 있다. 나이트는 매우 충성스러운 신하로서 매일 무술을 연마한다.

 

나이트는 말을 타고 있기 때문에 이동을 할 때는 L자 형태로만 이동할 수 있으며 정원 밖으로는 나갈 수 없다. 나이트는 특정한 위치에서 다음과 같은 2가지 경우로 이동할 수 있다.

  • 수평으로 두 칸 이동한 뒤에 수직으로 한 칸 이동하기
  • 수직으로 두 칸 이동한 뒤에 수평으로 한 칸 이동하기

 

이처럼 8 x 8 좌표 평면상에서 나이트의 위치가 주어졌을 때 나이트가 이동할 수 있는 경우의 수를 출력하는 프로그램을 작성하시오. 이때 왕실의 정원에서 행 위치를 표현할 때는 1부터 8로 표현하며, 열 위치는 a부터 h로 표현한다.

 

예를 들어 만약 나이트가 a1에 있을 때 이동할 수 있는 경우의 수는 다음 2가지 이다. a1의 위치는 좌표평면에서 구석의 위치에 해당하며 나이트는 정원의 밖으로는 나갈 수 없기 때문이다.

  1. 오른쪽으로 두 칸 이동 후 아래로 한 칸 이동하기(c2)
  2. 아래로 두 칸 이동 후 오른쪽으로 한 칸 이동하기(b3)

또 다른 예로 나이트가 c2에 위치해 있다면 나이트가 이동할 수 있는 경우의 수는 6가지이다.

 

입력 조건

  • 첫째 줄에 8 x 8 좌표 평면상에서 현재 나이트가 위치한 곳의 좌표를 나타내는 두 문자로 구성된 문자열이 입력된다. 입력 문자는 a1처럼 열과 행으로 이뤄진다.

 

출력 조건

  • 첫째 줄에 나이트가 이동할 수 있는 경우의 수를 출력하시오.

 

입력 예시

a1

 

출력 예시

2

 

내 풀이

#include <iostream>
#include <string>

using namespace std;

struct t {
	int x;
	int y;
};

t moveTypes[8] = { {-1, -2},
	{1, -2},
	{-1, 2},
	{1, 2},
	{-2, -1},
	{2, -1},
	{-2, 1},
	{2, 1}
};

int main() 
{
	ios::sync_with_stdio(0);
	cin.tie(0);

	string s;

	cin >> s;

	t pt;
	pt.x = s[0] - 96;
	pt.y = s[1] - 48;

	int cnt = 0;

	// char a는 97
	for (int i = 0; i < 8; i++) {
		if ((pt.x + moveTypes[i].x >= 1 && pt.x + moveTypes[i].x <= 8) &&
			(pt.y + moveTypes[i].y >= 1 && pt.y + moveTypes[i].y <= 8)) {
			cnt++;
		}
	}
	cout << cnt << "\n";
}

 

아이디어 및 풀이

나이트의 8가지 방향에 대한 방향 벡터를 정의한다. (간결한 코드 작성 위함)

using namespace std;

string input;
int dx[] = { -2, -1, 1, 2, 2, 1, -1, -2 };
int dy[] = { -1, -2, -2, -1, 1, 2, 2, 1 };

int main() 
{
	cin >> input;
	int row = input[1] - '0';
	int col = input[0] - 'a' + 1;

	int result = 0;
	for (int i = 0; i < 8; i++) {
		int nextRow = row + dx[i];
		int nextCol = col + dy[i];
		if (nextRow >= 1 && nextRow <= 8
			&& nextCol >= 1 && nextCol <= 8) {
			result++;
		}
	}
	cout << result << "\n";
}

 

 

문제 4. 문자열 재정렬

  • 알파벳 대문자와 숫자(0~9)로만 구성된 문자열이 입력으로 주어집니다. 이때 모든 알파벳을 오른차순으로 정렬하여 이어서 출력한 뒤에, 그 뒤에 모든 숫자를 더한 값을 이어서 출력합니다.
  • 예를 들어 K1KA5CB7이라는 값이 들어오면 ABCKK13을 출력합니다.

 

내 코드

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

using namespace std;

int main() 
{
	string s;
	cin >> s;
	
	int num = 0;
	vector<char> v;
	for (int i = 0; i < s.length(); i++) {
		if (s[i] <= '9') {
			num += (s[i] - '0');
		}
		if (s[i] > '9') {
			v.push_back(s[i]);
		}
	}

	sort(v.begin(), v.end());
	
	for (int i = 0; i < v.size(); i++) {
		cout << v[i];
	}
	cout << num << "\n";
}

 

 

아이디어 및 풀이

"구현" 문제이기 때문에 요구사항대로 충실히 구현하면 정답이다.

별도의 변수로 숫자, 알파벳을 저장한다.

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

using namespace std;

int main() 
{
	string s;
	cin >> s;

	vector<char> result;
	int value = 0;

	for (int i = 0; i < s.size(); i++) {
		if (isalpha(s[i])) {
			result.push_back(s[i]);
		}
		else {
			value += s[i] - '0';
		}
	}

	sort(result.begin(), result.end());

	for (int i = 0; i < result.size(); i++) {
		cout << result[i];
	}
	if (value != 0)
		cout << value;
	cout << "\n";
}

 

 

피드백

숫자가 존재하지 않는 경우도 생각해서 짰어야..

'알고리즘 > 이것이 코딩 테스트다' 카테고리의 다른 글

08: 다이나믹 프로그래밍  (0) 2022.03.27
07: 이진 탐색  (0) 2022.03.25
06: 정렬  (0) 2022.03.20
05: DFS, BFS  (0) 2022.03.14
03: Greedy 알고리즘  (0) 2022.03.08

+ Recent posts