갓생살기프로젝트

[논문리뷰] Multi-scale patch-based representation learning for image anomaly detection and segmentation

Heeyeon.dev — Tue, 30 May 2023 15:41:10 +0900

오늘 리뷰할 논문은
"Multi-scale patch-based representation learning for image anomaly detection and segmentation"[1]
입니다.

링크 : https://openaccess.thecvf.com/content/WACV2022/papers/Tsai_Multi-Scale_Patch-Based_Representation_Learning_for_Image_Anomaly_Detection_and_Segmentation_WACV_2022_paper.pdf

이 논문은 제목에서도 알 수 있듯이 Representation Learning(Self-Supervised Learning)을 활용하여 anomaly detection과 anomaly segmentation을 수행한 논문입니다. 이미 알고있는 간단한 방법들로 task를 수행했는데 생각보다 성능적인 부분에서 우수한 성능을 낸 논문입니다.

1. Training Stage

Training overview

Training 단계에서는 제목에서 Multi-scale patch-based라고 말한 것 처럼 다양한 크기의 패치를 사용하여 encoder를 학습시킵니다. 논문에서는 64x64, 32x32, 그리고 16x16 사이즈의 패치를 학습에 사용하여 사용하여 각각 다른 크기의 input을 받는 encoder Enc64, Enc32, Enc16을 학습시킵니다.그리고 이 encoder들의 결과로 나온 feature를 k-means clustering을 활용해 군집화하고, Classifier로 보내 두 패치 사이의 relative angle을 추론합니다.이것이 전반적인 training 단계 과정인데, loss함수를 보면서 좀 더 자세하게 설명해보도록 하겠습니다.

2. Objective Functions

(1) SVDD Loss & Cos Loss

먼저 SVDD Loss는 유사한 패치 사이의 semantic한 정보를 모으고자 설계한 loss인데 단순히 패치 사이의 L2 norm으로 계산합니다. 하지만 이 경우에 패치 사이의 거리가 멀면 의미적으로 덜 유사할 수 있기 때문에 Cos Loss를 추가해주었습니다.
Cos Loss는 Cosine Similarity를 활용하여 Contrastive Learning과 유사하게 디자인한 loss function입니다.

SVDD/Cos Loss를 사용할 때 patch selection

위 그림은 SVDD와 Cos Loss를 사용하여 Encoder를 학습시킬 때 patch를 선택하는 방법입니다.
먼저 기준이 되는 Pi 패치를 뽑고 인접한 픽셀에서 패치 Pj를 뽑습니다. 이 때, Enc64는 Pi패치의 start point기준으로 +4~-4 픽셀 안에서 Pj의 start point를 선택하고 Enc32는 +2~-2, Enc16은 +1~-1 픽셀 안에서 선택합니다.
왜냐하면, 근처에 있는 패치를 뽑아야지만 그 유사성이 보장되기 때문입니다.

그리고 Cos Loss는 추가적으로 패치 Pk를 뽑는데 위의 Loss에서 알 수 있듯이 Pk의 목적은 contrastive learing의 negative pair를 생성하는 것에 있습니다.
가까이에서 뽑은 Pi와 Pj패치의 유사성은 높게, 멀리서 뽑은 Pk와 기준이 되는 Pi의 유사성은 작게 가져가겠다는 것이지요.

(2) SSL Loss

SSL Loss는 Self-Supervised Learning Loss인데 이 논문에서는 pretext task로 패치 사이의 각도를 추론하는 것으로 설정하였습니다. (단순히 Cross Entropy 사용함. )라벨 y는 0~11까지 11개가 있으며, 각각의 라벨은 0도, 30도, 60도, ... 330도 입니다.

단순하게 패치만 주고 각도를 맞출수는 없기 때문에 학습과정에서 패치를 뽑을때 각도를 설정하고 패치를 뽑아줍니다.

(그림 상에서는 Pm, Pn으로 나와있지만 loss function의 Pi, Pj와 동일합니다. //Pm == Pi, Pn == Pj)
(1) 기준이 되는 Pm 패치를 랜덤하게 뽑고 (2) Pn을 패치 사이즈만큼 떨어진 간격 안에서 랜덤하게 선택된 각도에 맞춰서 뽑습니다.

(3) Kmean Loss
좀 더 나은 feature representation을 학습하기 위해서 K-means clustering 도입하였는데, embedding된 patch를 가지고 cluster를 구분하였고, 그 feature들이 클러스터의 센터와 가까워지게끔 loss를 구성하였습니다.
(각 클러스터의 센터점인 Ck는 5 epoch마다 업데이트 합니다.)
(논문에서 K의 숫자(클러스터의 개수)는 언급하지 않음)

앞에서는 patch를 선택할 때 제한조건이 있었지만, Kmeans loss는 제약 조건 없이 random하게 patch selection을 진행합니다.
* Overall Loss

이렇게 모든 loss를 합해서 전체 loss를 구성하는데 이 때 학습데이터가 similar pattern일 수록 λ를 크게 세팅합니다.
아마, 유사한 패턴인 경우 SSL Loss로 학습하기 어려울 것이기 때문에 SSL의 영향을 덜 받게끔 한 것 같습니다.

(ex. 그물망 사진에서 두 개의 패치를 뽑아 그 각도를 추론하기 힘듬)

3. Inference Stage

Inference Stage에서는 앞서 학습시킨 Encoder를 사용하여 Anomaly Map을 생성합니다.

Inference phase overview

먼저, Inference 할 이미지가 주어지면, 각각에 encoder에 넣어줄 수 있게끔 patch를 뽑습니다. 각각 64, 32, 16 사이즈의 패치를 오버랩핑하여 추출하는데 이 때, 64사이즈의 패치는 stride 16, 32와 16사이즈의 패치는 stride 4로 설정하여 패치를 추출합니다.
(추출한 패치는 encoder에 들어가 feature로 나옴.)

수식에서 $\theta$는 encoder의 각 크기를 의미함. $(\theta = {64, 32, 16})$

위 식처럼 모든 패치 $P_r^\theta$는 training dataset을 활용해 모든 normal feature embedding과의 L2 distance를 구하고 그 중 가장 작은 값을 abnormality $D_\theta$로 정의합니다.

* 이 부분에서 논문은 'calculating the shortest L2-distance between its feature embedding and all the normal feature embeddings in the training dataset' 이라고 표현하였는데 저는 모든 training dataset 안에 있는 데이터들과 inference로 들어온 input 이미지를 비교하겠다는 것으로 이해하였습니다.
과연 이게 맞는 것인지...? 만약 맞다면 굉장히 많은 cost를 요구하는 알고리즘이고, 성능적인 측면에서 안되는게 이상할 정도로 heuristic한 알고리즘이라고 생각되네요...
아무래도 실제 산업에서는 사용하기 힘든 방법일 것 같습니다. (inference 도중에 모든 training dataset에 접근하는 것이 현실적으로 가능할지? / 실시간성 보장도 안될 듯)

모든 패치에서 가장 작은 L2 distance로 abnormality를 계산한 다음, 패치가 overlapping 되는 부분들을 단순히 평균내어 anomaly map을 정의합니다.

그리고 모든 인코더에서 각각 anomaly map을 생성하였다면, 각 인코더에서 나온 anomaly map을 element-wise addition으로 연산해 최종 anomaly map을 생성합니다.

최종적으로 만든 anomaly map을 통해 anomaly detection을 수행하는데 특정 픽셀 하나에서 튀는 값(outlier) 때문에 모델이 이를 anomaly라고 인식하는 것을 방지하고자 sliding window(8x8, stride=4)를 사용합니다. (이 방법을 통해 논문에서는 false positive를 효과적으로 줄였다고 함.)

8x8 윈도우 안에 있는 값을 모두 더해 평균내어 최종 anomaly score로 정합니다.

하지만 이 방법이 false positive를 줄이는데는 좋았을 수 있겠지만, 이 모델의 anomaly segmentation 결과를 보면 이 윈도우 때문에 결과가 grid 하게 조각조각 색칠되지 않았나 싶습니다.

4. Experiments

논문에서는 다양한 실험들과 그 결과에 대해서 얘기하고 있지만 다른 것들은 크게 유의미하지 않다고 생각합니다...
왜냐면 위에서도 얘기했지만 inference 할 때, training data를 쓰는 것 자체가 다른 방법들과 비교하는 것이 과연 맞나..?라는 생각이 듭니다.

그래도 논문에서 제시한 Table 7의 결과는 논문에서 사용한 여러 loss가 결과에 얼마나 영향력이 있나를 확인할 수 있었습니다.
두 패치 사이의 각도를 추론하게 하는 pretext task에 사용한 SSL loss가 생각보다 꽤 많은 영향을 준다는 것을 확인하였습니다.
두 패치 사이의 Sementic 한 정보를 학습함으로써 model학습에 도움을 주지 않았나 생각합니다.

ref :
[1] Tsai, Chin-Chia, Tsung-Hsuan Wu, and Shang-Hong Lai. "Multi-scale patch-based representation learning for image anomaly detection and segmentation." Proceedings of the IEEE/CVF Winter Conference on Applications of Computer Vision. 2022.

논문의 기본적인 알고리즘과 철학을 중심으로 담고자 생략한 부분이 많이 있으니 더 궁금하신 분들은 원본 논문을 참고하시기 바랍니다. 감사합니다.

[백준/BOJ/C++] 2805번 나무 자르기 - 이분탐색

Heeyeon.dev — Sun, 14 Feb 2021 02:22:22 +0900

2805번: 나무 자르기

첫째 줄에 나무의 수 N과 상근이가 집으로 가져가려고 하는 나무의 길이 M이 주어진다. (1 ≤ N ≤ 1,000,000, 1 ≤ M ≤ 2,000,000,000) 둘째 줄에는 나무의 높이가 주어진다. 나무의 높이의 합은 항상 M보

www.acmicpc.net

1. 문제

상근이는 나무 M미터가 필요하다. 근처에 나무를 구입할 곳이 모두 망해버렸기 때문에, 정부에 벌목 허가를 요청했다. 정부는 상근이네 집 근처의 나무 한 줄에 대한 벌목 허가를 내주었고, 상근이는 새로 구입한 목재 절단기를 이용해서 나무를 구할 것이다.

목재 절단기는 다음과 같이 동작한다. 먼저, 상근이는 절단기에 높이 H를 지정해야 한다. 높이를 지정하면 톱날이 땅으로부터 H미터 위로 올라간다. 그다음, 한 줄에 연속해있는 나무를 모두 절단해버린다. 따라서, 높이가 H보다 큰 나무는 H 위의 부분이 잘릴 것이고, 낮은 나무는 잘리지 않을 것이다. 예를 들어, 한 줄에 연속해있는 나무의 높이가 20, 15, 10, 17이라고 하자. 상근이가 높이를 15로 지정했다면, 나무를 자른 뒤의 높이는 15, 15, 10, 15가 될 것이고, 상근이는 길이가 5인 나무와 2인 나무를 들고 집에 갈 것이다. (총 7미터를 집에 들고 간다) 절단기에 설정할 수 있는 높이는 양의 정수 또는 0이다.

상근이는 환경에 매우 관심이 많기 때문에, 나무를 필요한 만큼만 집으로 가져가려고 한다. 이때, 적어도 M미터의 나무를 집에 가져가기 위해서 절단기에 설정할 수 있는 높이의 최댓값을 구하는 프로그램을 작성하시오.

2. 입력

첫째 줄에 나무의 수 N과 상근이가 집으로 가져가려고 하는 나무의 길이 M이 주어진다. (1 ≤ N ≤ 1,000,000, 1 ≤ M ≤ 2,000,000,000)

둘째 줄에는 나무의 높이가 주어진다. 나무의 높이의 합은 항상 M보다 크거나 같기 때문에, 상근이는 집에 필요한 나무를 항상 가져갈 수 있다. 높이는 1,000,000,000보다 작거나 같은 양의 정수 또는 0이다.

3. 출력

적어도 M미터의 나무를 집에 가져가기 위해서 절단기에 설정할 수 있는 높이의 최댓값을 출력한다.

4. 풀이

나무 자르기 문제는 이분 탐색 문제로 start는 1 end는 문제에서 주어진 최댓값으로 설정하고 시작한다.

mid는 start와 end의 중간값으로 이 값이 주어진 나무의 높이보다 작다면 나무에서 해당 높이를 뺀 만큼을 sum값에 더해준다. 모든 나무를 검사한 다음, sum값이 필요한 나무 길이인 M보다 크다면 start를 mid보다 1 큰 값으로 바꿔서 탐색 범위를 조금 더 큰값으로 바꿔준다. 그리고, 절단기에서 설정할 수 있는 높이의 최댓값을 구하는 것이기 때문에 현재 mid 값이 결과를 저장하는 result 변수의 값보다 크다면 result 변수에 mid 값을 대입해준다.

만약, sum값이 필요한 나무의 길이 M보다 작다면, 절단기의 높이를 더 낮게 설정해야 하기 때문에 end를 mid 보다 1 작은 값으로 바꿔서 탐색 범위를 조금 더 작은 값으로 바꿔준다.

5. 소스코드

#include <iostream>
#include <vector>
using namespace std;
int main(){
    long long N, M, result = 0;
    vector<int> tree;
    cin>>N>>M;
    for(int i = 0; i < N; i++){
        int x;
        cin>>x;
        tree.push_back(x);
    }
    long long start = 1, end = 2000000000;
    while(start <= end){
        long long mid = (start+end)/2;
        long long sum = 0;
        for(int i = 0; i < N; i++){
            if(tree[i] > mid){
                sum += tree[i] - mid;
            }
        }
        if(sum >= M){
            start = mid + 1;
            if(result < mid){
                result = mid;
            }
        }
        if(sum < M){
            end = mid - 1;
        }
    }
    cout<<result;
}

[백준/BOJ/C++] 1225번 이상한 곱셈 - 문자열

Heeyeon.dev — Sun, 14 Feb 2021 02:11:42 +0900

1225번: 이상한 곱셈

첫째 줄에 A와 B가 주어진다. 주어지는 두 수는 모두 10,000자리를 넘지 않는다.

www.acmicpc.net

1. 문제

A*B를 계산하다 지겨워진 형택이는 A*B를 새로운 방법으로 정의하려고 한다.

A에서 한 자리를 뽑고 * B에서 임의로 한 자리를 뽑아 곱한다.

의 가능한 모든 조합 (A가 n자리, B가 m자리 수라면 총 가능한 조합은 n*m개)을 더한 수로 정의하려고 한다.

예를 들어 121*34는

1*3 + 1*4 + 2*3 + 2*4 + 1*3 + 1*4 = 28

이 된다. 이러한 형택이의 곱셈 결과를 구하는 프로그램을 작성하시오.

2. 입력

첫째 줄에 A와 B가 주어진다. 주어지는 두 수는 모두 10,000자리를 넘지 않는다.

3. 출력

첫째 줄에 형택이의 곱셈 결과를 출력한다.

4. 풀이

이 문제는 다양한 방법으로 풀이를 할 수 있겠지만, 쉽게 입력을 받고 쉽게 관리하기 위해서 숫자를 string으로 입력받은 다음 vector에 넣어 계산하는 코드로 작성을 하였다.

다만 vector에 push 해줄 때 string 클래스의 at 함수는 문자로 반환을 하기 때문에 정확한 숫자 값을 넣어주기 위해 '0'을 빼준다.

이 작업만 거쳐주면 조건에 맞체 for문으로 각각 하나씩 곱해서 result 변수에 더해준다.

5. 소스코드

#include <iostream>
#include <vector>
using namespace std;
int main(){
    vector<int> A;
    vector<int> B;
    string num, num2;
    cin>>num>>num2;
    for (int i = 0; i < num.size(); i++){
        A.push_back(num.at(i) - '0');
    }
    for(int i = 0; i < num2.size(); i++){
        B.push_back(num2.at(i) - '0');
    }
    
    long long result = 0;
    for(int i = 0; i < A.size(); i++){
        for(int j = 0; j < B.size(); j++){
            result += (A[i] * B[j]);
        }
    }
    cout<<result;
    return 0;
}

[백준/BOJ/C++] 1157번 단어 공부 - 문자열

Heeyeon.dev — Sun, 14 Feb 2021 01:56:05 +0900

1157번: 단어 공부

알파벳 대소문자로 된 단어가 주어지면, 이 단어에서 가장 많이 사용된 알파벳이 무엇인지 알아내는 프로그램을 작성하시오. 단, 대문자와 소문자를 구분하지 않는다.

www.acmicpc.net

1. 문제

2. 입력

첫째 줄에 알파벳 대소문자로 이루어진 단어가 주어진다. 주어지는 단어의 길이는 1,000,000을 넘지 않는다.

3. 출력

첫째 줄에 이 단어에서 가장 많이 사용된 알파벳을 대문자로 출력한다. 단, 가장 많이 사용된 알파벳이 여러 개 존재하는 경우에는 ?를 출력한다.

4. 풀이

문자열 문제는 C++ string 클래스 멤버 함수 사용하는 방법을 연습하기에 아주 좋다.

이 단어 공부 문제에서는 at() 함수와 단순한 아스키코드값의 이해를 바탕으로 풀이할 수 있다.

- word.at(index)
인덱스에는 숫자가 들어가게 되고, 해당 위치에 해당하는 문자를 반환한다. string을 배열처럼 끊어서 사용한다고 생각하면 쉽다. 그래서 인덱스도 0번부터 시작한다.

단어를 at 함수를 사용해서 각각 분리했다면 이제 각 알파벳별로 개수를 카운트해야 한다. 알파벳 개수는 alphabet 배열에 저장하는데, 0번 인덱스부터 25번 인덱스까지 a에서 z까지의 사용된 개수를 저장한다.

대소문자를 각각 확인해줘야 하는데, 아스키코드 값이 대문자 A와 Z 사이이면 'A'를 뺀 값을 인덱스로 하여 카운트를 늘려주고, 소문자는 'a'를 뺀 값을 인덱스로 하여 카운트를 늘려준다.

그렇게 해서 alphabet 배열에 사용된 알파벳 개수를 모두 저장한 다음 최댓값을 구해준다.

최댓값이 여러 개 존재하는 경우를 확인하기 위해 구한 최댓값과 동일한 값이 alphabet 배열에 2개 이상 존재하는지 확인한다.

5. 소스코드

#include <iostream>
using namespace std;
int main(){
    string word;
    cin>>word;
    int alphabet[26] = {0, };
    for(int i = 0; i < word.size(); i++){
        if(word.at(i) >= 'A' && word.at(i) <= 'Z'){
            alphabet[word.at(i) - 'A']++;
        }
        else if(word.at(i) >= 'a' && word.at(i) <= 'z'){
            alphabet[word.at(i) - 'a']++;
        }
    }
    int max = 0; char result;
    for (int i = 0; i < 26; i++){
        if(alphabet[i] >= max){
            max = alphabet[i];
            result = i + 'A';
        }
        
    }
    int count = 0;
    for(int i = 0; i < 26; i++){
        if(max == alphabet[i]){
            count++;
        }
    }
    if(count > 1){
        cout<<"?";
    }
    else{
        cout<<result;
    }
    return 0;
}

[백준/BOJ/C++] 11728번 배열 합치기 - 정렬

Heeyeon.dev — Sat, 13 Feb 2021 23:37:32 +0900

11728번: 배열 합치기

첫째 줄에 배열 A의 크기 N, 배열 B의 크기 M이 주어진다. (1 ≤ N, M ≤ 1,000,000) 둘째 줄에는 배열 A의 내용이, 셋째 줄에는 배열 B의 내용이 주어진다. 배열에 들어있는 수는 절댓값이 109보다 작거

www.acmicpc.net

1. 문제

정렬되어있는 두 배열 A와 B가 주어진다. 두 배열을 합친 다음 정렬해서 출력하는 프로그램을 작성하시오.

2. 입력

첫째 줄에 배열 A의 크기 N, 배열 B의 크기 M이 주어진다. (1 ≤ N, M ≤ 1,000,000)

둘째 줄에는 배열 A의 내용이, 셋째 줄에는 배열 B의 내용이 주어진다. 배열에 들어있는 수는 절댓값이 109보다 작거나 같은 정수이다.

3. 출력

첫째 줄에 두 배열을 합친 후 정렬한 결과를 출력한다.

4. 풀이

출력 결과를 봤을 때 결과적으로 입력된 숫자들을 모두 정렬해서 한 줄로 출력한 모양이다.

문제에서는 두 배열 A와 B가 주어지지만, 어차피 각각 배열에 있는 숫자를 모두 합쳐서 정렬을 해야 하기 때문에 입력받을 때 별도의 구분 없이 하나의 벡터에 다 넣은 다음 sort 함수로 정렬을 하면 간단하게 풀이할 수 있다.

5. 소스코드

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int N, M;
    cin>>N>>M;
    vector<int> result;
    for(int i = 0; i < N+M; i++){
        int x;
        cin>>x;
        result.push_back(x);
    }
    sort(result.begin(), result.end());
    for(int i = 0; i < result.size(); i++){
        cout<<result[i]<<" ";
    }

    return 0;
}

