Smallsoft

백준 - 11054

smallsoft — Thu, 28 Nov 2024 23:21:17 +0900

문제링크

문제요약

특정 수를 기준으로 왼쪽에 위치한 숫자는 증가하고 오른쪽에 위치한 숫자는 감소하는 형태를 띤 부분 수열을 바이토닉 수열이라고 부른다.

문제에서 수열이 주어질때, 가장 긴 바이토닉 수열을 찾는 문제이다.

풀이

LIS를 두번 적용시킴으로써 해결 가능한 문제이다.

바이토닉 수열은 처음에는 증가하다 특정수를 기준으로 감소하는 형태이다.

LIS를 통해 증가하는 수열에 대한 정보를 dp[]에 담는다.

이 배열을 다시 감소하는 수열을 구하는 LIS를 구하면 dp[]에는 증가이후 감소하는 형태의 수열에 대한 길이를 구할 수 있다.

소스코드

#include <iostream>
using namespace std;

/*
증가 또는 감소세의 방향이 일직선이 수열을 바이토닉 수열이라고한다.
바이토닉 수열을 찾으시오
*/

int n, ans;
int arr[1005];
int dp[1005];

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

    cin >> n;
    for (int i = 0; i < n; i++) {
        cin >> arr[i];
        dp[i] = 1;
        for (int j = 0; j < i; j++) {
            if (arr[i] > arr[j]) {
                dp[i] = max(dp[i], dp[j] + 1);
            }
        }
    }
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < i; j++) {
            if (arr[i] < arr[j]) {
                dp[i] = max(dp[i], dp[j] + 1);
            }
        }
        ans = max(ans, dp[i]);
    }
    cout << ans;
}

백준 - 2631

smallsoft — Wed, 27 Nov 2024 21:24:33 +0900

문제링크

문제요약

n개의 수열(아이들)이 정렬되어있지않은 상태이다.

이 수열을 정렬하기위해서 수를 옮겨야하는데 이때 최소한으로 옮기는 수를 출력하는 문제이다.

풀이

3개의 수열을 여러가지 형태로 가정해보겠다.
[1, 2, 3] 이 수열은 0번 움직이면 정렬된다.
[1, 3, 2] 이 수열은 3을 뒤로 보내서 1번에 정렬된다.
[3, 2, 1] 이 수열은 총 2번을 움직여야 정렬된다.

이 규칙을보면 LIS를 구하는것과 연관이 있어 보인다.
[1, 2, 3]은 최장 증가 부분 수열이 [1, 2, 3]이고,
[1, 3, 2]은 [1, 2]가 나온다.
[3, 2, 1]은 [1] 하나만 나오게된다.

풀이를 정리하면

위치를 옮기지 않아도 되는 아이들은 이미 오른차순을 만족하는 부분 수열이다.
이 중 가장 긴 오름차순 부분 수열을 찾고, 이를 제외한 나머지 아이들을 옮겨야한다.

소스코드

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

int n;
int board[1005];
int dp[1005];
int ans;

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

    cin >> n;
    for (int i = 0; i < n; i++) {
        cin >> board[i];
        dp[i] = 1;
        for (int j = 0; j < i; j++) {
            if (board[i] > board[j])
                dp[i] = max(dp[i], dp[j] + 1);
        }
        ans = max(ans, dp[i]);
    }
    cout << n - ans;
}

백준 - 1965

smallsoft — Tue, 26 Nov 2024 22:38:19 +0900

문제링크

문제요약

이 문제는 최장 증가 부분 수열 알고리즘에 관한 문제이다.
해당 알고리즘의 대표적인 예시이기 때문에 따로 이 문제를 못풀겠다면 해당 알고리즘을 공부해야한다.

소스코드

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

int n;
int board[1005];
int dp[1005];
int ans;

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

    cin >> n;
    for (int i = 0; i < n; i++) {
        cin >> board[i];
        dp[i] = 1;
        for (int j = 0; j < i; j++) {
            if (board[i] > board[j])
                dp[i] = max(dp[i], dp[j] + 1);
        }
        ans = max(ans, dp[i]);
    }
    cout << ans;
}

백준 - 9461

