anozanami의 PS 블로그

BOJ 2343 기타 레슨

anozanami — Tue, 3 Sep 2024 20:58:32 +0900

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

문제 분석

처음에는 어떻게 풀어야 할 지 감이 아예 안잡혔다. 블루레이 길이를 찾아야하는데 강의의 수의 범위가 꽤 커서 이분 탐색을 써야한다는 느낌은 들었지만 어떻게 적용할지 몰랐다. 개강 전부터 풀고 있다가 개강하고 나서 풀게 되었다..

이분 탐색을 무슨 값으로 할 지 모르겠어서 어려웠던 것 같다. 이를 블루레이의 길이(l)로 잡았을 때 가능했다.

풀어 보기

이분 탐색을 진행할 때 start(최솟값)를 블루레이의 최댓값으로 해야 모든 블루레이를 담을 수 있다.(l이 1~9일 때 담는 크기가 1~8이면 9인 블루레이를 담을 수 없다) end(최댓값)는 모든 블루레이의 합이 되면 된다. 반복문을 돌 때 필요한 블루레이수 cnt와 m을 비교하여 cnt가 더 크다면 start가 더 커야한다.

코드 구현

#include <bits/stdc++.h> // 2343 기타 레슨
using namespace std;
int n, m;
int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    int Max = 0;
    int sum1 = 0;
    int cnt = 0;
    cin >> n >> m;
    vector <int> blueray(n);
    for(int i = 0; i < n; i++){
        cin >> blueray[i];
        Max = max(blueray[i], Max);
        sum1 += blueray[i];
    }
    int start = Max;
    int end = sum1;
    int mid;
    while(start <= end){
        int cnt = 0;
        int sum2 = 0;
        mid = (start + end) / 2;
        for(int i = 0; i < n; i++){
            if(sum2 + blueray[i] > mid){
                sum2 = 0;
                cnt++;
            }
            sum2 += blueray[i];
        }
        if(sum2 != 0) cnt++;
        if(cnt > m) start = mid + 1;
        else end = mid - 1;
    }
    cout << start;
}

if(sum2 != 0) cnt++; 이 부분을 구현 안해서 자꾸 틀렸다. 항상 모든 테스트케이스를 맞아야 한다는 것을 생각하면서 구현해야겠다. 추가로 다른 자료를 보니 내가 변수를 쓸데없이 많이 작성함을 발견했다. 더 깔끔하게 구현해보도록 노력하겠다.

#include <bits/stdc++.h> // 2343 기타 레슨
using namespace std;

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    int n, m;
    cin >> n >> m;
    vector <int> a(n);
    int start = 0;
    int end = 0;
    
    for(int i = 0; i < n; i++){
        cin >> a[i];
        if(start < a[i])
        	start = a[i]; // 레슨 최댓값 -> 시작 인덱스
        end += a[i] // 모든 레슨의 합 -> 종료 인덱스
    }
    
    while(start <= end){
        int mid = (start + end) / 2;
        int sum = 0;
        int cnt = 0;
        
        for(int i = 0; i < n; i++){
            if(sum + a[i] > mid){
                sum = 0;
                cnt++;
            }
            sum += a[i];
        }
        if(sum != 0) cnt++;
        if(cnt > m) start = mid + 1;
        else end = mid - 1;
    }
    cout << start;
}

굳이 Max와 sum1, 2를 나눠서 저장할 필요가 없었다. blueray도 그냥 a같은 쉬운 문자를 쓰는 것이 좋을 것 같다.

이진 탐색

anozanami — Wed, 28 Aug 2024 17:01:44 +0900

- 이진 탐색 : 데이터가 정렬된 상태에서 원하는 값을 찾아내는 알고리즘. 타 탐색 알고리즘와의 차이점으로는

꼭 정렬된 상태에서 구현되어야 한다.
시간 복잡도가 O(log n)이다.
중앙값 비교를 통한 대상 축소 방식이다.

정도가 되겠다. 데이터의 양이 너무 많을 때(타 탐색 알고리즘을 이용하면 시간 초과가 날 때) 이용하면 좋겠다.

- 이진 탐색의 핵심 이론(오름차순으로 정렬된 데이터에서만 적용)

현재 데이터의 중앙값(mid)을 선택한다.
중앙값 > 타깃 데이터일 때 중앙값을 기준으로 왼쪽을 선택한다. (끝점을 중앙값 바로 이전 데이터로 선택한다.)
중앙값 < 타깃 데이터일 때 중앙값을 기준으로 오른쪽을 선택한다. (시작점을 중앙값 바로 이후 데이터로 선택한다.)
1~3을 반복하다가 중앙값 == 타깃 데이터일 때 탐색을 종료한다.