[백준/BOJ/C++] 1780번 종이의 개수 - 분할 정복

Heeyeon.dev — Sat, 13 Feb 2021 01:58:39 +0900

1780번: 종이의 개수

N×N크기의 행렬로 표현되는 종이가 있다. 종이의 각 칸에는 -1, 0, 1의 세 값 중 하나가 저장되어 있다. 우리는 이 행렬을 적절한 크기로 자르려고 하는데, 이때 다음의 규칙에 따라 자르려고 한다.

www.acmicpc.net

1. 문제

만약 종이가 모두 같은 수로 되어 있다면 이 종이를 그대로 사용한다.
(1)이 아닌 경우에는 종이를 같은 크기의 9개의 종이로 자르고, 각각의 잘린 종이에 대해서 (1)의 과정을 반복한다.

이와 같이 종이를 잘랐을 때, -1로만 채워진 종이의 개수, 0으로만 채워진 종이의 개수, 1로만 채워진 종이의 개수를 구해내는 프로그램을 작성하시오.

2. 입력

첫째 줄에 N(1 ≤ N ≤ 37, N은 3k 꼴)이 주어진다. 다음 N개의 줄에는 N개의 정수로 행렬이 주어진다.

3. 출력

첫째 줄에 -1로만 채워진 종이의 개수를, 둘째 줄에 0으로만 채워진 종이의 개수를, 셋째 줄에 1로만 채워진 종이의 개수를 출력한다.

4. 풀이

종이의 개수 문제는 분할 정복 기법으로 문제를 풀이할 수 있다.

현재 크기의 종이에서 모든 종이의 값이 같지 않다면 종이를 가로 세로 각각 3 분할을 해서 다시 한번 확인한다. 확인했을 때, 종이에 적힌 수가 모두 같다면 count를 늘려준다. 만약, 종이의 크기가 1일 될 때까지 종이에 적힌 수가 같지 않았더라면, 재귀를 더 이상 반복할 수 없기에 그 종이에 해당하는 숫자의 count를 늘려준다.

하단 코드에서 arr배열은 입력된 값을 저장하는 배열이고, count_paper 배열은 각각 -1, 0, 1에 해당하는 종이의 갯수를 저장하는 배열이다.

5. 소스코드

#include <iostream>
using namespace std;
int arr[2187][2187];
int count_paper[3]; //index 0 : -1, index 1 : 0, index 2 : 1

void solution(int x, int y, int n){
    if(n == 1){
        count_paper[arr[x][y] + 1]++;
        return;
    }
    for(int i = x; i < x+n; i++){
        for(int j = y; j < y+n; j++){
            //다르면 종이 쪼개기.
            if(arr[x][y] != arr[i][j]){
                int k = n/3;
                for(int a = 0; a < 3; a++){
                    for(int b = 0; b < 3; b++){
                        solution(x + a*k, y + b*k, k);
                    }
                }
                return;
            }
            
        }
    }
    count_paper[arr[x][y] + 1]++;
}


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

    int N;
    cin>>N;
    for(int i = 0; i < N; i++){
        for(int j = 0; j < N; j++){
            cin>>arr[i][j];
        }
    }
    solution(0, 0, N);
    for(int i = 0; i < 3; i++){
        cout<<count_paper[i]<<"\n";
    }
    return 0;
}

[백준/BOJ/C++] 1992번 쿼드트리 - 분할 정복

Heeyeon.dev — Fri, 12 Feb 2021 17:28:33 +0900

1992번: 쿼드트리

첫째 줄에는 영상의 크기를 나타내는 숫자 N 이 주어진다. N 은 언제나 2의 제곱수로 주어지며, 1 ≤ N ≤ 64의 범위를 가진다. 두 번째 줄부터는 길이 N의 문자열이 N개 들어온다. 각 문자열은 0 또

www.acmicpc.net

1. 문제

흑백 영상을 압축하여 표현하는 데이터 구조로 쿼드 트리(Quad Tree)라는 방법이 있다. 흰 점을 나타내는 0과 검은 점을 나타내는 1로만 이루어진 영상(2차원 배열)에서 같은 숫자의 점들이 한 곳에 많이 몰려있으면, 쿼드 트리에서는 이를 압축하여 간단히 표현할 수 있다.

주어진 영상이 모두 0으로만 되어 있으면 압축 결과는 "0"이 되고, 모두 1로만 되어 있으면 압축 결과는 "1"이 된다. 만약 0과 1이 섞여 있으면 전체를 한 번에 나타내지를 못하고, 왼쪽 위, 오른쪽 위, 왼쪽 아래, 오른쪽 아래, 이렇게 4개의 영상으로 나누어 압축하게 되며, 이 4개의 영역을 압축한 결과를 차례대로 괄호 안에 묶어서 표현한다.

위 그림에서 왼쪽의 영상은 오른쪽의 배열과 같이 숫자로 주어지며, 이 영상을 쿼드 트리 구조를 이용하여 압축하면 "(0(0011)(0(0111) 01) 1)"로 표현된다. N ×N 크기의 영상이 주어질 때, 이 영상을 압축한 결과를 출력하는 프로그램을 작성하시오.

2. 입력

첫째 줄에는 영상의 크기를 나타내는 숫자 N 이 주어진다. N 은 언제나 2의 제곱수로 주어지며, 1 ≤ N ≤ 64의 범위를 가진다. 두 번째 줄부터는 길이 N의 문자열이 N개 들어온다. 각 문자열은 0 또는 1의 숫자로 이루어져 있으며, 영상의 각 점들을 나타낸다.

3. 출력

영상을 압축한 결과를 출력한다.

4. 풀이

이 문제는 분할정복 문제로 가로 세로 각각 절반씩 나누어서 한 섹션의 숫자가 모두 같은 숫자로 되어있는지 확인해야 한다.

하단 코드의 same 함수는 길이가 n인 한 섹션의 시작점 x,y를 받아 그 섹션 안의 숫자가 모두 같은지를 검사한다.

같을 경우에는 true, false를 반환하는데, 출력과 재귀 호출은 solution 함수에서 담당한다.

solution 함수에서 그 구역의 숫자가 모두 같을 경우에는 해당하는 숫자를 출력해주고, 같지 않으면 분할을 해야 하기 때문에 재귀로 4 분할된 구역을 호출한다. 이때, 분할되기 때문에 괄호를 먼저 열어준다.

그리고 한 구역이 끝나면 괄호를 닫아서 압축된 결과를 출력해준다.

5. 소스코드

#include <iostream>
using namespace std;
int arr[64][64];
bool same(int x, int y, int n){
    for(int i = x; i < x + n; i++){
        for(int j = y; j < y + n; j++){
            if(arr[x][y] != arr[i][j]){
                return false;
            }
        }
    }
    return true;
}
void solution(int x, int y, int n){
    if(!same(x, y, n)){
        cout<<"("; //같지 않으면 분할 되니까 괄호 열기.
        int k = n/2;
        for(int a = 0; a < 2; a++){
            for(int b = 0 ; b < 2; b++){
                solution(x+a*k, y+b*k, k);
            }
        }
        cout<<")"; //한구역 끝나면 괄호 닫기.
        return;
    }
    //숫자가 모두 같으면 출력.
    cout<<arr[x][y];
}
int main(){
    int N;
    cin>>N;
    for(int i = 0; i < N; i++){
        for(int j = 0; j < N; j++){
            scanf("%1d", &arr[i][j]);
        }
    }
    solution(0, 0, N);
    return 0;
}

[백준/BOJ/C++] 2447번 별 찍기 10 - 분할 정복

Heeyeon.dev — Fri, 12 Feb 2021 16:48:20 +0900

2447번: 별 찍기 - 10

재귀적인 패턴으로 별을 찍어 보자. N이 3의 거듭제곱(3, 9, 27, ...)이라고 할 때, 크기 N의 패턴은 N×N 정사각형 모양이다. 크기 3의 패턴은 가운데에 공백이 있고, 가운데를 제외한 모든 칸에 별이

www.acmicpc.net

1. 문제

재귀적인 패턴으로 별을 찍어 보자. N이 3의 거듭제곱(3, 9, 27,...)이라고 할 때, 크기 N의 패턴은 N×N 정사각형 모양이다.