smallsoft — Mon, 25 Nov 2024 21:59:06 +0900

문제링크

문제요약

나선형 모양으로 삼각형이 계속해서 추가될때, n번째 삼각형의 변의 길이를 구하는 문제이다.

풀이

나선형모양의 삼각형이 계속 추가된다해서 어렵게 생각할 필요없다.

문제에서 P(10)의 예시를 주어지는데 이 수열이 어떻게 증가하는지 찾고 DP로 해결 하면되는 문제이다.

삼각형의 변의 길이는 1, 1, 1, 2, 2, 3, 4, 5, 7, 9씩 증가한다.

증가하는걸 자세히보면 n번째는 (n - 2) + (n - 3) 만큼 증가한다는걸 알 수 있다.

처음 P(4)까지의 값을 세팅하고 이를 통해 P(100)까지 값을 구한뒤 P(n)을 출력해주면된다.

소스코드

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

long long dp[105];
int n;

int main() {
    cin >> n;

    dp[0] = 1;
    dp[1] = 1;
    dp[2] = 1;
    dp[3] = 2;
    dp[4] = 2;
    for (int i = 5; i < 100; i++) {
        dp[i] = dp[i - 2] + dp[i - 3];
    }
    for (int i = 0; i < n; i++) {
        int tmp;
        cin >> tmp;
        cout << dp[tmp - 1] << '\n';
    }
}

프로그래머스 - 전력망을 둘로 나누기

smallsoft — Wed, 20 Nov 2024 23:53:00 +0900

문제링크

문제요약

n개(2<= n <= 100)의 노드가 트리형태로 연결되어있다.

이 트리를 둘로 나누었을때 두개의 트리가 가지고있는 노드의 수를 최대한 비슷하게 짤랐을 때, 두 트리의 노드 수 차이를 출력하면된다.

풀이

처음에는 규칙성을 찾아보려했지만, 트리의 특별한 형태가 정해져있지않아 규칙을 찾기가 쉽지않았다.

결국 완전탐색을통해 wires를 하나씩 제거해가며 노드의 수를 계산해주었다.

노드의 수를 계산하는건 dfs로 계산하였다.

소스코드

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

vector<int> v[105];
bool vist[105];

int recursion(int cur) {
    int count = 1;
    vist[cur] = 1;
    for (const auto &e : v[cur]) {
        if (vist[e]) continue;
        count += recursion(e);
    }
    return count;
}

int solution(int n, vector<vector<int>> wires) {
    int answer = n;
    for (const auto &e : wires) {
        v[e[0]].push_back(e[1]);
        v[e[1]].push_back(e[0]);
    }

    for (const auto &e : wires) {
        v[e[0]].erase(remove(v[e[0]].begin(), v[e[0]].end(), e[1]), v[e[0]].end());
        v[e[1]].erase(remove(v[e[1]].begin(), v[e[1]].end(), e[0]), v[e[1]].end());
        fill(vist, vist + 105, 0);
        vist[1] = 1;
        int tmp_size = recursion(1);
        answer = min(answer, abs(tmp_size - (n - tmp_size)));
        v[e[0]].push_back(e[1]);
        v[e[1]].push_back(e[0]);
    }
    return answer;
}

프로그래머스 - 소수찾기

smallsoft — Tue, 19 Nov 2024 22:55:03 +0900

문제링크

문제요약

숫자로 이루어진 문자열 number가 주어진다.

주어진 숫자 문자열로 만들 수 있는 모든 순열 조합에서 소수를 찾아 그 개수를 반환하면된다.

제약조건

number의 길이는 1이상 7이하이다.
number는 0부터 9까지의 숫자로 구성되어있다.

풀이

에라토스테네스의 체 알고리즘을 이용해서 1e8까지의 소수를 구한뒤,

number를 dfs로 완전탐색을 돌리며 소수가 몇개인지 구하면된다.

소스코드

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

bool arr[10000000];
int ans;
bool vist[10];

void primenum() {

    arr[0] = false;
    arr[1] = false;
    for (int i = 2; i < 10000000; ++i)
    {
        if (arr[i])
        {
            for (int j = i * 2; j < 10000000; j += i)
            {
                arr[j] = false;
            }
        }
    }
}