문제 하나를 풀면서 적용해보자.

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

#include <bits/stdc++.h> // 1920 수 찾기
using namespace std;
using ll = long long;
ll arr_n[100001];
ll arr_m[100001];
int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    int n, m;
    cin >> n;
    for(int i = 0; i < n; i++)
        cin >> arr_n[i];
    cin >> m;
    for(int i = 0; i < m; i++)
        cin >> arr_m[i];
    
    for(int i = 0; i < m; i++){
        int check = 0;
        for(int j = 0; j < n; j++){
            if(arr_n[j] == arr_m[i]) check = 1;
        }
        cout << check << '\n';
    }
}

처음 이 문제를 접근한다면 보통 이런식으로 하나의 원소와 다른 배열의 모든 원소와 비교하게 짠다. 하지만 최악의 경우에는 10만 * 10만 = 100억번의 시행이 이루어지게 된다. 이는 시간 초과로 이어진다ㅏ. 이럴 때 이분 탐색을 이용하면 더욱 적 은 시행으로 답을 낼 수 있어 시간 초과가 안나게 된다.

#include <bits/stdc++.h> // 1920 수 찾기
using namespace std;
int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    
    int n, m;
    cin >> n;
    vector<int> v(n);
    
    for(int i = 0; i < n; i++)
        cin >> v[i];
    sort(v.begin(), v.end());
    
    cin >> m;
    
    for(int i = 0; i < m; i++){
        int target;
        cin >> target;
        
        int start = 0;
        int end = n-1;
        int mid;
        int check = 0; // 존재여부 체크
        
        while(start <= end){
            mid = (start + end) / 2;
            if(v[mid] > target) end = mid - 1;
            else if(v[mid] < target) start = mid + 1;
            else {
                check = 1;
                break;
            }
        }
        cout << check << '\n';
    }
}

이분탐색을 이용하면 탐색 부분의 시간복잡도가 log(100억) 약 32~33이니 확실히 줄어든다. 많은 양의 케이스가 주어지는 경우의 탐색은 이분 탐색을 적극적으로 이용해보자.

Backtracking

anozanami — Tue, 20 Aug 2024 10:29:40 +0900

백트래킹(backtracking)이란? : 해를 찾는 도중 해가 아니어서 막히면, 되돌아가서 다시 해를 찾아가는 기법

백트래킹의 가장 기본적인 문제인 N과 M 시리즈의 코드를 분석하면서 이해해보겠다.

#include <bits/stdc++.h> //15649 N과 M(1)
using namespace std;
int n, m;
int arr[10];
bool isused[10];

void func(int k){
    if(k == m){
        for(int i = 0; i < m; i++)
            cout << arr[i] << ' ';
        cout << '\n';
        return;
    }
    for(int i = 1; i <= n; i++){
        if(!isused[i]){
            isused[i] = true;
            arr[k] = i;
            func(k+1);
            isused[i] = false;
        }
    }
}

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cin >> n >> m;
    func(0);
    return 0;
}

arr은 답에 해당하는 여러 값을 저장하기 위한 배열이고 isused는 1 ~ N까지의 특정 숫자의 사용여부를 체크하는 배열이다.

func 함수가 백트래킹의 핵심이자 전형적인 구조이다.func함수는 현재 숫자가 k개까지 정해진 상황에서 arr[k]가 무엇인지 결정해주는 함수이다. func함수는 재귀를 이용하여 짰으니 base condition을 지정해줘야한다. 우리는 M개의 숫자를 골라야 하기 때문에 k == M일 때를 base condition으로 정한다. 이 때 M개의 숫자를 모두 고르게 됐으니 형식에 맞춰서 숫자를 출력한다. 이제 arr[k]를 결정해야한다. 먼저 1 ~ N까지의 모든 숫자를 반복해야하고 if문을 이용해 해당 숫자를 사용했으면 넘어가는 식으로 코드를 작성한다. 해당 숫자를 사용하지 않았으면 isused값을 true로 변경해주고 arr[k]의 값을 결정한다. 그 다음 재귀를 통해 k+1번째의 숫자를 결정한다. 재귀를 탈출했으면 다시 isused값을 false로 변경해줘야한다. 이전 isused값이 true인채로 다음 반복을 진행하면 해당 값(i)이 출력되지 않으므로 오류가 난다.

BFS 기본형식 - 최단거리 계산

anozanami — Sun, 3 Dec 2023 15:18:11 +0900