크기 3의 패턴은 가운데에 공백이 있고, 가운데를 제외한 모든 칸에 별이 하나씩 있는 패턴이다.

***
* *
***

N이 3보다 클 경우, 크기 N의 패턴은 공백으로 채워진 가운데의 (N/3)×(N/3) 정사각형을 크기 N/3의 패턴으로 둘러싼 형태이다. 예를 들어 크기 27의 패턴은 예제 출력 1과 같다.

2. 입력

첫째 줄에 N이 주어진다. N은 3의 거듭제곱이다. 즉 어떤 정수 k에 대해 N=3k이며, 이때 1 ≤ k < 8이다.

3. 출력

첫째 줄부터 N번째 줄까지 별을 출력한다.

4. 풀이

입력이 27일때 예제 출력

입력이 27일때 출력된 예제를 분할 정복으로 풀기 위해서 각 구간별로 나눠보았다.

먼저 제일 처음 크게 3x3으로 나눴을때(빨간색 구분선) 정중앙 부분이 비어있고, 나누어진 각 섹션을 다시 한번 나눴을 때(파란색 구분선) 또 정중앙 부분이 비어있는 것을 볼 수 있다.

그리고 파란색 구분선으로 나누어진 나머지 부분을 보면 문제에서 주어진 패턴이 반복된다.

따라서, 주어진 입력을 3으로 나누면서 중앙부분을 비워두고 나누어진 크기가 3일 때 패턴을 반복하면 된다.

하단 코드에서 solution 함수의 else 부분이 큰 사각형을 나누는 부분이고, if(n==3) 부분이 패턴을 찍는 부분이다.

5. 소스코드

#include <iostream>
using namespace std;
bool star[6561][6561];
void solution(int x, int y, int n){
    if(n == 3){
        for(int i = x; i < x + n; i++){
            for(int j = y; j < y + n; j++){
                if(i%3 != 1 || j%3 != 1){ //문제의 패턴에서 별이 있는 부분만 true
                    star[i][j] = true;
                }
            }
        }
    }
    else{
        int k = n/3;
        for(int a = 0; a < 3; a++){
            for(int b = 0; b < 3; b++){
                if(a != 1 || b != 1){ //큰 사각형에서 가운데를 비운다.
                    solution(x+a*k, y+b*k, k);
                }
            }
        }
    }
}
int main(){
    int N;
    cin>>N;
    solution(0, 0, N);
    for(int i = 0; i < N; i++){
        for(int j = 0; j < N; j++){
            if(star[i][j]){
                cout<<"*";
            }
            else{
                cout<<" ";
            }
        }
        cout<<"\n";
    }
    return 0;
}

[백준/BOJ/C++] 1654번 랜선 자르기 - 이분 탐색

Heeyeon.dev — Mon, 8 Feb 2021 18:57:36 +0900

1654번: 랜선 자르기

첫째 줄에는 오영식이 이미 가지고 있는 랜선의 개수 K, 그리고 필요한 랜선의 개수 N이 입력된다. K는 1이상 10,000이하의 정수이고, N은 1이상 1,000,000이하의 정수이다. 그리고 항상 K ≦ N 이다. 그

www.acmicpc.net

1. 문제

집에서 시간을 보내던 오영식은 박성원의 부름을 받고 급히 달려왔다. 박성원이 캠프 때 쓸 N개의 랜선을 만들어야 하는데 너무 바빠서 영식이에게 도움을 청했다.

이미 오영식은 자체적으로 K개의 랜선을 가지고 있다. 그러나 K개의 랜선은 길이가 제각각이다. 박성원은 랜선을 모두 N개의 같은 길이의 랜선으로 만들고 싶었기 때문에 K개의 랜선을 잘라서 만들어야 한다. 예를 들어 300cm짜리 랜선에서 140cm짜리 랜선을 두 개 잘라내면 20cm는 버려야 한다. (이미 자른 랜선은 붙일 수 없다.)

편의를 위해 랜선을 자르거나 만들 때 손실되는 길이는 없다고 가정하며, 기존의 K개의 랜선으로 N개의 랜선을 만들 수 없는 경우는 없다고 가정하자. 그리고 자를 때는 항상 센티미터 단위로 정수길이만큼 자른다고 가정하자. N개보다 많이 만드는 것도 N개를 만드는 것에 포함된다. 이때 만들 수 있는 최대 랜선의 길이를 구하는 프로그램을 작성하시오.

2. 입력

첫째 줄에는 오영식이 이미 가지고 있는 랜선의 개수 K, 그리고 필요한 랜선의 개수 N이 입력된다. K는 1이상 10,000 이하의 정수이고, N은 1 이상 1,000,000 이하의 정수이다. 그리고 항상 K ≦ N이다. 그 후 K 줄에 걸쳐 이미 가지고 있는 각 랜선의 길이가 센티미터 단위의 정수로 입력된다. 랜선의 길이는 231-1보다 작거나 같은 자연수이다.

3. 출력

첫째 줄에 N개를 만들 수 있는 랜선의 최대 길이를 센티미터 단위의 정수로 출력한다.

4. 풀이

랜선의 길이가 최대 2^31 - 1로 너무 큰 수이기 때문에 이분탐색 기법을 활용하여 문제를 풀어야 한다.

start에는 1, end에는 랜선 길이의 최대값을 넣고 이분 탐색을 시작한다.

count변수에 mid 길이로 잘라서 만들수 있는 랜선의 개수를 저장한다.

만약 count가 필요한 랜선의 갯수보다 같거나 더 많은 경우에는 지금까지의 최댓값과 mid를 비교해 더 큰 값을 MAX 변수에 저장하고, start = mid + 1로 변경해준다.

그리고, count가 필요한 랜선의 갯수보다 작은 경우에는 end = mid - 1로 바꿔서 탐색 범위를 더 작은 숫자로 변경한다.

5. 소스코드

#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>
using namespace std;
vector<int> lan;
int max(int a, int b){
    return a > b ? a : b;
}
int main(){
    int K, N; //K : 가지고 있는 랜선의 개수, N : 필요한 랜선의 개수
    cin>>K>>N;
    for(int i = 0; i < K; i++){
        int x;
        cin>>x;
        lan.push_back(x);
    }
    long long start = 1, end = INT32_MAX, MAX = 0;
    while(start <= end){
        long long mid = (start+end)/2;
        int count = 0;
        for(int i = 0; i < lan.size(); i++){
            count += lan[i]/mid;
        }
        if(count >= N){
            MAX = max(MAX, mid);
            start = mid + 1;
        }
        else{
            end = mid - 1;
        }
    }
    cout<<MAX;
}

[백준/BOJ/C++] 10816번 숫자 카드 2 - 이분 탐색

Heeyeon.dev — Mon, 8 Feb 2021 17:26:40 +0900

10816번: 숫자 카드 2

첫째 줄에 상근이가 가지고 있는 숫자 카드의 개수 N(1 ≤ N ≤ 500,000)이 주어진다. 둘째 줄에는 숫자 카드에 적혀있는 정수가 주어진다. 숫자 카드에 적혀있는 수는 -10,000,000보다 크거나 같고, 10,

www.acmicpc.net

1. 문제

숫자 카드는 정수 하나가 적혀져 있는 카드이다. 상근이는 숫자 카드 N개를 가지고 있다. 정수 M개가 주어졌을 때, 이 수가 적혀있는 숫자 카드를 상근이가 몇 개 가지고 있는지 구하는 프로그램을 작성하시오.

2. 입력

첫째 줄에 상근이가 가지고 있는 숫자 카드의 개수 N(1 ≤ N ≤ 500,000)이 주어진다. 둘째 줄에는 숫자 카드에 적혀있는 정수가 주어진다. 숫자 카드에 적혀있는 수는 -10,000,000보다 크거나 같고, 10,000,000보다 작거나 같다.

셋째 줄에는 M(1 ≤ M ≤ 500,000)이 주어진다. 넷째 줄에는 상근이가 몇 개 가지고 있는 숫자 카드인지 구해야 할 M개의 정수가 주어지며, 이 수는 공백으로 구분되어져 있다. 이 수도 -10,000,000보다 크거나 같고, 10,000,000보다 작거나 같다.

3. 출력

첫째 줄에 입력으로 주어진 M개의 수에 대해서, 각 수가 적힌 숫자 카드를 상근이가 몇 개 가지고 있는지를 공백으로 구분해 출력한다.

4. 풀이

갖고있는 숫자 카드의 갯수를 카운트 해야하기 때문에 일반적인 이진 탐색 방법으로는 문제를 풀기가 어렵다.

그래서, 이진탐색기반의 탐색방법인 upper_bound와 lower_bound를 활용하여 문제를 풀어야 한다.

STL에서 제공하는 upper_bound와 lower_bound 함수를 사용하였는데,

upper_bound는 key값을 초과하는 가장 첫 번째 원소의 위치를 반환하고,

lower_bound는 key값이 없으면 key값보다 큰 가장 작은 정수 값을 반환한다.

그래서 upper_bound함수에서 반환한 값에서 lower_bound함수에서 반환한 값을 빼면 숫자카드의 갯수를 구할 수 있다.

5. 소스코드

#include <iostream>
#include <vector>
#include <bits/stdc++.h>
#include <algorithm>
using namespace std;
vector<int> num_N;
vector<int> num_M;
vector<int> answer;
int countbyRange(vector<int>& v, int leftValue, int rightValue){
    vector<int>::iterator rightIndex = upper_bound(v.begin(), v.end(), rightValue);
    vector<int>::iterator leftIndex = lower_bound(v.begin(), v.end(), leftValue);
    return rightIndex - leftIndex;
}

int main(){
    int N, M;
    cin>>N;
    for(int i = 0; i < N; i++){
        int x;
        cin>>x;
        num_N.push_back(x);
    }
    sort(num_N.begin(), num_N.end());
    cin>>M;
    for(int i = 0; i < M; i++){
        int y;
        cin>>y;
        num_M.push_back(y);
    }
    for(int i = 0; i < M; i++){
        cout<<countbyRange(num_N, num_M[i], num_M[i])<<" ";
    }
    return 0;
}

[백준/BOJ/C++] 10815번 숫자 카드 - 이분 탐색

Heeyeon.dev — Mon, 8 Feb 2021 16:31:04 +0900

10815번: 숫자 카드

www.acmicpc.net

1. 문제

숫자 카드는 정수 하나가 적혀져 있는 카드이다. 상근이는 숫자 카드 N개를 가지고 있다. 정수 M개가 주어졌을 때, 이 수가 적혀있는 숫자 카드를 상근이가 가지고 있는지 아닌지를 구하는 프로그램을 작성하시오.

2. 입력

첫째 줄에 상근이가 가지고 있는 숫자 카드의 개수 N(1 ≤ N ≤ 500,000)이 주어진다. 둘째 줄에는 숫자 카드에 적혀있는 정수가 주어진다. 숫자 카드에 적혀있는 수는 -10,000,000보다 크거나 같고, 10,000,000보다 작거나 같다. 두 숫자 카드에 같은 수가 적혀있는 경우는 없다.

셋째 줄에는 M(1 ≤ M ≤ 500,000)이 주어진다. 넷째 줄에는 상근이가 가지고 있는 숫자 카드인지 아닌지를 구해야 할 M개의 정수가 주어지며, 이 수는 공백으로 구분되어져 있다. 이 수도 -10,000,000보다 크거나 같고, 10,000,000보다 작거나 같다

3. 출력

첫째 줄에 입력으로 주어진 M개의 수에 대해서, 각 수가 적힌 숫자 카드를 상근이가 가지고 있으면 1을, 아니면 0을 공백으로 구분해 출력한다.

4. 풀이

숫자 카드에 적혀있는 수의 범위가 크기 때문에 모든 숫자를 하나씩 검사하기에는 시간이 너무 오래걸린다. 그래서 이분탐색 기법을 활용하여 문제를 풀어야 한다.

1) 먼저 이분탐색을 하기 위해 상근이가 가지고 있는 숫자카드를 정렬한다.

2) M개의 정수를 각각 이분탐색 기법으로 확인한다.

- start는 0, end는 num_N벡터의 가장 마지막 인덱스로 정하고 시작한다.

- flag 변수를 활용하여 그 숫자가 있는지 없는지를 저장한다. 있을경우에는 answer 벡터에 1을 추가하고, 반복문이 끝난뒤에도 flag 변수가 여전히 0이면 없다는 의미이기 때문에 answer 벡터에 0을 추가한다.

5. 소스코드

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
vector<int> num_N;
vector<int> num_M;
vector<int> answer;

int main(){
    int N, M;
    cin>>N;
    for(int i = 0; i < N; i++){
        int x;
        cin>>x;
        num_N.push_back(x);
    }
    //상근이가 갖고있는 숫자카드 정렬
    sort(num_N.begin(), num_N.end());
    
    cin>>M;
    for(int i = 0; i < M; i++){
        int y;
        cin>>y;
        num_M.push_back(y);
    }

    for(int i = 0 ; i < M; i++){
        int x = num_M[i];
        int start = 0;
        int end = num_N.size() - 1;
        int flag = 0; //그 숫자를 가지고 있으면 1, 아니면 0
        while(start <= end){
            int mid = (start+end)/2;
            if(num_N[mid] == x){
                answer.push_back(1); 
                flag = 1;
                break;
            }
            else if(num_N[mid] < x){
                start = mid + 1;
            }
            else if(num_N[mid] > x){
                end = mid - 1;
            }
        }
        if(flag == 0){
            answer.push_back(0);
        }
    }
    for(int i = 0; i < answer.size(); i++){
        cout<<answer[i]<<" ";
    }
}

[백준/BOJ/C++] 11279번 하노이 탑 이동 순서 - 재귀

Heeyeon.dev — Mon, 8 Feb 2021 16:12:51 +0900

11729번: 하노이 탑 이동 순서

세 개의 장대가 있고 첫 번째 장대에는 반경이 서로 다른 n개의 원판이 쌓여 있다. 각 원판은 반경이 큰 순서대로 쌓여있다. 이제 수도승들이 다음 규칙에 따라 첫 번째 장대에서 세 번째 장대로

www.acmicpc.net

1. 문제

세 개의 장대가 있고 첫 번째 장대에는 반경이 서로 다른 n개의 원판이 쌓여 있다. 각 원판은 반경이 큰 순서대로 쌓여있다. 이제 수도승들이 다음 규칙에 따라 첫 번째 장대에서 세 번째 장대로 옮기려 한다.

한 번에 한 개의 원판만을 다른 탑으로 옮길 수 있다.
쌓아 놓은 원판은 항상 위의 것이 아래의 것보다 작아야 한다.