void recursion(string num, string nub) {
    if (arr[stoi(nub)]) {
        ans++;
        arr[stoi(nub)] = false;
    }
    for (int i = 0; i < num.size(); i++) {
        if (vist[i]) continue;
        vist[i] = true;
        recursion(num, nub + num[i]);
        vist[i] = false;
    }
}

int solution(string numbers) {
    fill(arr, arr + 10000000, 1);
    primenum();
    recursion(numbers, "0");
    return ans;
}

Krampoline 사용기(2)

smallsoft — Mon, 18 Nov 2024 11:13:15 +0900

*카카오테크 부트캠프 1기로 교육과정중 경험했던 크램폴린에 대한 글입니다.

쿠버네티스 환경을 처음 공부해보고 이를 크램폴린에 적용하면서 겪은 여러 문제들을 두서없이 적은 글이다. 여러 문제들이 있었지만 결국 원하는 방향으로 테스트 서버를 구축하였다. 나중에 누군가 도움이 되었으면해서 글을 남긴다.

1. 배포는 어떻게?

크램폴린 공식 사용 설명서
처음 쿠버네티스 환경을 접하면서 어떻게 사용해야되는지 몰라서 꽤나 해맸다.

다행히 공식 가이드에서 풀스택 배포 설명 및 실습을 위한 레포도 준비되어있었다. 나 같은 경우는 카테부에서 지급해준 쿠버네티스 책과 크램폴린을 실습하며 공부하였다.

그래서 최소한의 배포를 위해서 무엇이 필요하냐 물을 수 있다. 아래 체크리스트로 정리해보았다.

소스코드와 Dockerfile
쿠버네티스의 동작을 정의해줄 k8s 디렉토리 및 그 안의 매니페스트파일들
- 매니페스트 파일엔 Ingress 리소스를 꼭 정의해야줘야한다. 이는 외부 통신을 위해서이다, 이걸 정의안하면 크램폴린 터미널 안에서만 접속해야한다.

동작순서

Dockerfile로 소스코드를 Docker 이미지를 만들어 D2hub에 업로드한다.
Kargo를 생성한다. kargo가 생성될때 k8s안에 있는 yaml파일들을 검사한다.
배포버튼을 누르면 바로 배포된다!

이 내용은 공식 가이드의 실습에 적혀있으니 가이드를 천천히 읽어보는걸 추천한다.

아래 내용 부터는 실제로 배포했던 내 테스트 서버에 대한 설명들이다.

2. 테스트 서버 구축하기

*이 파트를 읽기 전 참고할 글과 git저장소입니다.

우리 팀같은 경우는 Ai서버를 단독으로 AWS에 배포되었기에 크램폴린에서는 배포되지 않았다.

아래는 테스트 서버를 위해 만든 레포들이다.

  개인 레포
  └─ k8s
      ├─ backend.yaml         
      ├─ frontend.yaml          
      ├─ ingress.yaml           
      ├─ kustomization.yaml   
      └─ mysql.yaml

  Frontend Repo
  ├─ Dockerfile
  ├─ Source
  └─ ...

  Backend Repow
  ├─ Dockerfile
  ├─ Source
  └─ ...

크램폴린 공식 설명서에 나와있는 풀스택 배포 가이드를 바탕으로 만들었다.

차이점이 있다면 풀스택배포 가이드에서는 Nginx컨테이너를 통해 라우팅하지만, 내가 구성한 환경은 Ingress controller 통해 라우팅한다.

2-0. 크램폴린 IDE 사용 팁

크램폴린에서 kubectl사용을 사용할때 기본 네임스페이스가 <사용자ID>-namespace 로 설정되어있다.

배포시 파드들은 Default에 생성되니 네임스페이스를 default로 옮겨 놓으면 편하다.

# 현재 네임스페이스 확인
kubectl config view --minify | grep namespace

# 기본 네임스페이스를 default로 변경
kubectl config set-context --current --namespace=default

2-1. 환경변수

프론트엔드, 백엔드 서버에서 사용할 설정파일의 값들을 위해 쿠버네티스 configmap 리소스를 사용하였다.