#include <bits/stdc++.h>
using namespace std;
#define X first
#define Y second
int board[101][101];
int dist[101][101]; // 기존의 bool형의 2차원 배열이 아닌 거리를 저장할 int형으로 대체
int n, m;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cin >> n >> m;
    for(int i = 0; i < n; i++) cin >> board[i];
    for(int i = 0; i < n; i++) fill(dist[i], dist[i]+m, -1);
    queue<pair<int, int>> Q;
    dist[0][0]++;
    Q.push({0, 0});
    while(!Q.empty()){
        auto cur = Q.front(); Q.pop();
        for(int dir = 0; dir < 4; dir++){
            int nx = cur.X + dx[dir];
            int ny = cur.Y + dy[dir];
            if(nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
            if(dist[nx][ny] >= 0 || board[nx][ny] != 1) continue; // dist값이 0 이상이면 이미
            왔다간 흔적이 있는 것이기 때문에 새롭게 접근하면 최솟값이 될 수 없으니 continue.
            dist[nx][ny] = dist[cur.X][cur.Y] + 1; // cur값에서 + 1
            Q.push({nx, ny});
        }
    }
    cout << dist[n-1][m-1]; // (n-1, m-1)의 거리의 최솟값.   
    return 0;
}

BFS 기본 형식 - 2차원 배열(Flood Fill)

anozanami — Sun, 3 Dec 2023 14:39:23 +0900

Flood Fill 알고리즘은 주어진 시작점으로 부터 연결된 영역을 찾는 알고리즘이다.

#include <bits/stdc++.h>
using namespace std;
#define X first
#define Y second // pair에서 first, second를 줄여서 쓰기 위해서 사용
int board[502][502]; // 1이 파란 칸, 0이 빨간 칸에 대응
bool vis[502][502]; // 해당 칸을 방문했는지 여부를 저장
int n, m;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1}; // 상하좌우 네 방향을 의미

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cin >> n >> m;
    for(int i = 0; i < n; i++)
        for(int j = 0; j < m; j++)
            cin >> board[i][j];
    queue<pair<int, int>> Q;
    vis[0][0] = 1; // (0, 0)에서부터 BFS를 시작하기 위한 준비
    Q.push({0, 0});
    while(!Q.empty()){
        auto cur = Q.front(); Q.pop();
        for(int dir = 0; dir < 4; i++){ // 상하좌우 칸을 살펴볼 것이다.
            int nx = cur.X + dx[dir];
            int ny = cur.Y + dy[dir]; // nx, ny에 dir에서 정한 방향의 인접한 칸의 좌표가 들어감
            if(nx < 0 || nx >= n || ny < 0 || ny >= m) continue; // 범위 밖일 경우 넘어감
            if(board[nx][ny] != 1 || vis[i][j] == 1) continue; // 이미 방문한 칸이거나 파란 칸이 아닐 경우
            vis[nx][ny] = 1;
            Q.push({nx, ny}); // (nx, ny)를 방문했다고 명시
        }
    }
    // (0, 0)을 시작점으로 하는 BFS가 종료됨.
    
    return 0;
}

18111: 마인크래프트

anozanami — Sat, 14 Oct 2023 23:28:41 +0900

접근 : 처음부터 접근을 완전 잘못했다. 배열의 값을 직접 바꾸면서 진행하려고 했었는데 지금생각해보니 그러면 정말 매우 복잡해지는 길이라는 생각이 든다. 블로그의 도움이라면 절대로 풀 지 못했을 것이다... 블로그에서는 백준 카테고리와 같은 브루트포스 알고리즘을 통해서 설명해주었다. 높이를 브루트포스하여 푼다. 높이 0부터 256까지 검사하면서 어떤 높이 값이 적당할지 체크하는 것이다. 중간 중간에 있는 조건문들도 초견에 풀기 정말로 힘들 것 같다.

풀이 : 높이를 높여가며 먼저 쌓아야 할 블록과 제거해야 할 블록의 개수를 센다. 왜 이렇게 하나면 가장 기본적으로 인벤토리에 있는 블록 개수와 쌓아야하는 블록의 개수에 오류가 생기면 바로 패스해야하기 때문이고 또 시간을 계산할 때에도 꼭 필요하기 때문이다. 블록 개수 판단은

if(맵의 한 타일에서 높이 - 정한높이가 양수) => 지워야할 블록 개수

else => 채워야할 블록 개수

로 생각한다.

그 다음엔 높이와 걸린 시간을 갱신한다. 시간은

if(지울 블록의 개수 + 처음에 가지고 있던 인벤토리 블록의 개수 >= 채울 블록 개수)