이 작업을 수행하는데 필요한 이동 순서를 출력하는 프로그램을 작성하라. 단, 이동 횟수는 최소가 되어야 한다.

아래 그림은 원판이 5개인 경우의 예시이다.

2. 입력

첫째 줄에 첫 번째 장대에 쌓인 원판의 개수 N (1 ≤ N ≤ 20)이 주어진다.

3. 출력

첫째 줄에 옮긴 횟수 K를 출력한다.

두 번째 줄부터 수행 과정을 출력한다. 두 번째 줄부터 K개의 줄에 걸쳐 두 정수 A B를 빈칸을 사이에 두고 출력하는데, 이는 A번째 탑의 가장 위에 있는 원판을 B번째 탑의 가장 위로 옮긴다는 뜻이다.

4. 풀이

하노이 탑 이동 순서 문제는 재귀를 사용해서 아래 사진의 과정을 반복한다.

초기 탑을 옮기기 전.

먼저 가장 밑에 있는 원판을 빼고 위에 N-1개를 2번에 옮긴다.

그 다음, 가장 아래에 있는 N번 원판을 3번으로 옮긴다.

나머지 N-1개 원판을 3번으로 옮긴다.

이걸 재귀로 표현한 것이 아래의 코드다.

원판의 갯수가 n개라고 할 때, 이동횟수를 점화식으로 표현하면 Tn = Tn-1 * 2 + 1이다.

이를 식으로 표현하면 이동횟수는 2^n - 1이다.

5. 소스코드

#include <iostream>
#include <cmath>
using namespace std;
void hanoi(int first, int second, int third, int n){
    if(n == 1){
        cout<<first<<" "<<third<<"\n";
    }
    else{
        //N-1 개를 1번에서 2번으로 옮기고 n번째 돌을 3번으로 옮김.
        hanoi(first, third, second, n-1);
        cout<<first<<" "<<third<<"\n";
        //다시 N-1개를 2에서 3으로 옮김.
        hanoi(second, first, third, n-1);
    }
}
int main(){
    ios::sync_with_stdio(false);
    cout.tie(0);
    int N;
    cin>>N;
    int move = pow(2, N) - 1;
    cout<<move<<"\n";
    hanoi(1, 2, 3, N);
    return 0;
}

[백준/BOJ/C++] 10989번 수 정렬하기 3 - 정렬

Heeyeon.dev — Fri, 29 Jan 2021 19:55:10 +0900

10989번: 수 정렬하기 3

첫째 줄에 수의 개수 N(1 ≤ N ≤ 10,000,000)이 주어진다. 둘째 줄부터 N개의 줄에는 숫자가 주어진다. 이 수는 10,000보다 작거나 같은 자연수이다.

www.acmicpc.net

1. 문제

N개의 수가 주어졌을 때, 이를 오름차순으로 정렬하는 프로그램을 작성하시오.

2. 입력

첫째 줄에 수의 개수 N(1 ≤ N ≤ 10,000,000)이 주어진다. 둘째 줄부터 N개의 줄에는 숫자가 주어진다. 이 수는 10,000보다 작거나 같은 자연수이다.

3. 출력

첫째 줄부터 N개의 줄에 오름차순으로 정렬한 결과를 한 줄에 하나씩 출력한다.

4. 풀이

이 문제에서 메모리제한이 8MB이기 때문에 단순히 입력된 N으로 크기가 N인 배열을 만들어서 풀면 메모리 초과가 나오게 된다. 따라서, 수의 범위가 10,000까지이기 때문에 계수정렬 방식으로 정렬을 해준다.

계수정렬은 입력된 수에 해당하는 배열의 인덱스에 값을 더해주는 방식이다.

예를 들어, 숫자 5가 입력되면 arr[5]의 값에 +1을 해준다. 이렇게 모두 입력받은 다음 출력할때는 해당 인덱스의 값만큼 출력을 해준다.

** 추가로 해당문제에서 c++을 사용할때 cin과 cout으로 인해 시간초과가 걸리게 된다.

ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);

그래서 상단 코드를 추가해준다.
C표준 stream과 C++표준 stream의 동기화를 끊는 역할을 하는데, 동기화를 끊으면 C++ stream은 독립적인 버퍼를 갖게되며, 실행 속도가 향상된다.

5. 소스코드

#include <iostream>
using namespace std;
int main(){
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    int N;
    cin>>N;
    int arr[10001] = {0,};
    for(int i = 0; i < N; i++){
        int tmp;
        cin>>tmp;
        arr[tmp]++;
    }
    for(int i = 1; i < 10001; i++){
        for(int j = 0; j < arr[i]; j++){
            cout<<i<<"\n";
        }
    }
    return 0;
}

[백준/BOJ/C++] 10825번 국영수 - 정렬

Heeyeon.dev — Fri, 29 Jan 2021 18:38:42 +0900

10825번: 국영수

첫째 줄에 도현이네 반의 학생의 수 N (1 ≤ N ≤ 100,000)이 주어진다. 둘째 줄부터 한 줄에 하나씩 각 학생의 이름, 국어, 영어, 수학 점수가 공백으로 구분해 주어진다. 점수는 1보다 크거나 같고, 1

www.acmicpc.net

1. 문제

도현이네 반 학생 N명의 이름과 국어, 영어, 수학 점수가 주어진다. 이때, 다음과 같은 조건으로 학생의 성적을 정렬하는 프로그램을 작성하시오.

국어 점수가 감소하는 순서로
국어 점수가 같으면 영어 점수가 증가하는 순서로
국어 점수와 영어 점수가 같으면 수학 점수가 감소하는 순서로
모든 점수가 같으면 이름이 사전 순으로 증가하는 순서로 (단, 아스키 코드에서 대문자는 소문자보다 작으므로 사전순으로 앞에 온다.)

2. 입력

첫째 줄에 도현이네 반의 학생의 수 N (1 ≤ N ≤ 100,000)이 주어진다. 둘째 줄부터 한 줄에 하나씩 각 학생의 이름, 국어, 영어, 수학 점수가 공백으로 구분해 주어진다. 점수는 1보다 크거나 같고, 100보다 작거나 같은 자연수이다. 이름은 알파벳 대소문자로 이루어진 문자열이고, 길이는 10자리를 넘지 않는다.

3. 출력

문제에 나와있는 정렬 기준으로 정렬한 후 첫째 줄부터 N개의 줄에 걸쳐 각 학생의 이름을 출력한다.

4. 풀이

문제에서 정렬조건이 4가지나 있기 때문에 별도로 compare함수를 만들어서 정렬을 해야한다.

compare 함수에서 return을 할때 부등호 부등호 방향이 '<'이면 오름차순, '>'이면 내림차순 정렬이다.

우선순위에 맞게 compare 함수를 작성한 다음, stable_sort함수로 정렬을 해준다.

5. 소스코드

#include <iostream>
#include <algorithm>
using namespace std;
struct student{
    string name;
    int kor;
    int eng;
    int math;
};
bool compare(student s1, student s2){
    if(s1.kor == s2. kor){
        if(s1.eng == s2. eng){
            if(s1.math == s2.math){
                return s1.name < s2.name;
            }
            return s1.math > s2.math;
        }
        return s1.eng < s2.eng;
    }

    else{
        return s1.kor > s2.kor;
    }  
}
int main(){
    int N; //
    cin>>N;
    student *array = new student[N];
    for(int i = 0; i < N; i++){
        cin>>array[i].name>>array[i].kor>>array[i].eng>>array[i].math;
    }
    stable_sort(array, array+N, compare);
    for(int i = 0; i < N; i++){
        cout<<array[i].name<<"\n";
    }
    return 0;
}

[백준/BOJ/C++] 11651번 좌표 정렬하기 2 - 정렬

Heeyeon.dev — Fri, 29 Jan 2021 18:26:10 +0900

11651번: 좌표 정렬하기 2

첫째 줄에 점의 개수 N (1 ≤ N ≤ 100,000)이 주어진다. 둘째 줄부터 N개의 줄에는 i번점의 위치 xi와 yi가 주어진다. (-100,000 ≤ xi, yi ≤ 100,000) 좌표는 항상 정수이고, 위치가 같은 두 점은 없다.

www.acmicpc.net

1. 문제

2차원 평면 위의 점 N개가 주어진다. 좌표를 y좌표가 증가하는 순으로, y좌표가 같으면 x좌표가 증가하는 순서로 정렬한 다음 출력하는 프로그램을 작성하시오.

2. 입력

3. 출력

첫째 줄부터 N개의 줄에 점을 정렬한 결과를 출력한다.

4. 풀이

sort함수로 pair클래스를 정렬할 때, first인자를 기준으로 정렬이 된다. y좌표가 증가하는 순으로 정렬을 해야하기 때문에 먼저 입력된 x를 second에 넣어주고, y를 first에 넣어준다. 그 다음 sort함수를 사용해서 정렬하면 y좌표 기준으로 정렬이 된다.

5. 소스코드

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main(){
    int N;
    cin>>N;
    vector<pair<int, int>> arr(N);
    for(int i = 0; i < N; i++){
        cin>>arr[i].second>>arr[i].first;
    }
    sort(arr.begin(), arr.end());
    for(int i = 0; i < N; i++){
        cout<<arr[i].second<<" "<<arr[i].first<<"\n";
    }
}#include <iostream>

[백준/BOJ/C++] 2751번 수 정렬하기 2 - 정렬

Heeyeon.dev — Fri, 29 Jan 2021 18:19:22 +0900

2751번: 수 정렬하기 2

첫째 줄에 수의 개수 N(1 ≤ N ≤ 1,000,000)이 주어진다. 둘째 줄부터 N개의 줄에는 숫자가 주어진다. 이 수는 절댓값이 1,000,000보다 작거나 같은 정수이다. 수는 중복되지 않는다.

www.acmicpc.net

1. 문제

N개의 수가 주어졌을 때, 이를 오름차순으로 정렬하는 프로그램을 작성하시오.

2. 입력

3. 출력

첫째 줄부터 N개의 줄에 오름차순으로 정렬한 결과를 한 줄에 하나씩 출력한다.

4. 풀이

c++ 은 sort 함수를 사용해도 시간초과가 걸리지 않기 때문에 단순히 sort함수만을 사용해서 풀이가 가능하다.

5. 소스코드

#include <iostream>
#include <algorithm>
using namespace std;
int main(){
    int N;
    cin>>N;
    int *arr = new int[N];
    for(int i = 0; i < N; i++){
        cin>>arr[i];
    }
    sort(arr, arr+N);
    for(int i = 0; i < N; i++){
        cout<<arr[i]<<"\n";
    }
    return 0;
}

[백준/BOJ/C++] 11650번 좌표 정렬하기 - 정렬

Heeyeon.dev — Fri, 29 Jan 2021 18:13:05 +0900

11650번: 좌표 정렬하기

www.acmicpc.net

1. 문제

2차원 평면 위의 점 N개가 주어진다. 좌표를 x좌표가 증가하는 순으로, x좌표가 같으면 y좌표가 증가하는 순서로 정렬한 다음 출력하는 프로그램을 작성하시오.

2. 입력

3. 출력

첫째 줄부터 N개의 줄에 점을 정렬한 결과를 출력한다.

4. 풀이

vector에 pair클래스로 x,y쌍을 입력한 다음, sort 함수를 이용해 정렬한다.

5. 소스코드

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main(){
    int N;
    cin>>N;
    vector<pair<int, int>> arr(N);
    for(int i = 0; i < N; i++){
        cin>>arr[i].first>>arr[i].second;
    }
    sort(arr.begin(), arr.end());
    for(int i = 0; i < N; i++){
        cout<<arr[i].first<<" "<<arr[i].second<<"\n";
    }
    return 0;
}

[백준/BOJ/C++] 10814번 나이순 정렬 - 정렬

Heeyeon.dev — Fri, 29 Jan 2021 18:05:34 +0900

10814번: 나이순 정렬

온라인 저지에 가입한 사람들의 나이와 이름이 가입한 순서대로 주어진다. 이때, 회원들을 나이가 증가하는 순으로, 나이가 같으면 먼저 가입한 사람이 앞에 오는 순서로 정렬하는 프로그램을

www.acmicpc.net

1. 문제

온라인 저지에 가입한 사람들의 나이와 이름이 가입한 순서대로 주어진다. 이때, 회원들을 나이가 증가하는 순으로, 나이가 같으면 먼저 가입한 사람이 앞에 오는 순서로 정렬하는 프로그램을 작성하시오.

2. 입력

첫째 줄에 온라인 저지 회원의 수 N이 주어진다. (1 ≤ N ≤ 100,000)

둘째 줄부터 N개의 줄에는 각 회원의 나이와 이름이 공백으로 구분되어 주어진다. 나이는 1보다 크거나 같으며, 200보다 작거나 같은 정수이고, 이름은 알파벳 대소문자로 이루어져 있고, 길이가 100보다 작거나 같은 문자열이다. 입력은 가입한 순서로 주어진다.

3. 출력

첫째 줄부터 총 N개의 줄에 걸쳐 온라인 저지 회원을 나이 순, 나이가 같으면 가입한 순으로 한 줄에 한 명씩 나이와 이름을 공백으로 구분해 출력한다.

4. 풀이

나이순 정렬 문제는 단순한 정렬문제이기는 하지만, 나이가 같으면 가입한 순으로 정렬을 해줘야 하기 때문에, sort함수 대신 stable_sort함수를 사용한다.

stable_sort함수는 sort함수처럼 정렬을 하긴 하지만, vector의 앞의 원소 순서대로 정렬이 된다.

**추가로 회원수가 최대 100,000명이기 때문에 출력을 해줄때 endl 대신 "\n"으로 출력한다.

5. 소스코드

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int compare(pair<int, string> a, pair<int, string> b){
    if(a.first < b.first)
        return true;
    else
        return false;
    
}
int main(){
    int N;
    cin>>N;
    vector<pair<int, string>> arr(N);
    for(int i = 0; i < N; i++){
        cin>>arr[i].first>>arr[i].second;
    }
    stable_sort(arr.begin(), arr.end(), compare);

    for(int i = 0; i < N; i++){
        cout<<arr[i].first<<" "<<arr[i].second<<"\n"; //endl 쓰면 시간초과.
    }

    return 0;
}

[백준/BOJ/C++] 10819번 차이를 최대로 - 완전탐색

Heeyeon.dev — Fri, 29 Jan 2021 17:48:35 +0900

1. 문제

N개의 정수로 이루어진 배열 A가 주어진다. 이때, 배열에 들어있는 정수의 순서를 적절히 바꿔서 다음 식의 최댓값을 구하는 프로그램을 작성하시오.