Backend.yaml

환경변수 사용을 위해 각 파트 개발자와 협력하여 중요한 토큰값, DB정보들을 환경변수를 통해 쓰게끔 코드를 부탁하였다.

크램폴린 IDE에서 configmap 출력

크램폴린 ide를 통해 환경변수를 생성하는 방법은 다음과 같다.

kubeclt create configmap <이름> --from-literal=<key>=value>

아래는 --from으로 생성가능한 옵션들이다.

--from-env-file: 환경 변수 형식의 파일에서 데이터를 읽음.
--from-file: 파일 또는 특정 키-파일 경로를 지정.
--from-literal: 직접 key-value 값을 지정.

나같은 경우는 env 파일을 각 파트 개발자에게 받은뒤 이 파일을 크램폴린 IDE 복사한뒤 --from-env-file옵션을 사용해 configmap을 생성했다.

2-2. 외부인터넷 연결

크램폴린 내부에서 작동하고있는 컨테이너가 외부 인터넷과 연결이 필요한 경우가 있다. (우리 프로젝트의 경우는 Github서버에 연결이 필요했다.)

외부 인터넷과 연결을위해 크램폴린은 프록시주소를 제공해준다.

이는 NAT게이트웨이와는 다르기때문에 어플리케이션에 프록시를한다고 정의해줘야한다.

우리팀의 백엔드코드에서는 다음과같이 프록시를 설정해주었다.

@Configuration
public class RestTemplateConfig {

    @Bean
    @Profile({"dev", "prod"})
    public RestTemplate restTemplateWithProxy() {
        SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();

        Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress("krmp-proxy.9rum.cc", 3128));
        factory.setProxy(proxy);

        return new RestTemplate(factory);
    }

프로그래머스 - 카펫

smallsoft — Sun, 17 Nov 2024 23:09:59 +0900

문제해결

문제요약

갈색 타일은 카펫의 외곽 부분을 차지하고, 노란색 타일은 내부를 자치한다.
노란색 타일과 갈색 타일이 주어질때 가로와 세로의 길이를 반환하는 문제이다.

풀이

얻을 수 있는 정보를 종합해서 어떻게 풀어야할지 계획을 세워야했던 문제였다.

노란타일 + 갈색타입 = width * height
문제의 조건에 따라 width >= height 이다.
중앙에는 노란타일이 있으니, (width - 2) * (height - 2) = yellow

위 3가지 정보를 바탕으로 height를 통해 width를 얻고, height를 늘려가면서 조건에 만족하는 가로, 세로를 찾으면된다.

소스코드

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

/*
중앙에 위치해야하는 노랑
외곽에 위치해야하는 갈색

노랑과 갈색 수를 주어주면 가로 세로를 출력

- - - - - - 14,4   6, 3
- * * * * -
- - - - - -

- - - - 12,4  4, 4
- * * -
- * * -
- - - -

14 + 4 = 6 * 3
12 + 4 = 4 * 4

height 를 통해 width
height <= width
*/

vector<int> solution(int brown, int yellow) {
    vector<int> answer;
    for (int height = 3; height * height <= (brown + yellow); height++) {
        if ((brown + yellow) % height != 0) continue;
        int width = (brown + yellow) / height;
        if ((height - 2) * (width - 2) == yellow) {
            answer.push_back(width);
            answer.push_back(height);
            break;
        }
    }
    return answer;
}

프로그래머스 - 모의고사

smallsoft — Sat, 16 Nov 2024 17:16:39 +0900

문제링크

문제요약

수포자 1,2,3 은 다음과 같은 패턴을 반복한다.

수포자 1 = [1, 2, 3, 4, 5 ...]
수포자 2 = ['2, 1' , '2, 3' , '2, 4' , '2, 5' , ...]
수포자 3 = [3, 3, 1, 1, 2, 2, 4, 4, 5, 5 ...

정답배열 answers 가 주어졌을때 수포자 1, 2, 3 중 가장 점수가 높은 사람을 리턴하면된다.

풀이

딱히 풀이라고 할것도 없이 완전탐색을 돌리면된다.

answers를 0부터 answers.length()까지 돌리면서 수포자의 점수를 체크하면된다.

소스코드

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

/*
1번 - 12345 ...
2번 - 21 22 23 24 25 ...
3번 - 33 11 22 44 55 ...
*/

int a1[10] = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5};
int a2[10] = {2, 1, 2, 3, 2, 4, 2, 5};
int a3[10] = {3, 3, 1, 1, 2, 2, 4, 4, 5, 5};