=> 소요시간 : 지울 블록 개수 * 2 + 채울 블록 개수

if(소요시간이 작다면) 시간 갱신

로 한다.

2491번: 수열

anozanami — Sat, 14 Oct 2023 22:38:19 +0900

접근 : 배열의 원소끼리 관계가 있을거라고 생각했다. 앞의 원소까지의 값에 따라서 그 다음 원소의 값이 결정된다. 전형적인 DP문제이다.

풀이 : DP라는 것을 알고 접근했을 때는 테이블을 현재까지의 연속된 가장 긴/짧은 구간, 점화식을 긴/짧은 것 각각

d1[i+1] = d1[i] + 1, if(arr[i] <= arr[i+1]), d2[i+1] = d2[i] + 1, if(arr[i] >= arr[i+1]) 로 했다. 초깃값은 d1, d2를 전부 1로 초기화하고 d1[1] && d2[1] == 1, d1[2] && d2[2] == 2 이다.

<다른 사람 풀이>

void Solution()
{
    int Answer = 1;
    int Len = 1;
    int Len2 = 1;
    for (int i = 1; i < N; i++)
    {
        if (Arr[i] <= Arr[i + 1]) Len++;
        else Len = 1;
 
        if (Arr[i] >= Arr[i + 1]) Len2++;
        else Len2 = 1;
 
        int Result = Max(Len, Len2);
        Answer = Max(Answer, Result);
    }
    cout << Answer << endl;
}

풀이 : 이 풀이는 나의 풀이를 정말 깔끔하게 다듬은 느낌이다. 논리는 다른게 없지만 구현이 달라 인용해본다. Len이라는 변수를 이용해서 나처럼 굳이 d1,d2 배열을 이용하지 않아도 되게끔 설계했다. 참고바란다.

DP

anozanami — Sat, 14 Oct 2023 22:11:50 +0900

정의 : DP(Dynamic Programming) 한글로 동적 계획법, 프로그래밍이다. 최적화 이론의 한 기술으로써 특정 범위까지의 값을 구하기 위해 그것과 다른 범위까지의 값을 이용하여 효율적으로 값을 구하는 알고리즘 설계 기법이다. 말을 조금 친절하게 하면 기억하며 풀기로 기억해주면 조금 더 좋겠다. (라임 맞춘거 맞다.)

구현 : 문제를 해결하기 위한 점화식을 찾아낸 후 점화식의 항을 밑에서부터 차례로 구해나가서 답을 구한다.

잠시 바킹독의 실전 알고리즘 (DP)편을 인용한다.

DP를 푸는 과정은

1. 테이블 정의하기

2. 점화식 찾기

3. 초기값 정하기

로 이뤄져 있다. 코딩테스트에 나올 수준의 DP 문제는 일단 점화식만 찾고나면 그 뒤는 초기 값을 채워넣은 후에 반복문을 돌면서 배열을 채우면 끝이어서 구현이 굉장히 쉽다고 한다. 보통 점화식은 여러개로 나눠지는 경우가 많다. 많은 문제를 풀면서 익숙해지는게 가장 중요한 것 같다.

Cloud Engineer

anozanami — Sat, 22 Jul 2023 17:56:09 +0900

https://brunch.co.kr/@topasvga/233

6월 3주차 복습(6/12~6/18)

anozanami — Sun, 18 Jun 2023 22:17:08 +0900

- 푼 문제 수 : 237 -> 251(+14)

- solved 티어 : 골드 4 1011 -> 골드 4 1051(+40)

- solved 랭킹 : #23,137(↑22.46%) ->#21,915(↑21.16%)

- 이번주 후기 : 이번주는 훈련이 있기도했고 추가로 다른 공부해야할 것들이 생겨서 약간은 소홀했다. atcis포맷, 비밀번호 변경법, 무전실, RDX교체 등등... 뭐가 많았다. 불주이기도 했고... 뭐 물론 다 핑계이다 ㅋㅋ...

- 이번주는 DP를 풀었다. 확실히 백트래킹보다 훨씬 더 많이 쓰이는 것 같다. 알고리즘에 따른 문제 분류에서도 DP가 압도적으로 많으니 DP는 완벽하게 숙지하는 것이 맞는 것 같다. 하루는 삘타서 7문제 푼게 아주 장하다 ㅋㅋㅋ 다음주만 버티면 외박+휴가를 나간다. 기분이 매우 좋다. 담주에는 당분간 못할 수도 있다. 그 다음주(7월)에 열심히 해보겠다!!!