|A[0] - A[1]| + |A[1] - A[2]| + ... + |A[N-2] - A[N-1]|

2. 입력

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

3. 출력

첫째 줄에 배열에 들어있는 수의 순서를 적절히 바꿔서 얻을 수 있는 식의 최댓값을 출력한다.

4. 풀이

배열의 크기가 최대 8이기 때문에, 이 문제는 숫자를 줄 세울 수 있는 모든 조합을 검사하여 최대값을 구한다.

algorithm 헤더파일을 추가하면 next_permutation 함수를 통해 순열을 구할수가 있다.

next_permutation 함수는 다음 순열이 없다면(다음에 나올 수열이 순서상 이전 순열보다 작다면) false를 반환한다.

각 순열마다 식의 결과값을 tmp에 저장한 다음 최대값인지를 검사하여 sum 변수에 최대값을 저장한다.

5. 소스코드

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int max(int a, int b){
    return a > b ? a : b;
}
int main(){
    int N;
    cin>>N;
    vector<int> arr(N);
    for(int i = 0; i < N; i++){
        cin>>arr[i];
    }
    //오름차순 정렬
    sort(arr.begin(), arr.end()); 
    
    int sum = 0, tmp = 0;
    do{
        tmp = 0;
        for(int i = 0; i < N - 1; i++){
            tmp += abs(arr[i] - arr[i + 1]);
        }
        sum = max(sum, tmp);
    } while(next_permutation(arr.begin(), arr.end()));
    cout<<sum;
}

[백준/BOJ/C++] 2503번 숫자야구 - 완전탐색

Heeyeon.dev — Fri, 29 Jan 2021 17:17:21 +0900

2503번: 숫자 야구

첫째 줄에는 민혁이가 영수에게 몇 번이나 질문을 했는지를 나타내는 1 이상 100 이하의 자연수 N이 주어진다. 이어지는 N개의 줄에는 각 줄마다 민혁이가 질문한 세 자리 수와 영수가 답한 스트

www.acmicpc.net

1. 문제

정보문화진흥원 정보 영재 동아리에서 동아리 활동을 하던 영수와 민혁이는 쉬는 시간을 틈타 숫자야구 게임을 하기로 했다.

영수는 1에서 9까지의 서로 다른 숫자 세 개로 구성된 세 자리 수를 마음속으로 생각한다. (예: 324)
민혁이는 1에서 9까지의 서로 다른 숫자 세 개로 구성된 세 자리 수를 영수에게 묻는다. (예: 123)
민혁이가 말한 세 자리 수에 있는 숫자들 중 하나가 영수의 세 자리 수의 동일한 자리에 위치하면 스트라이크 한 번으로 센다. 숫자가 영수의 세 자리 수에 있긴 하나 다른 자리에 위치하면 볼 한 번으로 센다.

예) 영수가 324를 갖고 있으면

429는 1 스트라이크 1 볼이다.
241은 0 스트라이크 2 볼이다.
924는 2 스트라이크 0 볼이다.
영수는 민혁이가 말한 수가 몇 스트라이크 몇 볼인지를 답해준다.
민혁이가 영수의 세 자리 수를 정확하게 맞추어 3 스트라이크가 되면 게임이 끝난다. 아니라면 민혁이는 새로운 수를 생각해 다시 영수에게 묻는다.

현재 민혁이와 영수는 게임을 하고 있는 도중에 있다. 민혁이가 영수에게 어떤 수들을 물어보았는지, 그리고 각각의 물음에 영수가 어떤 대답을 했는지가 입력으로 주어진다. 이 입력을 바탕으로 여러분은 영수가 생각하고 있을 가능성이 있는 수가 총 몇 개인지를 알아맞혀야 한다.

아래와 같은 경우를 생각해보자.

민혁: 123
영수: 1 스트라이크 1 볼.
민혁: 356
영수: 1 스트라이크 0 볼.
민혁: 327
영수: 2 스트라이크 0 볼.
민혁: 489
영수: 0 스트라이크 1 볼.

이때 가능한 답은 324와 328, 이렇게 두 가지이다.

영수는 동아리의 규율을 잘 따르는 착한 아이라 민혁이의 물음에 곧이곧대로 정직하게 답한다. 그러므로 영수의 답들에는 모순이 없다.

민혁이의 물음들과 각각의 물음에 대한 영수의 답이 입력으로 주어질 때 영수가 생각하고 있을 가능성이 있는 답의 총 개수를 출력하는 프로그램을 작성하시오.

2. 입력

첫째 줄에는 민혁이가 영수에게 몇 번이나 질문을 했는지를 나타내는 1 이상 100 이하의 자연수 N이 주어진다. 이어지는 N개의 줄에는 각 줄마다 민혁이가 질문한 세 자리 수와 영수가 답한 스트라이크 개수를 나타내는 정수와 볼의 개수를 나타내는 정수, 이렇게 총 세 개의 정수가 빈칸을 사이에 두고 주어진다.

3. 출력

첫 줄에 영수가 생각하고 있을 가능성이 있는 답의 총 개수를 출력한다.

4. 풀이

숫자 야구 문제는 입력되는 정보를 가지고 수의 조합을 예측하는 방법으로는 풀 수 없다.

이 문제는 완전탐색으로 풀어야 하는데, 답의 범위가 123부터 987까지이기 때문에 모든 경우를 검사하여 확인하는것이 가능하다.

먼저 입력받는 숫자와 그 숫자의 strike, ball 갯수의 정보를 저장하기 위해 num구조체를 만들고, num 구조체 배열을 입력받은 N만큼 동적 할당 해준다.

하단 코드를 보면 num 구조체에 first, second, third 변수가 있는데, 이는 각 자리별로 검사를 용이하게 하기 위함이다.

입력을 모두 받은 다음에는 123부터 987까지 반복하며 해당 숫자와 입력받은 모든 숫자들의 ball과 strike 갯수가 일치하는지 검사한다. 갯수가 일치한다면 N_count를 올려주고, 입력받은 케이스에대해 모든 비교가 끝나면 현재 N_count가 N과 일치하는지 확인한다. N과 일치한다면 그 숫자는 정답이 될 수 있는 숫자이기 때문에 answer++을 해준다.

5. 소스코드

#include <iostream>
using namespace std;
struct num{
    int question; //민혁이가 불러주는 숫자
    int strike; 
    int ball;
    int first; //백의 자리
    int second; //십의 자리
    int third; //일의 자리
};

int main(){
    int N; 
    int answer = 0;
    cin>>N;
    struct num *array = new num[N];
    int question, strike, ball;
    for(int i = 0; i < N; i++){
        cin>>question;
        cin>>strike;
        cin>>ball;
        array[i].question = question;
        array[i].strike = strike;
        array[i].ball = ball;
        array[i].first = question/100;
        array[i].second = (question%100 - question%10)/10;
        array[i].third = question%10;
    }

    int first, second, third;
    int strike_count = 0;
    int ball_count = 0;
    int N_count = 0;

    for(int i = 123; i <= 987; i++){
        strike_count = 0;
        ball_count = 0;
        N_count = 0;
        first = i/100;
        second = (i%100 - i%10)/10;
        third = i%10;
        //각 자리의 숫자가 0이 아니면서 다른 자리의 숫자와 같지 않을 때만 검사.
        if(first != second && second != third && first != third && second != 0 && third != 0){
           for(int i = 0; i < N; i++){
               strike_count = 0;
               ball_count = 0;
               //입력된 숫자와 검사한는 숫자의 자리와, 숫자가 같으면 strike_count++
               if(first == array[i].first){
                   strike_count++;
               }
               if(second == array[i].second){
                   strike_count++;
               }
               if(third == array[i].third){
                   strike_count++;
               }
               //겹치는 숫자가 있으면 ball_count++
               if(first == array[i].second || first == array[i].third){
                   ball_count++;
               }
               if(second == array[i].first || second == array[i].third){
                   ball_count++;
               }
               if(third == array[i].first || third == array[i].second){
                   ball_count++;
               }
               //검사하는 숫자의 ball과 strike가 모두 같으면 N_count++
               if(strike_count == array[i].strike && ball_count == array[i].ball){
                   N_count++;
               }
           }
           //입력된 모든경우에 대해 답이 될 수 있을 때
           if(N_count == N){
               answer++;
           }
        }

    } //123~987 for문 끝
    cout<<answer<<endl;;
    } //main

[백준/BOJ/C++] 11047번 동전 0 - Greedy

Heeyeon.dev — Tue, 26 Jan 2021 22:59:50 +0900

11047번: 동전 0

첫째 줄에 N과 K가 주어진다. (1 ≤ N ≤ 10, 1 ≤ K ≤ 100,000,000) 둘째 줄부터 N개의 줄에 동전의 가치 Ai가 오름차순으로 주어진다. (1 ≤ Ai ≤ 1,000,000, A1 = 1, i ≥ 2인 경우에 Ai는 Ai-1의 배수)

www.acmicpc.net

1. 문제

준규가 가지고 있는 동전은 총 N종류이고, 각각의 동전을 매우 많이 가지고 있다.

동전을 적절히 사용해서 그 가치의 합을 K로 만들려고 한다. 이때 필요한 동전 개수의 최솟값을 구하는 프로그램을 작성하시오.

2. 입력

첫째 줄에 N과 K가 주어진다. (1 ≤ N ≤ 10, 1 ≤ K ≤ 100,000,000)

둘째 줄부터 N개의 줄에 동전의 가치 Ai가 오름차순으로 주어진다. (1 ≤ Ai ≤ 1,000,000, A1 = 1, i ≥ 2인 경우에 Ai는 Ai-1의 배수)

3. 출력

첫째 줄에 K원을 만드는데 필요한 동전 개수의 최솟값을 출력한다.

4. 풀이

동전의 개수를 최소로 만드려면 동전의 큰 단위를 많이 사용해야한다.

동전의 가장 큰 단위부터 검사해서 입력된 K값보다 단위가 작을 때, 그 K 값을 그 동전 단위로 나눈 몫만큼 카운트에 더해준다. 그리고 K값은 그 동전을 뺀만큼 빼준다.

5. 소스코드

#include <iostream>
using namespace std;
int main(){
    int N, K; //N : 동전종류, K : 금액.
    cin>>N>>K;
    int *money = new int[N];

    for(int i = 0; i < N; i++){
        cin>>money[i];
    }

    int count = 0;
    int Q;
    for(int i = N - 1; i >= 0; i--){
        if(K >= money[i]){
            Q = K/money[i];
            count += Q;
            K -= money[i]*Q;
        }
        if(K == 0)
            break;
    }
    cout<<count;
}

[백준/BOJ/C++] 11399번 ATM - Greedy

Heeyeon.dev — Tue, 26 Jan 2021 22:38:34 +0900

11399번: ATM

첫째 줄에 사람의 수 N(1 ≤ N ≤ 1,000)이 주어진다. 둘째 줄에는 각 사람이 돈을 인출하는데 걸리는 시간 Pi가 주어진다. (1 ≤ Pi ≤ 1,000)

www.acmicpc.net

1. 문제

인하은행에는 ATM이 1대밖에 없다. 지금 이 ATM앞에 N명의 사람들이 줄을 서있다. 사람은 1번부터 N번까지 번호가 매겨져 있으며, i번 사람이 돈을 인출하는데 걸리는 시간은 Pi분이다.

사람들이 줄을 서는 순서에 따라서, 돈을 인출하는데 필요한 시간의 합이 달라지게 된다. 예를 들어, 총 5명이 있고, P1 = 3, P2 = 1, P3 = 4, P4 = 3, P5 = 2 인 경우를 생각해보자. [1, 2, 3, 4, 5] 순서로 줄을 선다면, 1번 사람은 3분만에 돈을 뽑을 수 있다. 2번 사람은 1번 사람이 돈을 뽑을 때 까지 기다려야 하기 때문에, 3+1 = 4분이 걸리게 된다. 3번 사람은 1번, 2번 사람이 돈을 뽑을 때까지 기다려야 하기 때문에, 총 3+1+4 = 8분이 필요하게 된다. 4번 사람은 3+1+4+3 = 11분, 5번 사람은 3+1+4+3+2 = 13분이 걸리게 된다. 이 경우에 각 사람이 돈을 인출하는데 필요한 시간의 합은 3+4+8+11+13 = 39분이 된다.

줄을 [2, 5, 1, 4, 3] 순서로 줄을 서면, 2번 사람은 1분만에, 5번 사람은 1+2 = 3분, 1번 사람은 1+2+3 = 6분, 4번 사람은 1+2+3+3 = 9분, 3번 사람은 1+2+3+3+4 = 13분이 걸리게 된다. 각 사람이 돈을 인출하는데 필요한 시간의 합은 1+3+6+9+13 = 32분이다. 이 방법보다 더 필요한 시간의 합을 최소로 만들 수는 없다.

줄을 서 있는 사람의 수 N과 각 사람이 돈을 인출하는데 걸리는 시간 Pi가 주어졌을 때, 각 사람이 돈을 인출하는데 필요한 시간의 합의 최솟값을 구하는 프로그램을 작성하시오.

2. 입력

첫째 줄에 사람의 수 N(1 ≤ N ≤ 1,000)이 주어진다. 둘째 줄에는 각 사람이 돈을 인출하는데 걸리는 시간 Pi가 주어진다. (1 ≤ Pi ≤ 1,000)

3. 출력

첫째 줄에 각 사람이 돈을 인출하는데 필요한 시간의 합의 최솟값을 출력한다.

4. 풀이

줄을 뒤에 서는 사람은 앞사람이 걸리는 시간이 누적 되기 때문에, 모든 시간의 합이 최소가 되려면 시간이 적게 걸리는 사람부터 ATM 줄을 서야 한다.

그래서 먼저 각 사람이 돈을 인출하는데 필요한 시간을 입력받은 다음, 오름차순으로 배열을 정렬한다.

그리고 greedy배열에는 앞에 사람부터 해당 순서 사람까지 걸리는 시간의 모든 총합을 저장하고, result 변수에 greedy 배열의 총 합을 저장하고, 출력한다.

5. 소스코드

#include <iostream>
#include <algorithm>
using namespace std;
int main(){
    int N;
    cin>>N;
    int time[1000] = {0,};
    int greedy[1000] = {0,};
    int result = 0;
    for(int i = 0; i < N; i++){
        cin>>time[i];
    }
    //시간이 적게 걸리는 순으로 정렬
    sort(time, time+N);
    greedy[0] = time[0];
    for(int i = 1; i < N; i++){
        greedy[i] += (greedy[i-1] + time[i]);
    }
    for(int i = 0; i < N; i++){
        result += greedy[i];
    }
    cout<<result;
}

[백준/BOJ/C++] 17608번 막대기 - 구현