vector<int> solution(vector<int> answers) {
    vector<int> answer;
    int cnt1 = 0, cnt2 = 0, cnt3 = 0;
    for (int i = 0; i < answers.size(); i++) {
        if (a1[i % 10] == answers[i])
            cnt1++;
        if (a2[i % 8] == answers[i])
            cnt2++;
        if (a3[i % 10] == answers[i])
            cnt3++;
    }
    if (cnt1 >= cnt2 && cnt1 >= cnt3)
        answer.push_back(1);
    if (cnt2 >= cnt1 && cnt2 >= cnt3)
        answer.push_back(2);
    if (cnt3 >= cnt1 && cnt3 >= cnt2)
        answer.push_back(3);
    return answer;
}

백준 - 1374

smallsoft — Fri, 15 Nov 2024 23:13:11 +0900

문제링크
비슷하지만 조금 더 쉬운 문제

문제요약

강의실을 사용해야하는 강의 n에 대해 시작시간과 끝나는 시간을 입력으로 준다.

문제에서는 강의 번호에 대한 정보가 주어지지만 이 입력은 쓸모없는 정보이기에 안써도된다.

강의 n개가 입력으로 들어왔을때 필요한 최소 강의실의 수를 출력하면된다.

풀이

겹치는 강의들이 최소한의 강의실로 배치될 수 있도록 효율적으로 관리해야한다.

효율적으로 관리하기위해서 시작시간을 기준으로 정렬한뒤 종료시간에 대한 정보를 자료구조에 넣고 이를 관리해서 강의실 재사용이 가능한지 판단하면 된다.

자료구조에따른 시간복잡도

처음에는 종료시간에 대한 정보를 vector에 넣고 이 백터를 처음부터 끝까지 봤는데 이건 시간복잡도가 꽤 길게나온다.

종료시간중에 가장 먼저 끝나는 종료시간만 알면되는 부분이기에 이부분을 우선순위큐로 바꿔서 시간복잡도를 낮추었다.

시간이 긴게 백터, 짧은게 우선순위 큐를 사용한 코드이다.

소스코드

vector사용

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

int n;
vector<pair<int, int> > v;
vector<int> ans;

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

    cin >> n;
    for (int i = 0; i < n; i++) {
        int tmp, tmp1;
        cin >> tmp >> tmp >> tmp1;
        v.push_back({tmp, tmp1});
    }
    sort(v.begin(), v.end(), [](pair<int, int> &a, pair<int, int> &b) {
        if (a.first == b.first)
            return a.second < b.second;
        return a.first < b.first;
    });

    ans.push_back(0);
    bool flag = 0;
    for (const auto &e : v) {
        flag = 0;
        for (int i = 0; i < ans.size(); i++) {
            if (e.first >= ans[i]) {
                ans[i] = e.second;
                flag = 1;
                break;
            }
        }
        if (!flag)
            ans.push_back(e.second);
    }
    cout << ans.size();
}

우선순위 큐 사용

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

int n;
vector<pair<int, int> > v;
vector<int> ans;
priority_queue<int, vector<int>, greater<int> > pq;

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

    cin >> n;
    for (int i = 0; i < n; i++) {
        int tmp, tmp1;
        cin >> tmp >> tmp >> tmp1;
        v.push_back({tmp, tmp1});
    }
    sort(v.begin(), v.end(), [](pair<int, int> &a, pair<int, int> &b) {
        if (a.first == b.first)
            return a.second < b.second;
        return a.first < b.first;
    });

    pq.push(v[0].second);
    for (int i = 1; i < n; i++) {
        if (v[i].first >= pq.top())
            pq.pop();
        pq.push(v[i].second);
    }
    cout << pq.size();
}