코딩테스트에서는 제한된 시간 내에 문제를 해결해야 하므로, 표준 라이브러리의 자료구조와 알고리즘, 내장 함수를 잘 이해하고 숙지하는 것이 필요하다. 표준 라이브러리는 효율적으로 구현된 검증된 코드로 구성되어 있어 직접 알고리즘을 구현하는 것보다 빠르고 안정적인 해결책을 제공하며, 시간 복잡도 면에서도 최적화되어 있어 불필요한 연산을 줄일 수 있다. 예를 들어, 정렬이 필요할 때 직접 정렬 알고리즘을 구현하는 것보다 sorted() 또는 heapq를 활용하는 것이 훨씬 효율적이며, 스택과 큐가 필요한 경우 deque를 사용하면 시간 복잡도를 줄일 수 있다. 또한, 탐색과 해싱이 필요한 문제에서는 set과 dict가 O(1)에 가까운 접근 속도를 제공하기 때문에 성능 차이가 크게 발생할 수 있다. 결국, 표준 라이브러리를 잘 활용하면 문제 풀이 시간을 단축할 수 있고, 불필요한 구현 실수를 방지하며, 더 많은 문제를 해결할 수 있는 경쟁력이 생긴다.
1. 1 C++ 자료구조 라이브러리
C++ 표준 라이브러리(STL)는 효율적인 자료구조를 제공하여 알고리즘 구현을 단순화하고 성능을 최적화할 수 있도록 돕는다. vector, deque, list와 같은 컨테이너는 동적 배열과 연결 리스트 기반의 자료구조를 제공하며, stack과 queue는 후입선출(LIFO)과 선입선출(FIFO) 구조를 쉽게 다룰 수 있도록 한다. set과 map은 자동 정렬 및 로그 시간 탐색을 지원하는 트리 기반 컨테이너이며, unordered_set과 unordered_map은 해시 기반으로 평균 O(1)의 탐색 속도를 제공한다. 또한, priority_queue는 힙 기반의 우선순위 큐를 지원하여 최댓값 또는 최솟값을 빠르게 추출할 수 있다. 이처럼 STL을 활용하면 직접 구현할 필요 없이 최적화된 자료구조를 사용할 수 있어 코드의 간결성과 성능을 동시에 확보할 수 있다.
1.1 vector
vector는 동적 배열을 제공하는 컨테이너로, 연속적인 메모리 블록을 사용하여 데이터를 저장한다. 따라서 인덱스를 통한 랜덤 접근이 빠르며(O(1)), 삽입과 삭제는 O(n)의 시간이 걸릴 수 있다. 크기가 자동으로 증가하며, capacity() 함수를 통해 내부 메모리 할당 크기를 확인할 수 있다. reserve()를 사용하면 미리 공간을 할당하여 재할당 횟수를 줄일 수 있으며, shrink_to_fit()을 이용해 불필요한 메모리를 줄일 수도 있다. vector는 크기가 가변적인 배열을 필요로 할 때 유용하며, 특히 데이터를 자주 추가 및 삭제하지 않고 랜덤 접근이 중요한 경우 가장 적합한 선택이다.
#include <iostream>
#include <vector>
int main() {
std::vector<int> v = {1, 2, 3, 4, 5};
v.push_back(6);
v.insert(v.begin() + 2, 10);
v.erase(v.begin() + 1);
v.reserve(100);
std::cout << "Size: " << v.size() << ", Capacity: " << v.capacity() << '\n';
}- push_back(value): 맨 뒤에 값을 추가한다.
- pop_back(): 맨 뒤의 값을 제거한다.
- size(): 요소의 개수를 반환한다.
- clear(): 모든 요소를 제거한다.
- resize(new_size): 크기를 변경한다.
- at(index): 특정 인덱스의 요소를 반환한다.
- sort(begin, end): 범위를 정렬한다(헤더 <algorithm> 필요).
1.2 List
list는 이중 연결 리스트를 구현한 컨테이너로, 삽입과 삭제가 O(1)로 빠르지만 인덱스를 통한 접근은 O(n)으로 느리다. push_front()와 push_back()을 사용해 앞뒤로 데이터를 추가할 수 있으며, pop_front()와 pop_back()으로 삭제할 수도 있다. 리스트 내부에서 노드들은 포인터를 통해 연결되므로 중간 삽입 및 삭제 연산이 빠르다. 하지만 연속적인 메모리를 사용하지 않으므로 vector에 비해 메모리 오버헤드가 크다. 따라서 list는 요소의 빈번한 추가 및 삭제가 필요하지만, 랜덤 접근이 적은 경우에 적합하다.
#include <iostream>
#include <list>
int main() {
std::list<int> l = {1, 2, 3, 4, 5};
l.push_front(0);
l.push_back(6);
l.insert(++l.begin(), 10);
l.erase(++l.begin());
l.reverse();
l.sort();
for (int x : l) std::cout << x << " ";
}- push_back(value): 맨 뒤에 값을 추가한다.
- push_front(value): 맨 앞에 값을 추가한다.
- pop_back(): 맨 뒤 값을 제거한다.
- pop_front(): 맨 앞 값을 제거한다.
- insert(it, value): 특정 위치에 값을 삽입한다.
- erase(it): 특정 위치의 값을 제거한다
1.3 deque
deque는 양쪽에서 빠르게 삽입과 삭제가 가능한 컨테이너로, 내부적으로 여러 개의 작은 배열을 관리하는 방식으로 동작한다. push_front()와 push_back()으로 양쪽에서 요소를 추가할 수 있으며, pop_front()와 pop_back()을 이용해 삭제할 수도 있다. deque는 vector와 다르게 크기 변경이 발생할 때 전체 데이터를 재할당하지 않아 효율적이지만, vector보다 캐시 효율성이 떨어질 수 있다. 따라서 앞뒤에서의 삽입 및 삭제가 자주 발생하는 경우에 적합하다.
#include <iostream>
#include <deque>
int main() {
std::deque<int> dq = {1, 2, 3, 4, 5};
dq.push_front(0);
dq.push_back(6);
dq.pop_front();
dq.pop_back();
for (int x : dq) std::cout << x << " ";
}- push_front(value): 맨 앞에 값을 추가한다.
- push_back(value): 맨 뒤에 값을 추가한다.
- pop_front(): 맨 앞의 값을 제거한다.
- pop_back(): 맨 뒤의 값을 제거한다.
- front(): 맨 앞의 값을 반환한다.
- back(): 맨 뒤의 값을 반환한다.
1.4 Stack
stack은 후입선출(LIFO, Last In First Out) 방식의 컨테이너 어댑터로, vector 또는 deque를 기반으로 동작한다. push()를 통해 데이터를 추가하고, pop()을 통해 마지막에 추가된 데이터를 제거할 수 있다. 또한 top()을 사용하여 가장 최근에 추가된 데이터를 확인할 수 있다. stack은 재귀적인 문제나 백트래킹 문제를 해결할 때 유용하게 사용된다.
#include <iostream>
#include <stack>
int main() {
std::stack<int> s;
s.push(1);
s.push(2);
s.push(3);
std::cout << s.top() << '\n'; // 3
s.pop();
std::cout << s.top() << '\n'; // 2
}- push(value): 스택의 맨 위에 값을 추가한다.
- pop(): 스택의 맨 위 값을 제거한다.
- top(): 스택의 맨 위 값을 반환한다.
- empty(): 스택이 비어 있는지 확인한다.
- size(): 스택의 크기를 반환한다.
1.5 queue
queue는 선입선출(FIFO, First In First Out) 방식의 컨테이너 어댑터로, deque를 기반으로 동작한다. push()를 사용해 데이터를 추가하고, pop()을 사용해 가장 먼저 추가된 데이터를 제거할 수 있다. front()는 가장 오래된 요소를, back()은 가장 최근에 추가된 요소를 참조한다. 주로 작업 스케줄링, BFS(너비 우선 탐색) 알고리즘 등에 사용된다.
#include <iostream>
#include <queue>
int main() {
std::queue<int> q;
q.push(1);
q.push(2);
q.push(3);
std::cout << q.front() << '\n'; // 1
q.pop();
std::cout << q.front() << '\n'; // 2
}- push(value): 큐의 맨 뒤에 값을 추가한다.
- pop(): 큐의 맨 앞 값을 제거한다.
- front(): 큐의 맨 앞 값을 반환한다.
- back(): 큐의 맨 뒤 값을 반환한다.
- empty(): 큐가 비어 있는지 확인한다.
- size(): 큐의 크기를 반환한다.
1.6 set
set은 중복을 허용하지 않으며 자동으로 정렬된 데이터를 저장하는 컨테이너로, Red-Black Tree를 기반으로 구현된다. insert()를 사용해 요소를 추가하고, erase()로 삭제할 수 있으며, find()로 특정 요소를 찾을 수 있다. 모든 연산의 평균 시간 복잡도는 O(log n)이다.
#include <iostream>
#include <set>
int main() {
std::set<int> s = {4, 2, 3, 1, 5};
s.insert(6);
s.erase(2);
for (int x : s) std::cout << x << " ";
}- insert(value): 값을 추가한다.
- erase(value): 값을 제거한다.
- find(value): 값을 찾는다. 없으면 end() 반환.
- count(value): 값이 존재하면 1, 아니면 0 반환.
- clear(): 모든 요소를 제거한다.
unordered_set은 해시 테이블을 기반으로 하며, 요소의 순서를 유지하지 않지만 O(1)의 평균 탐색 성능을 제공한다. 하지만 해시 충돌이 발생하면 최악의 경우 O(n)까지 성능이 저하될 수 있다.
#include <iostream>
#include <unordered_set>
int main() {
std::unordered_set<int> us = {4, 2, 3, 1, 5};
us.insert(6);
us.erase(2);
for (int x : us) std::cout << x << " ";
}1.7 map
map은 키-값 쌍을 저장하는 연관 컨테이너로, 키가 자동으로 정렬된다. insert() 또는 operator[]를 사용해 값을 추가하고, erase()로 삭제할 수 있다. 키를 기반으로 빠른 검색이 가능하며, 평균 연산 시간 복잡도는 O(log n)이다.
#include <iostream>
#include <map>
int main() {
std::map<std::string, int> m;
m["apple"] = 5;
m["banana"] = 3;
m["cherry"] = 7;
for (auto &[key, value] : m) std::cout << key << ": " << value << "\n";
}
unordered_map은 해시 테이블 기반의 연관 컨테이너로, 키-값 쌍을 저장하며 O(1)의 평균 탐색 성능을 제공한다. 키의 정렬이 필요하지 않은 경우 map보다 빠르게 동작할 수 있다.
#include <iostream>
#include <unordered_map>
int main() {
std::unordered_map<std::string, int> um;
um["apple"] = 5;
um["banana"] = 3;
for (auto &[key, value] : um) std::cout << key << ": " << value << "\n";
}
- insert({key, value}): 키-값 쌍을 추가한다.
- erase(key): 특정 키를 제거한다.
- find(key): 특정 키를 찾는다.
- operator[key]: 키에 해당하는 값을 반환한다.
1.8 priority_queue
priority_queue는 우선순위 큐(priority queue)를 제공하는 컨테이너 어댑터로, 기본적으로 최대 힙(max heap) 구조를 사용하여 가장 큰 값이 먼저 나오는 방식으로 동작한다. 내부적으로 힙(heap) 자료구조를 사용하며, 삽입과 삭제 연산의 시간 복잡도는 O(log n)이다. push()를 사용해 요소를 추가하고, pop()을 통해 가장 높은 우선순위를 가진 요소를 제거할 수 있다. 기본적으로 priority_queue<int>는 내림차순(최대 힙)으로 정렬되지만, greater<type>을 이용해 최소 힙(min heap)으로 설정할 수도 있다. 우선순위 큐는 작업 스케줄링, 다익스트라 알고리즘, 이벤트 처리 등에 사용된다.
#include <iostream>
#include <queue>
#include <vector>
int main() {
std::priority_queue<int> maxPQ; // 최대 힙 (default)
std::priority_queue<int, std::vector<int>, std::greater<int>> minPQ; // 최소 힙
maxPQ.push(3);
maxPQ.push(5);
maxPQ.push(1);
maxPQ.push(4);
std::cout << "Max Heap: ";
while (!maxPQ.empty()) {
std::cout << maxPQ.top() << " "; // 5 4 3 1
maxPQ.pop();
}
minPQ.push(3);
minPQ.push(5);
minPQ.push(1);
minPQ.push(4);
std::cout << "\nMin Heap: ";
while (!minPQ.empty()) {
std::cout << minPQ.top() << " "; // 1 3 4 5
minPQ.pop();
}
}- push(value): 값을 추가한다.
- pop(): 최댓값(또는 최솟값)을 제거한다.
- top(): 최댓값(또는 최솟값)을 반환한다.
- empty(): 비어 있는지 확인한다.
1.9 string
string은 동적 크기를 가지는 문자열 컨테이너로, C 스타일의 char 배열보다 사용이 편리하며 다양한 문자열 조작 기능을 제공한다. + 연산자를 사용하여 문자열을 연결할 수 있으며, append()를 사용하면 뒤에 문자열을 추가할 수 있다. substr()을 이용해 부분 문자열을 추출하고, find()를 사용해 특정 문자열을 검색할 수 있다. replace()는 특정 부분을 다른 문자열로 대체할 수 있으며, erase()를 사용하면 문자열의 일부를 삭제할 수도 있다. string은 텍스트 데이터를 다룰 때 가장 많이 사용되는 컨테이너이며, 문자열 검색, 변환, 조작 등에 필수적이다.
#include <iostream>
#include <string>
int main() {
std::string s = "Hello, World!";
s.append(" C++"); // 문자열 추가
s.insert(5, " my"); // 특정 위치에 삽입
s.replace(7, 2, "awesome"); // 부분 문자열 교체
s.erase(5, 3); // 특정 부분 삭제
s = s.substr(0, 5); // 부분 문자열 추출
std::cout << "Modified string: " << s << '\n';
std::string text = "abcdefg";
std::size_t found = text.find("cd");
if (found != std::string::npos) {
std::cout << "Found at index: " << found << '\n';
}
std::reverse(text.begin(), text.end());
std::cout << "Reversed string: " << text << '\n';
}
삽입 및 삭제
- append(str) 또는 +=: 문자열을 추가한다.
- insert(pos, str): 특정 위치에 문자열을 삽입한다.
- erase(pos, len): 특정 위치에서 지정한 길이만큼 문자열을 삭제한다.
- clear(): 문자열을 비운다.
탐색 및 조회
- size() 또는 length(): 문자열의 길이를 반환한다.
- find(str): 문자열에서 특정 문자열 또는 문자를 찾고, 시작 위치를 반환한다(없으면 std::string::npos 반환).
- rfind(str): 뒤에서부터 문자열을 검색한다.
- substr(pos, len): 특정 위치에서 길이만큼 부분 문자열을 반환한다.
- at(index): 특정 인덱스의 문자를 반환한다(경계 체크 포함).
변환 및 조작
- replace(pos, len, str): 문자열의 일부를 다른 문자열로 교체한다.
- to_string(num): 숫자를 문자열로 변환한다.
- stoi(str) 또는 stol(str): 문자열을 정수로 변환한다.
비교
- compare(str): 문자열을 비교하여 같으면 0, 작으면 음수, 크면 양수를 반환한다.
문자열 처리
- empty(): 문자열이 비어 있는지 확인한다.
- resize(n): 문자열 크기를 조정한다.
- swap(str): 두 문자열의 내용을 교환한다.
2. 알고리즘
2.1 algorithm
algorithm 헤더는 다양한 알고리즘 함수들을 제공하며, 정렬, 탐색, 조합, 변환 등 다목적 작업을 쉽게 수행할 수 있다.
정렬 및 정리
- sort(begin, end): 지정한 범위를 오름차순으로 정렬한다.
- reverse(begin, end): 지정한 범위를 뒤집는다.
- unique(begin, end): 인접한 중복 요소를 제거한다(정렬된 상태 필요).
- rotate(begin, new_begin, end); 컨테이너의 요소를 회전시킨다. 첫 번째 요소를 새로운 시작 위치로 옮기고, 나머지 요소들을 순환 이동한다.
- partition(begin, end, condition); 주어진 조건에 따라 컨테이너를 분할한다. 조건을 만족하는 요소들은 앞쪽에, 만족하지 않는 요소들은 뒤쪽에 배치된다.
- merge(begin1, end1, begin2, end2, output); 이진 탐색
탐색
- lower_bound(begin, end, value): 정렬된 범위에서 value 이상의 첫 위치를 반환한다.
- upper_bound(begin, end, value): 정렬된 범위에서 value보다 큰 첫 위치를 반환한다.
- binary_search(begin, end, value): 정렬된 범위에서 value 존재 여부를 확인한다.
- find(begin, end, value); 특정 값을 찾아 첫 번째 위치를 반환한다. 값이 없으면 end()를 반환한다
- binary_search(begin, end, value);
조합 및 순열
- next_permutation(begin, end): 다음 순열로 변환한다.
- prev_permutation(begin, end): 이전 순열로 변환한다.
기타 유용한 함수
- max(a, b), min(a, b): 최대값과 최소값을 반환한다.
- accumulate(begin, end, init): 범위의 합을 계산한다(헤더 <numeric> 필요).
- count(begin, end, value): 범위에서 특정 값의 개수를 세어 반환한다.
2.2 cmath
cmath 헤더는 수학적 연산을 위한 함수를 제공한다. 삼각 함수, 지수 함수, 로그, 제곱근, 절대값 등을 다룰 수 있다.
기본 수학 연산
- abs(x): 절대값을 반환한다(정수/실수 모두 사용 가능).
- pow(base, exp): base를 exp 제곱한 값을 반환한다.
- sqrt(x): 제곱근을 반환한다.
삼각 함수
- sin(x), cos(x), tan(x): 각각 사인, 코사인, 탄젠트 값을 반환한다.
- asin(x), acos(x), atan(x): 역삼각 함수 값을 반환한다.
- atan2(y, x): y/x의 아크탄젠트를 반환한다(각도는 라디안).
로그 및 지수
- log(x): 자연로그(ln(x)\ln(x))를 반환한다.
- log10(x): 상용로그(log10(x)\log_{10}(x))를 반환한다.
- exp(x): exe^x 값을 반환한다.
반올림 및 절삭
- ceil(x): 올림값을 반환한다.
- floor(x): 내림값을 반환한다.
- round(x): 반올림값을 반환한다.
3. 사용자 정의 함수
// 최대공약수 (GCD)
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
// 최소공배수 (LCM)
int lcm(int a, int b) { return a / gcd(a, b) * b; }
// 소수 판별
bool isPrime(int n) {
if (n <= 1) return false;
for (int i = 2; i * i <= n; ++i)
if (n % i == 0) return false;
return true;
}
// 팩토리얼 계산
long long factorial(int n) {
return n == 0 ? 1 : n * factorial(n - 1);
}
// 좌표 이동 (상, 하, 좌, 우)
const int dx[4] = {-1, 1, 0, 0};
const int dy[4] = {0, 0, -1, 1};
// 빠른 제곱 계산 (거듭제곱)
long long power(long long base, int exp) {
long long result = 1;
while (exp > 0) {
if (exp % 2 == 1) result *= base;
base *= base;
exp /= 2;
}
return result;
}
// nCr 조합 계산
long long combination(int n, int r) {
if (r > n) return 0;
if (r == 0 || r == n) return 1;
return combination(n - 1, r - 1) + combination(n - 1, r);
}
// 범위 내의 소수 구하기 (에라토스테네스의 체)
vector<int> sieve(int n) {
vector<int> primes;
vector<bool> is_prime(n + 1, true);
is_prime[0] = is_prime[1] = false;
for (int i = 2; i <= n; ++i) {
if (is_prime[i]) {
primes.push_back(i);
for (int j = i * 2; j <= n; j += i) {
is_prime[j] = false;
}
}
}
return primes;
}
// 유클리드 거리 계산
double euclideanDistance(int x1, int y1, int x2, int y2) {
return sqrt(pow(x2 - x1, 2) + pow(y2 - y1, 2));
}
// 문자열 반전
string reverseString(const string& str) {
return string(str.rbegin(), str.rend());
}
// 문자열을 공백 기준으로 분할
vector<string> split(const string& str, char delimiter) {
vector<string> tokens;
string token;
istringstream tokenStream(str);
while (getline(tokenStream, token, delimiter)) {
tokens.push_back(token);
}
return tokens;
}
// 숫자의 자리수 합 구하기
int digitSum(int n) {
int sum = 0;
while (n > 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
// 이진수로 변환
string toBinary(int n) {
string binary;
while (n > 0) {
binary.push_back((n % 2) + '0');
n /= 2;
}
reverse(binary.begin(), binary.end());
return binary.empty() ? "0" : binary;
}
// 배열의 최댓값 찾기
int maxElement(const vector<int>& arr) {
return *max_element(arr.begin(), arr.end());
}
// 배열의 최솟값 찾기
int minElement(const vector<int>& arr) {
return *min_element(arr.begin(), arr.end());
}
// 배열 합 계산
int sumArray(const vector<int>& arr) {
return accumulate(arr.begin(), arr.end(), 0);
}
// 중복 제거 후 정렬된 배열 반환
vector<int> uniqueSortedArray(vector<int> arr) {
sort(arr.begin(), arr.end());
arr.erase(unique(arr.begin(), arr.end()), arr.end());
return arr;
}
// 두 점 사이의 맨해튼 거리
int manhattanDistance(int x1, int y1, int x2, int y2) {
return abs(x1 - x2) + abs(y1 - y2);
}
// 방향 벡터 (8방향 - 상, 하, 좌, 우, 대각선)
const int dx8[8] = {-1, 1, 0, 0, -1, -1, 1, 1};
const int dy8[8] = {0, 0, -1, 1, -1, 1, -1, 1};
// 배열 원소 찾기 (이진 탐색)
int binarySearch(const vector<int>& arr, int target) {
int left = 0, right = arr.size() - 1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (arr[mid] == target) return mid;
else if (arr[mid] < target) left = mid + 1;
else right = mid - 1;
}
return -1; // 찾지 못한 경우
}
// 모듈러 덧셈 (큰 수 연산)
long long modularAdd(long long a, long long b, long long mod) {
return ((a % mod) + (b % mod)) % mod;
}
// 모듈러 곱셈 (큰 수 연산)
long long modularMultiply(long long a, long long b, long long mod) {
return ((a % mod) * (b % mod)) % mod;
}4. 기타
회전
정의: 지정된 범위에서 요소를 왼쪽 또는 오른쪽으로 회전시키는 함수
헤더 파일: <algorithm>
사용법:
- first: 회전 범위의 시작 반복자.
- middle: 새로 시작할 위치(회전의 기준점).
- last: 회전 범위의 끝 반복자.
rotate(first, middle, last);
rotate(vec.begin(), vec.begin() + 2, vec.end());
rotate(vec.rbegin(), vec.rbegin() + 2, vec.rend());
동작 원리:
- [first, middle) 범위의 요소를 뒤로 이동.
- [middle, last) 범위의 요소를 앞으로 이동.
2. 입출력
<iostream>
표준 입출력을 위한 헤더 파일로, cin, cout과 같은 표준 입력과 출력을 사용할 수 있다. 예를 들어, 사용자 입력을 받거나 결과를 출력할 때 사용한다.
#include <iostream>
using namespace std;
int main() {
int x;
double y;
cout << "Enter an integer and a float: ";
cin >> x >> y; // 입력
cout << "You entered: " << x << " and " << y << endl; // 출력
cerr << "This is an error message." << endl; // 표준 에러 출력
clog << "This is a log message." << endl; // 로그 메시지 출력
return 0;
}
<algorithm>
정렬, 이분 탐색, 최대/최소값 찾기, 순열 생성 등 다양한 알고리즘 함수를 제공한다.
#include <algorithm>
#include <vector>
using namespace std;
int main() {
vector<int> v = {5, 3, 8, 1};
// 최대/최소
int maxVal = *max_element(v.begin(), v.end());
int minVal = *min_element(v.begin(), v.end());
// 이분 탐색
sort(v.begin(), v.end());
bool found = binary_search(v.begin(), v.end(), 3);
// 순열 생성
do {
for (int x : v) cout << x << " ";
cout << endl;
} while (next_permutation(v.begin(), v.end()));
return 0;
}
<cmath>
수학 함수들을 제공하며, 절댓값(abs), 제곱근(sqrt), 삼각 함수(sin, cos) 등을 포함한다.
#include <cmath>
#include <iostream>
using namespace std;
int main() {
double x = -8.3;
cout << "Absolute: " << abs(x) << endl; // 절댓값
cout << "Ceiling: " << ceil(x) << endl; // 올림
cout << "Floor: " << floor(x) << endl; // 내림
cout << "Round: " << round(x) << endl; // 반올림
cout << "Power: " << pow(2, 3) << endl; // 2^3
cout << "Logarithm: " << log(10) << endl; // 자연로그
cout << "Exponential: " << exp(1) << endl; // e^1
cout << "Square Root: " << sqrt(16) << endl; // 제곱근
cout << "Trigonometry (sin): " << sin(M_PI / 2) << endl; // 삼각 함수
return 0;
}
<string>
문자열을 다루기 위한 헤더 파일로, 문자열 비교, 연결, 부분 문자열 추출 등을 지원한다.
#include <string>
#include <iostream>
using namespace std;
int main() {
string s = "hello";
s.insert(5, " world"); // 삽입
s.replace(0, 5, "Hi"); // 대체
s.erase(0, 3); // 삭제
cout << "Substring: " << s.substr(0, 5) << endl; // 부분 문자열
cout << "Find: " << s.find("world") << endl; // 특정 문자열 찾기
cout << "Reverse: " << string(s.rbegin(), s.rend()) << endl; // 역순
return 0;
}
<queue>
FIFO(First-In-First-Out) 방식의 자료구조를 제공한다. priority_queue는 우선순위 큐를 지원한다.
#include <queue>
#include <iostream>
using namespace std;
int main() {
queue<int> q;
q.push(1);
q.push(2);
q.push(3);
while (!q.empty()) {
cout << q.front() << " "; // 맨 앞 요소
q.pop(); // 제거
}
// 우선순위 큐 (기본: 최대 힙)
priority_queue<int> pq;
pq.push(10);
pq.push(5);
pq.push(20);
while (!pq.empty()) {
cout << pq.top() << " "; // 최대값
pq.pop();
}
return 0;
}
<stack>
LIFO(Last-In-First-Out) 방식의 자료구조를 제공한다.
#include <stack>
using namespace std;
stack<int> s;
s.push(1);
s.pop(); // 1 제거
<map>
키-값 쌍으로 이루어진 연관 컨테이너로, 키를 기준으로 정렬된 상태를 유지하며, 탐색, 삽입, 삭제 연산이 O(log N)이다.
#include <map>
#include <iostream>
using namespace std;
int main() {
map<string, int> m;
m["apple"] = 3;
m["banana"] = 5;
// 키로 값 접근
cout << "Apple: " << m["apple"] << endl;
// 반복문
for (auto &p : m) {
cout << p.first << ": " << p.second << endl;
}
// 특정 키 삭제
m.erase("banana");
return 0;
}
<set>
유일한 요소를 저장하며, 자동으로 정렬 상태를 유지한다. 삽입, 삭제, 탐색이 O(log N)이다.
#include <set>
#include <iostream>
using namespace std;
int main() {
set<int> s = {3, 1, 4};
// 요소 추가
s.insert(2);
// 요소 검색
if (s.find(3) != s.end()) {
cout << "Found 3" << endl;
}
// 요소 삭제
s.erase(3);
// 반복문
for (int x : s) {
cout << x << " ";
}
return 0;
}
<deque>
양쪽에서 삽입과 삭제가 가능한 자료구조이다. queue와 비슷하지만 앞뒤에서 삽입/삭제가 가능하다는 점이 다르다.
#include <deque>
#include <iostream>
using namespace std;
int main() {
deque<int> d = {1, 2, 3};
d.push_back(4); // 뒤에 추가
d.push_front(0); // 앞에 추가
d.pop_back(); // 뒤에서 제거
d.pop_front(); // 앞에서 제거
for (int x : d) {
cout << x << " ";
}
return 0;
}
<numeric>
accumulate, partial_sum 등 숫자 연산을 위한 함수를 제공한다.
#include <numeric>
#include <vector>
#include <iostream>
using namespace std;
int main() {
vector<int> v = {1, 2, 3, 4};
int sum = accumulate(v.begin(), v.end(), 0); // 합계
cout << "Sum: " << sum << endl;
vector<int> partialSums(v.size());
partial_sum(v.begin(), v.end(), partialSums.begin()); // 부분 합
for (int x : partialSums) cout << x << " ";
return 0;
}
2. 빠른 입출력 설정
코딩 테스트에서는 입출력 속도가 중요한데, cin과 cout은 기본적으로 느리다. 이를 개선하기 위해 아래와 같이 설정하면 된다. C++ 표준 스트림(cin/cout)과 C 표준 스트림(scanf/printf)의 동기화를 끊어, 불필요한 작업을 제거해 입출력 속도를 높인다. 또 cin이 cout 버퍼를 자동으로 비우는 동작을 비활성화하여 추가적인 성능 향상을 제공한다.
ios::sync_with_stdio(false);
cin.tie(0);
이 설정을 사용할 때는 cin/cout과 scanf/printf를 혼용하면 버퍼 동기화 문제로 인해 예상치 못한 결과가 발생할 수 있으므로, 하나의 방식을 통일하여 사용하는 것이 중요하다.
4. 매크로 정의
자주 사용하는 반복문, 상수 등을 매크로로 정의하면 코드를 더 간결하게 작성할 수 있다.
#define FOR(i, a, b) for (int i = a; i < b; ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(v) (v).begin(), (v).end()
#define PB push_back
#define MP make_pair
#define F first
#define S second
5. 유용한 함수
자주 사용하는 함수를 미리 정의해 두면 편리하다.
6. 디버그용 매크로
디버깅을 빠르게 할 수 있는 매크로를 준비하면 문제 해결에 유리하다.
#define DEBUG(x) cout << #x << " = " << x << endl
int x = 42;
DEBUG(x); // 출력: x = 42
8. 기타
띄어쓰기로 배열에 입력 넣기
#include <iostream>
#include <vector>
using namespace std;
int main() {
vector<int> numbers;
int num;
while (cin >> num) {
numbers.push_back(num);
}
return 0;
}
구조체 활용
struct STUDENT {
string name;
int korean;
int english;
int math;
}
string
substr(pos, count)는 원본 문자열에서 pos 인덱스부터 count개의 문자를 잘라서 새로운 문자열을 반환합니다.
'Test > Coding Test' 카테고리의 다른 글
| Coding Test [0] : 코딩테스트 준비 (Coding Test Environment) (3) | 2024.12.27 |
|---|