Heeyeon.dev — Tue, 26 Jan 2021 22:20:00 +0900

17608번: 막대기

아래 그림처럼 높이만 다르고 (같은 높이의 막대기가 있을 수 있음) 모양이 같은 막대기를 일렬로 세운 후, 왼쪽부터 차례로 번호를 붙인다. 각 막대기의 높이는 그림에서 보인 것처럼 순서대로

www.acmicpc.net

1. 문제

아래 그림처럼 높이만 다르고 (같은 높이의 막대기가 있을 수 있음) 모양이 같은 막대기를 일렬로 세운 후, 왼쪽부터 차례로 번호를 붙인다. 각 막대기의 높이는 그림에서 보인 것처럼 순서대로 6, 9, 7, 6, 4, 6 이다. 일렬로 세워진 막대기를 오른쪽에서 보면 보이는 막대기가 있고 보이지 않는 막대기가 있다. 즉, 지금 보이는 막대기보다 뒤에 있고 높이가 높은 것이 보이게 된다. 예를 들어, 그림과 같은 경우엔 3개(6번, 3번, 2번)의 막대기가 보인다.

N개의 막대기에 대한 높이 정보가 주어질 때, 오른쪽에서 보아서 몇 개가 보이는지를 알아내는 프로그램을 작성하려고 한다.

2. 입력

첫 번째 줄에는 막대기의 개수를 나타내는 정수 N (2 ≤ N ≤ 100,000)이 주어지고 이어지는 N줄 각각에는 막대기의 높이를 나타내는 정수 h(1 ≤ h ≤ 100,000)가 주어진다.

3. 출력

오른쪽에서 N개의 막대기를 보았을 때, 보이는 막대기의 개수를 출력한다.

4. 풀이

오른쪽 막대기부터 봤을 때 그 막대기보다 높이가 작거나 같은것은 카운트하지 않고 큰 것만 카운트 한다.

이 때, 현재 막대기보다 큰 값이 나올때 카운트를 하면서 막대기 높이를 새로 나온 막대기 값으로 갱신한다.

이렇게 해서 우측부터 좌측으로 차례대로 계산한다.

5. 소스코드

#include <iostream>
using namespace std;
int main(){
    int N; //막대기의 개수
    cin>>N;
    int *arr = new int[N];
    int count = 0;
    int right;

    for(int i = 0; i < N; i++){
        cin>>arr[i];
    }
    right = arr[N-1];
    for(int i = N - 2; i >= 0; i--){
        if(arr[i] > right){
            count++;
            right = arr[i];
        }
    }
    cout<<count + 1;
}

[백준/BOJ/C++] 2965번 캥거루 세마리 - 구현

Heeyeon.dev — Tue, 26 Jan 2021 22:01:18 +0900

2965번: 캥거루 세마리

첫째 줄에 세 캥거루의 초기 위치 A, B, C가 주어진다. (0 < A < B < C < 100)

www.acmicpc.net

1. 문제

캥거루 세 마리가 사막에서 놀고 있다. 사막에는 수직선이 하나 있고, 캥거루는 서로 다른 한 좌표 위에 있다.

한 번 움직일 때, 바깥쪽의 두 캥거루 중 한 마리가 다른 두 캥거루 사이의 정수 좌표로 점프한다. 한 좌표 위에 있는 캥거루가 두 마리 이상일 수는 없다.

캥거루는 최대 몇 번 움직일 수 있을까?

2. 입력

첫째 줄에 세 캥거루의 초기 위치 A, B, C가 주어진다. (0 < A < B < C < 100)

3. 출력

캥거루가 최대 몇 번 움직일 수 있는지 출력한다.

4. 풀이

캥거루가 최대한 많이 움직이기 위해서는 각 캥거루 사이의 거리가 많이 남아있는 쪽으로 나머지 한 캥거루가 움직여야한다. 그리고 그 캥거루가 움직일때 각 캥거루 바로 옆 좌표로 움직여야지만 거리가 많이 확보되어서 최대한으로 움직일 수 있다.

예를 들어, 캥거루의 초기 위치가 1 3 7이라고 할 때, 밑에 표와 같이 움직였을때 최대값 3이 나온다.

	1	2	3	4	5	6	7
처음 위치	A		B				C
1번 움직임			B	A			C
2번				A	B		C
3번					B	A	C

이를 간단하게 표현하면 아래 코드의 식과 같다.

5. 소스코드

#include <iostream>
using namespace std;
int main(){
    int A, B, C;
    cin>>A>>B>>C;
    int result = 0;
	
    //B와 A 사이의 거리가 C와 B사이의 거리보다 크거나 같을 때
    if(B - A >= C - B){
        C = B - 1;
        result = C - A;
    }
    //B와 C 사이의 거리가 B와 A사이의 거리보다 크거나 같을 때
    if(C - B >= B - A){
        A = B + 1;
        result = C - A;
    }
    cout<<result;
}

[백준/BOJ/C++] 10610번 30 - Greedy

Heeyeon.dev — Tue, 26 Jan 2021 21:27:09 +0900

10610번: 30

어느 날, 미르코는 우연히 길거리에서 양수 N을 보았다. 미르코는 30이란 수를 존경하기 때문에, 그는 길거리에서 찾은 수에 포함된 숫자들을 섞어 30의 배수가 되는 가장 큰 수를 만들고 싶어한

www.acmicpc.net

1. 문제

어느 날, 미르코는 우연히 길거리에서 양수 N을 보았다. 미르코는 30이란 수를 존경하기 때문에, 그는 길거리에서 찾은 수에 포함된 숫자들을 섞어 30의 배수가 되는 가장 큰 수를 만들고 싶어한다.

미르코를 도와 그가 만들고 싶어하는 수를 계산하는 프로그램을 작성하라.

2. 입력

N을 입력받는다. N는 최대 105개의 숫자로 구성되어 있으며, 0으로 시작하지 않는다.

3. 출력

미르코가 만들고 싶어하는 수가 존재한다면 그 수를 출력하라. 그 수가 존재하지 않는다면, -1을 출력하라.

4. 풀이

어떤 숫자가 30의 배수인지를 확인하는 조건은 2가지이다.

1. 각 자리 숫자의 합이 3의 배수다.
2. 일의 자리가 0이다.

이 두가지 조건이 충족되면 그 수는 30의 배수라고 할 수 있다.

문제에서는 입력된 숫자를 가지고 30의 배수를 만드는 것이기 때문에 1번 조건은 그대로 사용하면 되고, 2번 조건을 맞추기 위해서 입력된 숫자에 0이 최소 1개 이상 포함되어 있는지를 확인해야 한다.

1번 조건을 충족시키면서 숫자에 0이 포함되어 있다면, 최대값을 만들기 위해 내림차순으로 정렬하여 출력한다.

5. 소스코드

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
bool desc(int a, int b){
    return a > b;
}
int main(){
    char arr[100000];
    char ch;
    for(int i = 0; i < 100000; i++){
        cin.get(ch);
        if(ch == '\n'){
            for(; i < 100000; i++){
                arr[i] = '\0';
            }
            break;
        }
        arr[i] = ch;
    }

    int result = 0;
    int count = 0; //0의 개수
    for(int i = 0; i < 100000; i++){
        if(arr[i] == '0'){
            count++;
        }
    }
    
    int sum = 0;
    //입력된 각 숫자를 더한다.
    for(int i = 0; i < 100000; i++){
        if(arr[i] != '\0'){
            sum += arr[i] - '0';
        }
            
    }

    //3의 배수가 아니면 count를 0으로.
    if(sum%3 != 0)
        count = 0;

    //내림차순 정렬
    sort(arr, arr+100000, desc);

    for(int i = 0; i < 100000; i++){
        //3의 배수가 아니거나, 입력 숫자에 0이 없을 때.
        if(count == 0){
            cout<<-1;
            break;
        }
        if(arr[i] == '\0')
            break;
        cout<<arr[i];
    }
}

[백준/BOJ/C++] 2875번 대회 or 인턴 - Greedy

Heeyeon.dev — Tue, 26 Jan 2021 21:14:34 +0900

2875번: 대회 or 인턴

첫째 줄에 N, M, K가 순서대로 주어진다. (0 ≤ M ≤ 100, 0 ≤ N ≤ 100, 0 ≤ K ≤ M+N),

www.acmicpc.net

1. 문제

백준대학교에서는 대회에 나갈 때 2명의 여학생과 1명의 남학생이 팀을 결성해서 나가는 것이 원칙이다. (왜인지는 총장님께 여쭈어보는 것이 좋겠다.)

백준대학교는 뛰어난 인재들이 많아 올해에도 N명의 여학생과 M명의 남학생이 팀원을 찾고 있다. 대회에 참여하려는 학생들 중 K명은 반드시 인턴쉽 프로그램에 참여해야 한다. 인턴쉽에 참여하는 학생은 대회에 참여하지 못한다.

백준대학교에서는 뛰어난 인재들이 많기 때문에, 많은 팀을 만드는 것이 최선이다.

여러분은 여학생의 수 N, 남학생의 수 M, 인턴쉽에 참여해야하는 인원 K가 주어질 때 만들 수 있는 최대의 팀 수를 구하면 된다.

2. 입력

첫째 줄에 N, M, K가 순서대로 주어진다. (0 ≤ M ≤ 100, 0 ≤ N ≤ 100, 0 ≤ K ≤ M+N),

3. 출력

만들 수 있는 팀의 최대 개수을 출력하면 된다.

4. 풀이

먼저 한 팀이 여학생 2명, 남학생 1명으로 구성되기 때문에 특정 조건을 만족할때까지 입력된 여학생,남학생 수에서 각각 2명, 1명씩을 빼면서 팀을 만들어준다. 팀 카운트를 1씩 올려준다.

여기서 조건은 K명의 인원이 인턴쉽에 참여해야하기 때문에 팀은 만들고 남은 학생이 K보다 많아야 한다.

while문으로 표현을 하면 N + M >= K + 3 일 때까지인데, 여기서 3을 더해주는것은 while문을 한번 돌때 각각 2명, 1명이 빠져서 총 3명이 팀으로 빠지기 때문이다. 이 식을 다르게 표현하면 N + M - 3 >= K 로 표현할 수 있겠다.

5. 소스코드

#include <iostream>
using namespace std;
int main(){
    int N; //여학생
    int M; //남학생
    int K; //인턴쉽에 참가해야하는 인원
    
    cin>>N>>M>>K;

    int team = 0; //팀 개수

    while(N >= 2 && M >= 1 && N+M >= K + 3){
        N -= 2;
        M -= 1;
        team++;
    }
    cout<<team;
}#include <iostream>

[백준/BOJ/C++] 1003번 피보나치 함수 - Dynamic Programming

Heeyeon.dev — Sat, 16 Jan 2021 15:59:09 +0900

1003번: 피보나치 함수

각 테스트 케이스마다 0이 출력되는 횟수와 1이 출력되는 횟수를 공백으로 구분해서 출력한다.

www.acmicpc.net

1. 문제

다음 소스는 N번째 피보나치 수를 구하는 C++ 함수이다.

fibonacci(3)을 호출하면 다음과 같은 일이 일어난다.

fibonacci(3)은 fibonacci(2)와 fibonacci(1) (첫 번째 호출)을 호출한다.
fibonacci(2)는 fibonacci(1) (두 번째 호출)과 fibonacci(0)을 호출한다.
두 번째 호출한 fibonacci(1)은 1을 출력하고 1을 리턴한다.
fibonacci(0)은 0을 출력하고, 0을 리턴한다.
fibonacci(2)는 fibonacci(1)과 fibonacci(0)의 결과를 얻고, 1을 리턴한다.
첫 번째 호출한 fibonacci(1)은 1을 출력하고, 1을 리턴한다.
fibonacci(3)은 fibonacci(2)와 fibonacci(1)의 결과를 얻고, 2를 리턴한다.

1은 2번 출력되고, 0은 1번 출력된다. N이 주어졌을 때, fibonacci(N)을 호출했을 때, 0과 1이 각각 몇 번 출력되는지 구하는 프로그램을 작성하시오.

2. 입력

첫째 줄에 테스트 케이스의 개수 T가 주어진다.

각 테스트 케이스는 한 줄로 이루어져 있고, N이 주어진다. N은 40보다 작거나 같은 자연수 또는 0이다.

3. 출력

각 테스트 케이스마다 0이 출력되는 횟수와 1이 출력되는 횟수를 공백으로 구분해서 출력한다.

4. 풀이

이 문제의 시간제한은 0.25초 이기 때문에 단순하게 재귀로 돌아가는 피보나치 함수에서 출력되는 횟수를 카운트 하는 방식으로 코드를 작성하면 시간초과가 나오게 된다. 그래서 dp로 풀어야 하는데 우선 N번째 피보나치 수에서 0과 1이 각각 몇번씩 출력되는지 표로 살펴보도록 하자.

N	0 출력 횟수	1 출력 횟수
0	1	0
1	0	1
2	1	1
3	1	2
4	2	3
5	3	5
6	5	8
7	8	13
8	13	21

0출력 횟수는 N이 1일때부터 피보나치 수열을 따르게 되고, 1출력 횟수는 N이 0일때부터 피보나치 수열을 따르게 된다.

즉, N번째 피보나치수는 dp[N-1]만큼 0이 출력되고, dp[N]만큼 1이 출력된다.

다만, 코드에서 주의해야 할 부분은 N이 0일때는 이 규칙을 따르지 않기때문에 별도로 처리를 해주어야한다.

5. 소스코드

#include <iostream>
using namespace std;
int main(){
    int T; //테스트 케이스의 개수
    cin >> T;
    int *arr = new int[T];
    for(int i = 0; i < T; i++){
        cin >> arr[i];
    }

    int dp[41] = {0, 1, 1, };
    for(int i = 3; i < 41; i++){
        dp[i] = dp[i - 1] + dp[i - 2];
    }

    for(int i = 0; i < T; i++){
        if(arr[i] == 0){
            cout << "1 0" << endl;
        }
        else
        cout << dp[arr[i] - 1] << " " <<dp[arr[i]] <<endl;
    }
}

[백준/BOJ/C++] 14501번 퇴사 - Dynamic Programming

Heeyeon.dev — Thu, 14 Jan 2021 22:13:04 +0900

이미지를 클릭하면 문제 링크로 이동합니다.

1. 문제

상담원으로 일하고 있는 백준이는 퇴사를 하려고 한다.

오늘부터 N+1일째 되는 날 퇴사를 하기 위해서, 남은 N일 동안 최대한 많은 상담을 하려고 한다.

백준이는 비서에게 최대한 많은 상담을 잡으라고 부탁을 했고, 비서는 하루에 하나씩 서로 다른 사람의 상담을 잡아놓았다.

각각의 상담은 상담을 완료하는데 걸리는 기간 Ti와 상담을 했을 때 받을 수 있는 금액 Pi로 이루어져 있다.

N = 7인 경우에 다음과 같은 상담 일정표를 보자.

	1일	2일	3일	4일	5일	6일	7일
T[i]	3	5	1	1	2	4	2
P[i]	10	20	10	20	15	40	200

1일에 잡혀있는 상담은 총 3일이 걸리며, 상담했을 때 받을 수 있는 금액은 10이다. 5일에 잡혀있는 상담은 총 2일이 걸리며, 받을 수 있는 금액은 15이다.

상담을 하는데 필요한 기간은 1일보다 클 수 있기 때문에, 모든 상담을 할 수는 없다. 예를 들어서 1일에 상담을 하게 되면, 2일, 3일에 있는 상담은 할 수 없게 된다. 2일에 있는 상담을 하게 되면, 3, 4, 5, 6일에 잡혀있는 상담은 할 수 없다.

또한, N+1일째에는 회사에 없기 때문에, 6, 7일에 있는 상담을 할 수 없다.

퇴사 전에 할 수 있는 상담의 최대 이익은 1일, 4일, 5일에 있는 상담을 하는 것이며, 이때의 이익은 10+20+15=45이다.

상담을 적절히 했을 때, 백준이가 얻을 수 있는 최대 수익을 구하는 프로그램을 작성하시오.

2. 입력

첫째 줄에 N (1 ≤ N ≤ 15)이 주어진다.

둘째 줄부터 N개의 줄에 Ti와 Pi가 공백으로 구분되어서 주어지며, 1일부터 N일까지 순서대로 주어진다. (1 ≤ Ti ≤ 5, 1 ≤ Pi ≤ 1,000)

3. 출력

첫째 줄에 백준이가 얻을 수 있는 최대 이익을 출력한다.

4. 풀이

i번째 날에 일을 시작했을때 받을 수 있는 금액의 최대값을 퇴사전날부터 시작해서 거꾸로 구한다.

i번째 날에 하는 상담의 소요기간이 N+1번째 날보다 클 때 그 상담은 할 수가 없기 때문에, 그 다음날의 최대값을 반영한다.

	1일	2일	3일	4일	5일
T[i]	1	1	4	1	1
P[i]	10	20	10	20	30

예를 들어, 위의 표와 같이 예제가 주어졌을때, 3일째 상담은 4일이 소요되기 때문에 상담을 할 수가 없다. 그래서, 4일에 상담을 시작했을때의 최대값을 3일째의 최대값에 대입한다. (P[i] = P[i + 1])

i번째 날에 상담이 가능할 때는 1) i번째 날의 금액 + (i + T[i])번째 날의 최대값 또는 2) i+1번째 날의 최대값 중 더 큰 값을 택한다.

그래서 최종적으로 나올 수 있는 최대값을 출력한다.

위의 표를 기준으로 계산했을때

P[5] = 30

P[4] = max(P[5], P[4] + P[4 + T[4]) = max(P[5], P[4]+P[5]) = P[4]+P[5] = 50

P[3] = P[4] //3 + T[3] > 6

이런식으로 계속 계산해보면 예제의 최대값은 80이다.

5. 소스코드

#include <iostream>
using namespace std;
int max(int a, int b){
    return a > b ? a : b;
}
int main(){
    int N;
    cin>>N;
    int T[17] = {0,}; // 상담 소요 기간
    int P[17] = {0,}; //받을 수 있는 금액
    int result = 0;

    //기간, 금액 입력
    for(int i = 1; i < N+1; i++){
        cin >> T[i] >> P[i] ;
    }
    
    for(int i = N; i > 0; i--){
        if(i + T[i] > N + 1){
            P[i] = P[i+1];
        }
        else{
            P[i] = max(P[i+1], P[i] + P[i+T[i]]);
        }
        result = max(result, P[i]);
    }
    cout<<result;
}

[백준/BOJ/C++] 2156번 포도주 시식 - Dynamic Programming

Heeyeon.dev — Tue, 12 Jan 2021 22:54:26 +0900

이미지를 클릭하면 문제 링크로 이동합니다.

1. 문제

효주는 포도주 시식회에 갔다. 그 곳에 갔더니, 테이블 위에 다양한 포도주가 들어있는 포도주 잔이 일렬로 놓여 있었다. 효주는 포도주 시식을 하려고 하는데, 여기에는 다음과 같은 두 가지 규칙이 있다.

포도주 잔을 선택하면 그 잔에 들어있는 포도주는 모두 마셔야 하고, 마신 후에는 원래 위치에 다시 놓아야 한다.
연속으로 놓여 있는 3잔을 모두 마실 수는 없다.

효주는 될 수 있는 대로 많은 양의 포도주를 맛보기 위해서 어떤 포도주 잔을 선택해야 할지 고민하고 있다. 1부터 n까지의 번호가 붙어 있는 n개의 포도주 잔이 순서대로 테이블 위에 놓여 있고, 각 포도주 잔에 들어있는 포도주의 양이 주어졌을 때, 효주를 도와 가장 많은 양의 포도주를 마실 수 있도록 하는 프로그램을 작성하시오.

예를 들어 6개의 포도주 잔이 있고, 각각의 잔에 순서대로 6, 10, 13, 9, 8, 1 만큼의 포도주가 들어 있을 때, 첫 번째, 두 번째, 네 번째, 다섯 번째 포도주 잔을 선택하면 총 포도주 양이 33으로 최대로 마실 수 있다.

2. 입력

첫째 줄에 포도주 잔의 개수 n이 주어진다. (1≤n≤10,000) 둘째 줄부터 n+1번째 줄까지 포도주 잔에 들어있는 포도주의 양이 순서대로 주어진다. 포도주의 양은 1,000 이하의 음이 아닌 정수이다.

3. 출력

첫째 줄에 최대로 마실 수 있는 포도주의 양을 출력한다.

4. 풀이

이 문제 연속된 3잔을 마실 수 없다는 점이 dp 배열을 구하는 중요한 조건인데, 연속된 3개의 숫자를 선택할 수 없다는 점에 있어서 2579번 계단 오르기 문제와 유사하다.

*2579번 계단 오르기 - heeyeon-dev.tistory.com/10?category=452163

[백준/BOJ/C++] 2579번 계단 오르기 - Dynamic Programming

1. 문제 계단 오르기 게임은 계단 아래 시작점부터 계단 꼭대기에 위치한 도착점까지 가는 게임이다. <그림 1>과 같이 각각의 계단에는 일정한 점수가 쓰여 있는데 계단을 밟으면 그 계단에 쓰여

heeyeon-dev.tistory.com

그래서 기본 dp 배열을 구하는 식은 같다.

dp[i] = max(dp[i-2] + cup[i], dp[i-3] + cup[i-1] + cup[i]);

하지만, 포도주 시식 문제에서는 위의 식만으로는 해결할 수가 없다. 반례가 생기기 때문이다.

200, 100, 1, 2, 10, 400 가 예시로 주어졌을 때, 위의 식으로만 계산하면 최대값은 702가 나온다.

하지만, 실제 조건에 맞는 최대값은 (200, 100, 10, 400)을 택한 710이다. 반례로 포도주를 두 번 먹지 않는 경우가 최대값이 나올 수 있다.

따라서 점화식이 한가지 더 필요하다.

dp[i] = max(dp[i-1], dp[i]);

dp 배열에서 바로 직전 값과 비교만 해주면 된다.

5. 소스코드

#include <iostream>
using namespace std;
int max(int a, int b){
    return a > b ? a : b;
}
int main(){
    int N; // 포도주 잔의 개수
    cin >> N; 

    int cup[10001] = {0, }; //포도주 값 저장 배열
    int dp[10001] = {0, }; //최대값 저장 배열

   
    for(int i = 1; i < N+1; i++){
        cin>>cup[i]; 
    }

    dp[1] = cup[1];
    dp[2] = cup[1] + cup[2];

    for(int i = 3; i < N + 1; i++){
        dp[i] = max(dp[i-2] + cup[i], dp[i-3] + cup[i-1] + cup[i]);
        dp[i] = max(dp[i-1], dp[i]);
    }

    cout << dp[N] << endl;
}

[백준/BOJ/C++] 2193번 이친수 - Dynamic Programming

Heeyeon.dev — Sun, 10 Jan 2021 18:08:33 +0900

이미지를 클릭하면 문제 링크로 이동합니다.

1. 문제

0과 1로만 이루어진 수를 이진수라 한다. 이러한 이진수 중 특별한 성질을 갖는 것들이 있는데, 이들을 이친수(pinary number)라 한다. 이친수는 다음의 성질을 만족한다.

이친수는 0으로 시작하지 않는다.
이친수에서는 1이 두 번 연속으로 나타나지 않는다. 즉, 11을 부분 문자열로 갖지 않는다.

예를 들면 1, 10, 100, 101, 1000, 1001 등이 이친수가 된다. 하지만 0010101이나 101101은 각각 1, 2번 규칙에 위배되므로 이친수가 아니다.

N(1 ≤ N ≤ 90)이 주어졌을 때, N자리 이친수의 개수를 구하는 프로그램을 작성하시오.

2. 입력

첫째 줄에 N이 주어진다.

3. 출력

첫째 줄에 N자리 이친수의 개수를 출력한다.

4. 풀이

문제를 풀기에 앞서 N에 따라 나올 수 있는 이친수를 나열해보았다.

이친수를 나열한 다음, 2번째 규칙인 '11을 부분 문자열로 갖지 않는다.'를 고려해보면 이친수가 가지는 규칙성을 파악할 수 있다. 이친수는 1로 시작해야 하는데 11은 부분 문자열로 가질 수 없기 때문에 가장 앞자리 두 숫자는 10이 될 수밖에 없다. 따라서, 10 뒤에 따라오는 숫자들만 고려해보도록 한다.

위의 그림에서 빨간색 네모 박스를 먼저 살펴보자. N이 4일때 앞에 10을 제외하면 00, 01, 10으로 구성이 되는데 이는 N이 3일 때와 N이 2일 때 모든 숫자가 구성으로 갖고 있는 숫자와 동일하다.

다음으로 파란색 네모박스를 살펴보면, 앞서 규칙과 동일하게 N이 5일 때 000, 001, 010, 100, 101로 구성되는데 4와, 3에서 모든 숫자들의 구성과 동일하다.

따라서, N에 따른 이친수의 개수를 저장하는 배열을 dp라고 할 때, dp[i] = dp[i - 1] + dp[i - 2] 라는 식을 도출할 수 있게 된다.

5. 소스코드

#include <iostream>
using namespace std;
int main(){
    int N; //N 자리
    cin>>N; 

    long dp[91] = {0,};
    dp[0] = 0; dp[1] = 1;
    for(int i = 2; i < N+1; i++){
        dp[i] = dp[i - 1] + dp[i - 2];
    }
    cout<<dp[N];
}

[백준/BOJ/C++] 2579번 계단 오르기 - Dynamic Programming

Heeyeon.dev — Sat, 9 Jan 2021 21:13:53 +0900

이미지를 클릭하면 문제 링크로 이동합니다.

1. 문제

계단 오르기 게임은 계단 아래 시작점부터 계단 꼭대기에 위치한 도착점까지 가는 게임이다. <그림 1>과 같이 각각의 계단에는 일정한 점수가 쓰여 있는데 계단을 밟으면 그 계단에 쓰여 있는 점수를 얻게 된다.

예를 들어 <그림 2>와 같이 시작점에서부터 첫 번째, 두 번째, 네 번째, 여섯 번째 계단을 밟아 도착점에 도달하면 총 점수는 10 + 20 + 25 + 20 = 75점이 된다.

계단 오르는 데는 다음과 같은 규칙이 있다.

계단은 한 번에 한 계단씩 또는 두 계단씩 오를 수 있다. 즉, 한 계단을 밟으면서 이어서 다음 계단이나, 다음 다음 계단으로 오를 수 있다.
연속된 세 개의 계단을 모두 밟아서는 안 된다. 단, 시작점은 계단에 포함되지 않는다.
마지막 도착 계단은 반드시 밟아야 한다.

따라서 첫 번째 계단을 밟고 이어 두 번째 계단이나, 세 번째 계단으로 오를 수 있다. 하지만, 첫 번째 계단을 밟고 이어 네 번째 계단으로 올라가거나, 첫 번째, 두 번째, 세 번째 계단을 연속해서 모두 밟을 수는 없다.

각 계단에 쓰여 있는 점수가 주어질 때 이 게임에서 얻을 수 있는 총 점수의 최댓값을 구하는 프로그램을 작성하시오.

2. 입력

입력의 첫째 줄에 계단의 개수가 주어진다.

둘째 줄부터 한 줄에 하나씩 제일 아래에 놓인 계단부터 순서대로 각 계단에 쓰여 있는 점수가 주어진다. 계단의 개수는 300이하의 자연수이고, 계단에 쓰여 있는 점수는 10,000이하의 자연수이다.

3. 출력

첫째 줄에 계단 오르기 게임에서 얻을 수 있는 총 점수의 최댓값을 출력한다.

4. 풀이

이 문제의 규칙을 다시한번 정리하자면 계단을 오를때 +1 또는 +2 칸을 오를 수 있고, 시작점을 제외하고 연속된 세 계단을 밟으면 안된다. 이 두번째 규칙은 다시 얘기하자면 +1 +1을 연속으로 오르면 안된다는 얘기다.

따라서, 도착하는 계단을 기준으로 했을 때, 1) 2계단을 올라와서 도착하거나 2) +2계단을 한 다음 +1 계단을 해서 올라오는 경우. 이렇게 두가지로 구분할 수 있다.

도착점을 기준으로 dp 배열을 채워나가야 하기 때문에 먼저 1,2,3번째 dp 배열을 채워준다.

1번째 계단까지의 최대값은 첫번째 계단의 값이다.

2번째 계단까지는 +1 +1 또는 +2 중 최대값을 택해야하는데, 거쳐가는 계단수가 많을수록 최대값이 커지게된다. 따라서, 2번째 계단의 최대값은 (첫번째 계단 + 두번째 계단)이다.

3번째 계단의 최대값은 +1 +2(첫번째 계단 + 세번째 계단) 또는 +2 +1(두번째 계단 + 세번째 계단) 중 더 큰 값이 최대값이다.

이렇게 세번째 계단까지 계산해서 dp 배열을 채워준 다음, 위의 사진처럼 도착계단을 기준으로 -2계단의 최대값에 현재 계단값을 더한것과 -3계단의 최대값에 -1계단과 현재 계단값을 더한것 중 더 큰 값을 취하면 된다.

5. 소스코드

#include <iostream>
using namespace std;
int max(int a, int b){
    return a > b ? a : b;
}
int main(){
    int N; // 계단 개수 
    cin >> N; //계단 입력

    int stair[501] = {0, }; //계단 점수 입력할 배열
    int dp[501] = {0, }; //최대값 저장 배열

    //계단 점수 입력
    for(int i = 1; i < N+1; i++){
        cin>>stair[i]; 
    }

    dp[1] = stair[1]; //첫번째 계단까지의 최대값은 첫번째 계단의 값.
    dp[2] = stair[1] + stair[2]; //두번째 계단까지의 최대값은 (첫번째 계단 + 두번째 계단)
    dp[3] = max(stair[1] + stair[3], stair[2] + stair[3]); //세번째 계단은 +1 +2 or +2 +1 중 최대값

    for(int i = 4; i < N+1; i++){
        dp[i] = max(dp[i - 2] + stair[i], dp[i - 3] + stair[i -1] + stair[i]);
    }

    cout << dp[N] << endl;
}

[백준/BOJ/C++] 1932번 정수 삼각형 - Dynamic Programming

Heeyeon.dev — Fri, 8 Jan 2021 17:12:48 +0900

이미지를 클릭하면 문제 링크로 이동합니다.

1. 문제

7
3 8
8 1 0
2 7 4 4
4 5 2 6 5

위 그림은 크기가 5인 정수 삼각형의 한 모습이다.

맨 위층 7부터 시작해서 아래에 있는 수 중 하나를 선택하여 아래층으로 내려올 때, 이제까지 선택된 수의 합이 최대가 되는 경로를 구하는 프로그램을 작성하라. 아래층에 있는 수는 현재 층에서 선택된 수의 대각선 왼쪽 또는 대각선 오른쪽에 있는 것 중에서만 선택할 수 있다.

삼각형의 크기는 1 이상 500 이하이다. 삼각형을 이루고 있는 각 수는 모두 정수이며, 범위는 0 이상 9999 이하이다.

2. 입력

첫째 줄에 삼각형의 크기 n(1 ≤ n ≤ 500)이 주어지고, 둘째 줄부터 n+1번째 줄까지 정수 삼각형이 주어진다.

3. 출력

첫째 줄에 합이 최대가 되는 경로에 있는 수의 합을 출력한다.

4. 풀이

정수 삼각형에서 합이 최대가 되는 경로에 있는 수의 합을 구하기 위해서는 그 이전층까지의 합에 다음 층의 숫자를 더해서 계속해서 최댓값을 찾아 나가면 된다.

여기서 수를 더할 때 위의 사진처럼 삼각형의 좌측 끝과 우측 끝은 선택의 여지없이 바로 위에 있는 수를 더할 수밖에 없다.

반면, 삼각형의 양끝에 위치하지 않은 수들은 그 수에서 좌측 상단 또는 우측 상단에 있는 숫자 중 하나를 택해서 더해야 한다. 여기서 모든 경우를 구해서 마지막에 최댓값을 구하기보다는 둘 중 어떤 경우가 더 큰지 고려하여 그 숫자만을 더하는 것이 최댓값을 구하기에 효율적이다. 그리고, 계산을 할 때마다 해당 숫자가 최댓값인지를 확인하여 최종적으로 나온 최댓값을 출력해주면 된다.

사용 변수 : n(삼각형의 크기), max_num(최댓값 //반복문에서 갱신되는 최댓값을 저장한다.), arr(정수 삼각형과 계산 값을 저장하는 2차원 배열)

1) 먼저 삼각형의 크기를 입력받고 입력받은 크기의 2차원 배열을 생성한 다음, 정수 삼각형을 입력받는다.

2) 반복문으로 모든 숫자를 하나씩 검사하는데 이때,

삼각형의 좌측 끝인 경우와 우측 끝인 경우에는 바로 위층의 각 끝의 숫자를 더해준다.
삼각형의 양끝이 아닌 경우에는, 그 숫자의 대각선 왼쪽을 더하는 것과 대각선 오른쪽을 더하는 것 중 더 큰 경우를 택하여 더해준다.
max_num 변수에 현재 숫자가 지금까지 나온 최댓값보다 큰지 확인하여 최댓값을 변경해준다.

5. 소스코드

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

int max(int a, int b){
    return a > b ? a : b;
}

int main(){
    int n; //삼각형의 크기
    cin>>n; //삼각형 크기 입력
    int max_num = 0; //반복문에서 갱신되는 최대값을 저장.

    //정수 삼각형 2차원배열 동적할당
    int **arr = new int*[n];
    for(int i = 0; i < n; i++){
        arr[i] = new int[n];
        memset(arr[i], 0, sizeof(int)*n);
    }

    //정수 삼각형 입력
    for(int i = 0; i < n; i++){
        for(int j = 0; j <= i; j++){
            cin>>arr[i][j];
        }
    }

    for(int i = 1; i < n; i++){
        for(int j = 0; j <= i; j++){
            if(j == 0){ //삼각형의 좌측 끝인 경우
                arr[i][j] = arr[i-1][j] + arr[i][j];
            }
            else if(j == i){ //삼각형의 우측 끝인 경우
                arr[i][j] = arr[i-1][j-1] + arr[i][j];
            }
            else{
                arr[i][j] = max(arr[i-1][j-1] + arr[i][j], arr[i-1][j] + arr[i][j]);
            }
            max_num = max(max_num, arr[i][j]);
        }
    }
    cout<<max_num;
    return 0;
}

[백준/BOJ/C++] 9095번 1, 2, 3 더하기 - Dynamic Programming

Heeyeon.dev — Thu, 7 Jan 2021 22:32:18 +0900

1. 문제

정수 4를 1, 2, 3의 합으로 나타내는 방법은 총 7가지가 있다. 합을 나타낼 때는 수를 1개 이상 사용해야 한다.

1+1+1+1
1+1+2
1+2+1
2+1+1
2+2
1+3
3+1

정수 n이 주어졌을 때, n을 1, 2, 3의 합으로 나타내는 방법의 수를 구하는 프로그램을 작성하시오.

2. 입력

첫째 줄에 테스트 케이스의 개수 T가 주어진다. 각 테스트 케이스는 한 줄로 이루어져 있고, 정수 n이 주어진다. n은 양수이며 11보다 작다.

3. 출력

각 테스트 케이스마다, n을 1, 2, 3의 합으로 나타내는 방법의 수를 출력한다.

4. 풀이

사용 변수 : T(테스트 케이스 개수), testcase 배열(각각의 테스트 케이스 입력 값을 저장하는 배열), arr 배열(1에서 10까지의 경우의 수를 저장하는 배열)

이 문제는 단순히 1,2,3만 사용하여 자연수의 분할을 나타내는 것이기 때문에 'BOJ 1463번 1로 만들기'문제와 같이 bottom-up방식으로 문제를 해결하면 된다.

위의 그림을 보고 숫자 4를 예시로 들면 4는 1에서 +3, 2에서 +2, 3에서 +1을 한 것과 같다. 거꾸로 생각하면 4의 경우의 수는 4에서 -1, -2, -3을 한 경우의 수의 합과 같다. 문제에서 주어진 입력이 n은 11보다 작기 때문에 최대 10까지의 경우를 구한 다음 각각 테스트 케이스에서 원하는 숫자의 경우의 수를 출력해주면 된다.

1) 먼저 테스트 케이스 개수를 입력받고 그 개수만큼 배열을 할당하여 배열에 각각의 테스트 케이스를 저장한다.

2) for문으로 i는 1부터 10까지 반복하며 그 수에서 1, 2, 3을 뺀 경우의 수를 arr[i]에 더해준다.

3) 마지막으로 저장해뒀던 testcase배열안의 테스트 케이스 값을 arr배열 인덱스로 넣어 그 값에 해당하는 방법의 수를 출력한다.

5. 소스코드

#include <iostream>
using namespace std;
int main(){
    int T; //테스트 케이스 개수
    cin>>T; //테스트 케이스 개수 입력
    int* testcase = new int[T]; //테스트 케이스 개수만큼 배열 할당
    int arr[12] = {0, }; //방법의 수를 저장해 놓을 배열

    for(int i = 0; i < T; i++){ //테스트 케이스 각각 입력
        cin>>testcase[i];
    }

    arr[0] = 1; //계산의 편의를 위해 arr[0] = 1로 설정.
    for(int i = 1; i < 11; i++){
        if(i - 1 >= 0){
            arr[i] += arr[i - 1];
        }
        if(i - 2 >= 0){
            arr[i] += arr[i - 2];
        }
        if(i - 3 >= 0){
            arr[i] += arr[i - 3];
        }
    }

    for(int i = 0; i < T; i++){
        cout<<arr[testcase[i]]<<endl; //arr 배열에 저장해놓은 결과 출력
    }

    return 0;
}

[백준/BOJ/C++] 1463번 1로 만들기 - Dynamic Programming

Heeyeon.dev — Wed, 6 Jan 2021 23:16:28 +0900

1. 문제

정수 X에 사용할 수 있는 연산은 다음과 같이 세 가지 이다.

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

정수 N이 주어졌을 때, 위와 같은 연산 세 개를 적절히 사용해서 1을 만들려고 한다. 연산을 사용하는 횟수의 최솟값을 출력하시오.

2. 입력

첫째 줄에 1보다 크거나 같고, 106보다 작거나 같은 정수 N이 주어진다.

3. 출력

첫째 줄에 연산을 하는 횟수의 최솟값을 출력한다.

4. 풀이

사용 변수 : N(입력받는 정수), arr 배열

연산 횟수를 최소한으로 하려면 1을 빼는것보다는 2와 3으로 나누는것이 유리하고, 2로 나누는것보다는 3으로 나누는게 유리하다.

보통은 그러한데 예시에서 봤을때 10의 경우는 10 -> 9 -> 3 -> 1로 3번만에 1로 만드는 것이 가능하다. 10은 2로 나누어지지만 1을 뺀 후에 3으로 나누는 것이 연산 횟수를 최소한으로 만드는데에 유리하다. 이런 경우는 다 확인할수가 없기 때문에 bottom - up 방식으로 문제를 해결한다.

*bottom - up 방식이란? - 작은 문제부터 값을 구해 전체의 값을 구하는 방식.

1) 먼저 코드의 단순화를 위해 최소값을 구하는 min 함수를 정의해준다.

2) main 함수에서 N과 arr 배열을 선언하고, N을 입력받는다.(여기서 arr배열의 크기는 10^6 + 1로 하였는데, 입력값이 최대 10^6이기 때문이다.)

3) 먼저 arr[i] = arr[i - 1] + 1로 할당하는데 이는 i가 2나 3으로 나누어지지 않는경우이다.

예를 들어, i가 7일때 arr[7] = arr[6] + 1이다. 이는 거꾸로 생각했을 때 정수 7이 주어졌을 때 1을 빼서 숫자 6을 만든것과 같다.

4) 다음으로 i가 2 또는 3으로 나눠질때 i에서 1을 빼는것과 나누는것 중 연산횟수가 더 작은 것을 배열에 대입한다.

5) 위의 for문으로 각 숫자별로 해당하는 최소연산값을 배열에 대입해놓았기 때문에 arr[N]으로 최소연산값을 출력한다.

5. 소스코드(C++)

#include <iostream>
using namespace std;
int min(int a, int b){
    return a < b ? a : b;
}

int main(){
    int N;
    int arr[1000001] = {0, };
    cin >> N;

    for(int i = 2; i <= N; i++){
        arr[i] = arr[i - 1] + 1;
        if(i%2 == 0){
            arr[i] = min(arr[i], arr[i/2] + 1);
        }
        if(i%3 == 0){
            arr[i] = min(arr[i], arr[i/3] + 1);
        }
    }
    cout<<arr[N];
    return 0;
}

[백준/BOJ/C++] 2839번 설탕배달 - Dynamic Programming

Heeyeon.dev — Tue, 5 Jan 2021 16:24:29 +0900

1. 문제

상근이는 요즘 설탕공장에서 설탕을 배달하고 있다. 상근이는 지금 사탕가게에 설탕을 정확하게 N킬로그램을 배달해야 한다. 설탕공장에서 만드는 설탕은 봉지에 담겨 있다. 봉지는 3킬로그램 봉지와 5킬로그램 봉지가 있다.

상근이는 귀찮기 때문에, 최대한 적은 봉지를 들고 가려고 한다. 예를 들어, 18킬로그램 설탕을 배달해야 할 때, 3킬로그램 봉지 6개를 가져가도 되지만, 5킬로그램 3개와 3킬로그램 1개를 배달하면, 더 적은 개수의 봉지를 배달할 수 있다.

상근이가 설탕을 정확하게 N킬로그램 배달해야 할 때, 봉지 몇 개를 가져가면 되는지 그 수를 구하는 프로그램을 작성하시오.

2. 입력

첫째 줄에 N이 주어진다. (3 ≤ N ≤ 5000)

3. 출력

상근이가 배달하는 봉지의 최소 개수를 출력한다. 만약, 정확하게 N킬로그램을 만들 수 없다면 -1을 출력한다.

4. 풀이

사용 변수 : N(입력받는 설탕 무게), result(출력할 봉지의 최소 개수), remainder(설탕 무게에서 5kg 봉지에 담고 남은 무게)

1) 설탕무게 N을 입력받는다.

2) 봉지를 최소한의 개수로 가져가려면 5kg짜리 봉지의 개수가 많아야 하기 때문에 우선 입력받은 설탕 무게를 최대한 5kg 봉지에 넣는다. result = N/5

3) 설탕 전체에서 5kg 봉지에 담고 남은 무게가 3으로 나눠지면 3kg 봉지에 넣은 만큼 결과에 더해준다. 만약, 3으로 나눠지지 않는다면 5kg 봉지 개수 하나를 뺀다.(그럼, 남은 무게에 +5가 된다.)

5. 소스코드(C++)

#include <iostream>
using namespace std;
int main(){
    int N; //설탕 무게
    int result; //봉지 갯수
    int remainder; //남은 무게

    cin>>N; //설탕 입력

    result = N / 5; 

    while (result >= 0){ 
        remainder = N - result * 5; //설탕 전체에서 5kg봉지에 담고 남은 무게
        if(remainder % 3 == 0){ //남은 무게에서 3으로 나눠지면 
            result = result + remainder / 3; //3kg 봉지에 넣은만큼 결과에 더해준다.
            break;
        }
        result--; //남은 무게에서 3으로 안나눠지면 담아뒀던 5kg 봉지 하나를 뺀다.
    }
    cout<<result;
}