어쩌다 보니 자율주행 개발하는 사람 이야기

[ROS2] rosbag2에서의 데이터 유실을 개선한 foxy-future 브랜치

우아한 컴공인 — Tue, 10 Jan 2023 20:36:33 +0900

github 링크: https://github.com/ros2/rosbag2/tree/foxy-future

GitHub - ros2/rosbag2

Contribute to ros2/rosbag2 development by creating an account on GitHub.

github.com

ROS2 Foxy에서 rosbag2를 이용하여 데이터를 취득하다 보면,

데이터가 군데군데 빠져있는 것을 볼 수 있다. (보통 "이가 나갔다" 라고 표현하고는 한다.)

이런 이슈를 해결한 버전이 있다고 해서 찾아보게 되었다.

위 깃헙 링크에서 별도의 브랜치로 관리되고 있었는데, foxy-future 브랜치가 바로 그것이다.

몇 가지 성능 개선과 ROS2 Galatic에서 제공하는 몇 가지 기능들을 제공한다고 하는데, 우리는 이가 나가는 것이 가장 큰 문제이므로, 여기에 집중하고자 한다.

해당 repo를 clone 후, checkout을 통해 foxy-future 브랜치로 진입할 수 있다.

mkdir -p ~/rosbag_ws/src
cd ~/rosbag_ws/src

git clone https://github.com/ros2/rosbag2.git

git checkout foxy-future

이후에 해당 브랜치를 빌드하고, 소싱을 통해서 개선된 rosbag2를 적용할 수 있다.

colcon build
. install/setup.bash

참고로 빌드를 진행하며 몇 가지 패키지들이 필요하다는 메세지가 출력되고는 하는데, apt를 사용하여 설치할 수 있다.

이후에 rosbag2를 사용하여 데이터를 취득하기 전에 위에서 빌드한 결과물 소싱을 한 번 해준 뒤에 각자가 사용하는 워크스페이스 소싱을 해주는 방식으로 사용할 수 있다.

아마도 아래와 같이 alias를 지정할 수 있을 것 같다.

alias foxy="source /opt/ros/foxy/setup.bash"
alias sb=". install/setup.bash"
alias future="source ~/rosbag_ws/install/setup.bash"

이렇게 alias 지정을 했다면 아마도 아래와 같이 사용 할 것 같다.

foxy
future
sb
ros2 bag record <topic_name>

[프로그래머스] 두 개 뽑아서 더하기

우아한 컴공인 — Fri, 15 Jan 2021 11:59:53 +0900

두 개 뽑아서 더하기

문제 설명

정수 배열 numbers가 주어집니다. numbers에서 서로 다른 인덱스에 있는 두 개의 수를 뽑아 더해서 만들 수 있는 모든 수를 배열에 오름차순으로 담아 return 하도록 solution 함수를 완성해주세요.

제한사항

numbers의 길이는 2 이상 100 이하입니다.

numbers의 모든 수는 0 이상 100 이하입니다.

입출력 예

numbers	result
[2,1,3,4,1]	[2,3,4,5,6,7]
[5,0,2,7]	[2,5,7,9,12]

소스 코드

#include <string>
#include <vector>

using namespace std;

int i, j;
bool arr[201];
//필요한 변수 선언

vector<int> solution(vector<int> numbers) {
    vector<int> answer; //결과를 담을 변수
    
    for(i = 0; i < numbers.size(); i++){
        for(j = i + 1; j < numbers.size(); j++){
            arr[numbers[i] + numbers[j]] = true;
        }
    }
    //모든 경우의 수를 확인해 합한 값을 새로운 배열에 체크한다
    
    for(i = 0; i < 201; i++){
        if(arr[i] == true)
            answer.push_back(i);
    }
    //체크되어있는 값에 대해 결과 벡터에 하나씩 입력한다
    
    return answer;
}

해설

비교적 간단한 완전 탐색 문제로

주어지는 수가 100개를 넘지 않는다는 점에서 완전 탐색이 가능하고,

각각의 값이 100을 넘지 않는다는 점에서 배열로 두 수의 합을 체크가 가능합니다

나올수 있는 모든 경우의 수 (모든 사람과 악수하는 상황을 생각하면 좋습니다) 에 대한 합을 새로운 배열에 체크합니다

arr[numbers[i] + numbers[j]] = true;

이후에 체크한 배열을 앞에서부터 탐색하며 벡터에 집어넣으면 자연스럽게 오름차순 조건도 만족하게 됩니다

if(arr[i] == true)
  answer.push_back(i);

결과

개발환경

C++@Xcode
macOS 11.0.1 Big Sur

[백준] 1978번 : 소수 찾기 (C++)

우아한 컴공인 — Thu, 31 Dec 2020 07:07:03 +0900

소수 찾기

시간 제한	메모리 제한	제출	정답	맞은 사람	정답 비율
2 초	128 MB	58502	27409	22560	48.239%

문제

주어진 수 N개 중에서 소수가 몇 개인지 찾아서 출력하는 프로그램을 작성하시오.

입력

첫 줄에 수의 개수 N이 주어진다. N은 100이하이다. 다음으로 N개의 수가 주어지는데 수는 1,000 이하의 자연수이다.

출력

주어진 수들 중 소수의 개수를 출력한다.

예제 입력 1

4
1 3 5 7

예제 출력 1

소스코드

#include <iostream>
using namespace std;
int N, M, ans, arr[1001], i, j;
//필요한 변수 선언

int main(){
    arr[1] = 1;
    //1은 소수가 아니므로 미리 체크해둔다
    
    for(i = 2; i <= 500; i++){
        j = 2;
        while(i * j <= 1000){
            arr[i * j] = 1;
            j++;
        }
    }
    //에라토스테네스의 체 원리를 적용시키는 과정
    
    cin >> N;
    while(N--){
        cin >> M;
        if(arr[M] == 0)
            ans++;
    }
    //주어진 입력에 대하여 체크되지 않은 값이면 카운트를 늘린다
    
    cout << ans << '\n';
    //결과 출력
}

해설

주어진 입력에 대해 소수임을 판별하는 문제이다

에라토스테네스의 체 원리를 이용하여 미리 주어진 범위 (이 문제에서는 1000까지 입력 가능하다) 안에서 소수들을 미리 판별해놓은 다음 주어진 입력에 대해 바로바로 소수임을 판별하고 있다

에라토스테네스의 체는 간단하게 설명하자면

예를 들어 2부터 시작할때, 2 x 1를 제외하고 2 x 2, 2 x 3 ... 는 모두 소수가 아니므로 지워나가는 방식이다

이 방식대로 2부터 500 (501 부터는 2 이상을 곱했을때 문제에서 주어진 범위 1000을 넘기 때문에 고려할 필요가 없다)

까지 주어진 수의 범위 1000을 넘지 않는 선에서 수를 지워나가는(이 문제에서는 체크를 하는 방식) 방식으로 진행한다

1부터 1000까지의 모든 수를 체크한 후 입력을 받으며 이 입력이 소수인지 체크 여부를 확인하며 카운트를 한다

채점 결과

개발환경

C++@Xcode
macOS 11.0.1 Big Sur

[백준] 9663번 : N-Queen (C++)

우아한 컴공인 — Tue, 7 Jul 2020 18:51:26 +0900

N-Queen

시간 제한	메모리 제한	제출	정답	맞은 사람	정답 비율
10 초	128 MB	23313	13080	8620	55.735%

문제

N-Queen 문제는 크기가 N × N인 체스판 위에 퀸 N개를 서로 공격할 수 없게 놓는 문제이다.

N이 주어졌을 때, 퀸을 놓는 방법의 수를 구하는 프로그램을 작성하시오.

입력

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

출력

첫째 줄에 퀸 N개를 서로 공격할 수 없게 놓는 경우의 수를 출력한다.

예제 입력 1

예제 출력 1

소스 코드

#include <iostream>
using namespace std;

bool chess[17][17];
int n, ans;
//체스말들의 정보를 기록할 체스판 배열과, 입출력을 위한 변수 선언

bool check(int x, int y){
    bool tmp = true;
    //유효 조건에 걸리지 않는다면 참
    
    for(int i = 1; i < x; i++){
        if(chess[y][i])
            tmp = false;
    }
    //다른 체스말이 같은 행에 있는 경우
    
    for(int i = 1; 1 <= y - i; i++){
        if(chess[y - i][x - i])
            tmp = false;
    }
    //다른 체스말이 좌대각(위쪽) 방향에 있는 경우
    
    for(int i = 1; y + i <= n; i++){
        if(chess[y + i][x - i])
            tmp = false;
    }
    //다른 체스말이 좌대각(아래쪽) 방향에 있는 경우
    
    return tmp;
}
//체스말을 해당 위치에 놓는 것이 유효한지 판단하는 함수

void func(int cur){
    if(cur == n + 1){
        ans++;
        return;
    }
    //체스말을 충분히 놓은 경우 한 세트가 완성되었으므로 결과값 증가
    
    for(int i = 1; i <= n; i++){
        if(check(cur, i)){
            chess[i][cur] = true;
            func(cur + 1);
            //위치가 유효하다면 체스말을 놓고 다음 열 진행
        }
        chess[i][cur] = false;
        //이 위치가 아닌 다른 곳에 체스말을 두는 경우 시작
    }
}
//백트래킹 방식으로 체스말들을 놓는 함수

int main(){
    cin >> n;
    func(1);
    cout << ans << '\n';
    //문제 형식에 맞는 입출력과 백트래킹 함수 진입
}

해설

N-Queen 문제는 꽤나 유명한 백트래킹 연습 문제 중 하나이다

만약 백트래킹 개념에 대해 이해가 부족하다면 먼저 기본 진행 방식 정도는 공부하고 오는 것을 추천한다

이 문제 풀이에서 고려해야할 가장 중요한 정보는 백트래킹 방식으로 체스말을 배치하되,

이전에 배치한 체스말들과 공격 가능한 위치에 놓여있지 않도록 구성하는 것이다

아래에 공격 가능한 위치의 예를 그림으로 표현하였다

♥
	♥
♥	♥	◎
	♥
♥

공격 가능한 위치 : ♥

현재 배치하려는 체스말의 위치 : ◎

위처럼 체스말을 배치하는 경우에 우리는

좌대각(위쪽방향), 가로방향, 좌대각(아래쪽방향) 세가지 방향에서 체스말이 배치되어있는지 확인해야 할 것이다

이쯤 되면 우리는 체스말을 배치하는 과정에서 현재 열 오른쪽에 있는 열에 대해서는 고려할 필요가 없다는 것을 알게된다

bool check(int x, int y){
    bool tmp = true;
    //유효 조건에 걸리지 않는다면 참
    
    for(int i = 1; i < x; i++){
        if(chess[y][i])
            tmp = false;
    }
    //다른 체스말이 같은 행에 있는 경우
    
    for(int i = 1; 1 <= y - i; i++){
        if(chess[y - i][x - i])
            tmp = false;
    }
    //다른 체스말이 좌대각(위쪽) 방향에 있는 경우
    
    for(int i = 1; y + i <= n; i++){
        if(chess[y + i][x - i])
            tmp = false;
    }
    //다른 체스말이 좌대각(아래쪽) 방향에 있는 경우
    
    return tmp;
}
//체스말을 해당 위치에 놓는 것이 유효한지 판단하는 함수

체스말의 유효한 위치를 확인하는 함수만 잘 구성한다면 나머지 부분에 대해서는 전형적인 백트래킹 방식으로 구현할 수 있다

void func(int cur){
    if(cur == n + 1){
        ans++;
        return;
    }
    //체스말을 충분히 놓은 경우 한 세트가 완성되었으므로 결과값 증가
    
    for(int i = 1; i <= n; i++){
        if(check(cur, i)){
            chess[i][cur] = true;
            func(cur + 1);
            //위치가 유효하다면 체스말을 놓고 다음 열 진행
        }
        chess[i][cur] = false;
        //이 위치가 아닌 다른 곳에 체스말을 두는 경우 시작
    }
}
//백트래킹 방식으로 체스말들을 놓는 함수

개발환경

C++@Xcode
macOS 10.15 Catalina

[백준] 5557번 : 1학년 (C++)

우아한 컴공인 — Tue, 19 May 2020 15:49:22 +0900

1학년

시간 제한	메모리 제한	제출	정답	맞은 사람	정답 비율
1 초	128 MB	10140	3723	2853	36.427%

문제

상근이가 1학년 때, 덧셈, 뺄셈을 매우 좋아했다. 상근이는 숫자가 줄 지어있는 것을 보기만 하면, 마지막 두 숫자 사이에 '='을 넣고, 나머지 숫자 사이에는 '+' 또는 '-'를 넣어 등식을 만들며 놀고 있다. 예를 들어, "8 3 2 4 8 7 2 4 0 8 8"에서 등식 "8+3-2-4+8-7-2-4-0+8=8"을 만들 수 있다.

상근이는 올바른 등식을 만들려고 한다. 상근이는 아직 학교에서 음수를 배우지 않았고, 20을 넘는 수는 모른다. 따라서, 왼쪽부터 계산할 때, 중간에 나오는 수가 모두 0 이상 20 이하이어야 한다. 예를 들어, "8+3+2-4-8-7+2+4+0+8=8"은 올바른 등식이지만, 8+3+2-4-8-7이 음수이기 때문에, 상근이가 만들 수 없는 등식이다.

숫자가 주어졌을 때, 상근이가 만들 수 있는 올바른 등식의 수를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 숫자의 개수 N이 주어진다. (3 ≤ N ≤ 100) 둘째 줄에는 0 이상 9 이하의 정수 N개가 공백으로 구분해 주어진다.

출력

첫째 줄에 상근이가 만들 수 있는 올바른 등식의 개수를 출력한다. 이 값은 263-1 이하이다.

예제 입력 1

11
8 3 2 4 8 7 2 4 0 8 8

예제 출력 1

힌트

8+3-2-4+8-7-2-4-0+8=8
8+3-2-4+8-7-2-4+0+8=8
8+3+2+4-8-7+2-4-0+8=8
8+3+2+4-8-7+2-4+0+8=8
8+3+2-4+8-7+2+4-0-8=8
8+3+2-4+8-7+2+4+0-8=8
8-3+2+4-8+7+2+4-0-8=8
8-3+2+4-8+7+2+4+0-8=8
8-3+2-4+8+7+2-4-0-8=8
8-3+2-4+8+7+2-4+0-8=8

소스 코드

#include <iostream>
using namespace std;

long long arr[101], n, dp[100][21];
//문제에서 주어진 데이터를 입력받을 arr, n, 중간 계산 데이터를 저장할 dp 배열 선언

int main(){
    cin >> n;
    for(int i = 1; i <= n; i++){
        cin >> arr[i];
    }
    //문제에서 주어진 데이터들을 입력
    
    dp[1][arr[1]] = 1;
    //dp배열의 초기값 입력
    
    for(int i = 2; i < n; i++){
        //두번째 값부터 n - 1번째 값까지 계산 가능
        
        for(int j = 0; j <= 20; j++){
            //중간 계산이 있었는지 반복문으로 확인
            
            if(dp[i - 1][j] != 0){
                //중간 계산 결과가 존재하는 경우
                
                if(j + arr[i] >= 0 && j + arr[i] <= 20){
                    dp[i][j + arr[i]] += dp[i - 1][j];
                }
                //i번째 값과 덧셈 연산을 했을 때, 조건에 맞는 경우
                
                if(j - arr[i] >= 0 && j - arr[i] <= 20){
                    dp[i][j - arr[i]] += dp[i - 1][j];
                }
                //i번째 값과 뺄셈 연산을 했을 때, 조건에 맞는 경우
                
            }
        }
    }
    cout << dp[n - 1][arr[n]] << '\n';
    //n번째 값과 일치하는 결과값 출력
    
}

해설

범위가 제한되어있는 수들이 주어질 때, 덧셈 또는 뺄셈 연산을 해서 중간 결과 값들을 저장하며 나아가는 방식이다

DP 문제를 풀 때 생각해줘야하는 세가지 중 먼저 DP 배열이 나타내는 정보를 정하도록 한다

DP[ i ][ j ] = i 번째 수까지 연산을 수행했을 때, 그 결과값이 j 가 나오는 경우의 수

if(j + arr[i] >= 0 && j + arr[i] <= 20){
	dp[i][j + arr[i]] += dp[i - 1][j];
}
//i번째 값과 덧셈 연산을 했을 때, 조건에 맞는 경우
                
if(j - arr[i] >= 0 && j - arr[i] <= 20){
	dp[i][j - arr[i]] += dp[i - 1][j];
}
//i번째 값과 뺄셈 연산을 했을 때, 조건에 맞는 경우

따라서 두개의 반복문 중,

첫번째 반복문은 현재 확인하고 있는 위치,

두번째 반복문은 직전 데이터들과 비교했을 때, 조건에 맞는 경우가 있는 확인하는 반복문이다

두개의 반복문을 선언하고 현재 위치한 지점의 값과 이전 데이터를 덧셈하거나 뺄셈했을 때,

조건에 맞는 경우에 값을 수정하도록 한다

for(int i = 2; i < n; i++){
//두번째 값부터 n - 1번째 값까지 계산 가능
        
	for(int j = 0; j <= 20; j++){
	//중간 계산이 있었는지 반복문으로 확인

이 문제는 특히 조건을 잘 읽어보아야 머리가 덜 아픈데,

1. 데이터의 개수는 100개를 넘지 않는다

2. 중간 계산 결과는 0 이상 20 이하이다

3. 나올 수 있는 경우의 수는 2^63 - 1 이하이다

1, 2번 조건으로 DP 배열의 크기를 [ 100 ][ 20 ] 으로 획기적으로 줄일 수 있다

3번 조건을 충족시키기 위해 DP 배열을 long long 형으로 선언해야 한다

long long arr[101], n, dp[100][21];
//문제에서 주어진 데이터를 입력받을 arr, n, 중간 계산 데이터를 저장할 dp 배열 선언

결과값은 N - 1 번째 까지 확인했으므로 N- 1까지 연산한 결과가 N 번째 데이터와 같은 경우만 출력하면 된다

cout << dp[n - 1][arr[n]] << '\n';
//n번째 값과 일치하는 결과값 출력

개발환경

C++@Xcode
macOS 10.15 Catalina

[백준] 11049번 : 행렬 곱셈 순서 (C++)

우아한 컴공인 — Sun, 10 May 2020 06:57:30 +0900

행렬 곱셈 순서

시간 제한	메모리 제한	제출	정답	맞은 사람	정답 비율
1 초	256 MB	9060	4127	2934	43.745%

문제

크기가 N×M인 행렬 A와 M×K인 B를 곱할 때 필요한 곱셈 연산의 수는 총 N×M×K번이다. 행렬 N개를 곱하는데 필요한 곱셈 연산의 수는 행렬을 곱하는 순서에 따라 달라지게 된다.

예를 들어, A의 크기가 5×3이고, B의 크기가 3×2, C의 크기가 2×6인 경우에 행렬의 곱 ABC를 구하는 경우를 생각해보자.

AB를 먼저 곱하고 C를 곱하는 경우 (AB)C에 필요한 곱셈 연산의 수는 5×3×2 + 5×2×6 = 30 + 60 = 90번이다.
BC를 먼저 곱하고 A를 곱하는 경우 A(BC)에 필요한 곱셈 연산의 수는 3×2×6 + 5×3×6 = 36 + 90 = 126번이다.

같은 곱셈이지만, 곱셈을 하는 순서에 따라서 곱셈 연산의 수가 달라진다.

행렬 N개의 크기가 주어졌을 때, 모든 행렬을 곱하는데 필요한 곱셈 연산 횟수의 최솟값을 구하는 프로그램을 작성하시오. 입력으로 주어진 행렬의 순서를 바꾸면 안 된다.

입력

첫째 줄에 행렬의 개수 N(1 ≤ N ≤ 500)이 주어진다.

둘째 줄부터 N개 줄에는 행렬의 크기 r과 c가 주어진다. (1 ≤ r, c ≤ 500)

항상 순서대로 곱셈을 할 수 있는 크기만 입력으로 주어진다.

출력

첫째 줄에 입력으로 주어진 행렬을 곱하는데 필요한 곱셈 연산의 최솟값을 출력한다. 정답은 231-1 보다 작거나 같은 자연수이다. 또한, 최악의 순서로 연산해도 연산 횟수가 231-1보다 작거나 같다.

예제 입력 1

예제 출력 1

소스코드

#include <iostream>
#include <vector>
#define INF 9876543210
//INF를 미리 값을 지정, 문제에서 범위를 제공

using namespace std;
long long n, tmp1, tmp2, dp[501][501];
vector<pair<int, int>> v;
//최소 연산 횟수를 저장할 dp배열, 행렬의 크기를 저장할 pair형태의 벡터 선언

int main(){
    cin >> n;
    for(int i = 0; i < n; i++){
        cin >> tmp1 >> tmp2;
        v.push_back({tmp1, tmp2});
    }
    //문제에서 주어진 값들을 입력
    
    for(int i = 0; i < n; i++){
        for(int j = 0; j < n; j++){
            if(i + 1 == j)
                dp[i][j] = v[i].first * v[i].second * v[j].second;
            else if(i == j)
                dp[i][j] = 0;
            else
                dp[i][j] = INF;
        }
    }
    //이어진 두개의 행렬의 최소 비용은 미리 계산하고 나머지 경우는 i=j인 경우를 제외하고는 모두 INF 처리
    
    for(int i = 2; i < n; i++){
    //탐색하는 범위
    
        for(int j = 0; j + i < n; j++){
        //탐색의 시작점
        
            for(int mid = j; mid < i + j; mid++){
            //주어진 시작점과 범위 내에서 두 부분으로 분리시키는 지점
            
                dp[j][i + j] = min(dp[j][i + j], dp[j][mid] + dp[mid + 1][i + j] + (v[j].first * v[mid].second * v[i + j].second));
                //기존에 저장된 dp값과 나누어진 두 부분의 dp값과 그 두 부분을 합치는 비용을 합친 값과 비교해서 더 작은 값으로 수정
                
            }
        }
    }
    
    cout << dp[0][n - 1] << '\n';
    //완성된 결과값을 출력
}

해설

이 문제는 앞서 포스팅 되었던 11066번 : 파일 합치기 문제와 매우 유사하다

11066번 문제를 먼저 보고 오는 것도 추천한다

문제 풀이에 대해 고민하기 전에, 행렬의 연산에 대해 고민 해볼 필요가 있다

만약 2 x 3 배열과 3 x 7 배열을 곱한다고 했을 때,

연산 횟수는 2 x 3 x 7 이 된다 그리고 곱셈이 끝난 행렬은 2 x 7 행렬이 된다

이 두가지 정보에 집중하여 문제를 풀어나갈 수 있다

먼저 문제를 풀어나가기 위해 DP 배열이 나타내는 정보를 정할 필요가 있다

DP[ i ][ j ] = i 번째 행렬부터 j 번째 행렬까지 최소 연산 횟수로 곱했을 때의 연산 횟수

위와 같이 생각했을 때, 반복문 세개를 사용해

가장 첫번째 반복문에서는 탐색할 영역의 범위(사이즈)

두번째 반복문에서는 탐색할 영역의 시작점

세번째 반복문에서는 탐색할 영역을 두 부분으로 나누는 지점을 정해준다

for(int i = 2; i < n; i++){ //범위
        for(int j = 0; j + i < n; j++){ //시작점
            for(int mid = j; mid < i + j; mid++){ //끊을곳

나눠진 두 부분을 곱셈 연산을 한다고 가정했을때,

두 부분을 각각 만들기 위한 최소 연산 횟수는 이미 DP 배열 안에 저장 되어있을 것이다

(현재 탐색하는 범위보다 더 작은 범위이므로 이전에 계산되었을 것이다)

따라서 두 부분의 DP값과, 그 두 행렬을 곱하는 비용을 계산하면 되는데,

두 행렬을 곱하는 비용은 앞서 배열에 대해 설명한 것을 바탕으로 하면 두 행렬의 사이즈를 추정할 수 있고 그 사이즈를 바탕으로 연산 횟수도 추정할 수 있다

v[j].first * v[mid].second * v[i + j].second
//나눠진 두 부분을 곱셈 연산하는 비용

이런 정보들을 바탕으로 최소 값을 계속 수정해 나가면서 DP 배열을 수정하면 반복문이 종료되면 DP[0][n-1] 에 최소 비용이 입력되어있다

dp[j][i + j] = min(dp[j][i + j], dp[j][mid] + dp[mid + 1][i + j] + (v[j].first * v[mid].second * v[i + j].second));
//DP배열 수정 과정

cout << dp[0][n - 1] << '\n';
//반복문 탈출 후 결과값 출력

개발환경

C++@Xcode
macOS 10.15 Catalina

[백준] 2096번 : 내려가기 (C++)

우아한 컴공인 — Thu, 16 Apr 2020 19:10:58 +0900

내려가기

시간 제한	메모리 제한	제출	정답	맞은 사람	정답 비율
1 초	4 MB	12551	4494	3343	36.083%

문제

N줄에 0 이상 9 이하의 숫자가 세 개씩 적혀 있다. 내려가기 게임을 하고 있는데, 이 게임은 첫 줄에서 시작해서 마지막 줄에서 끝나게 되는 놀이이다.

먼저 처음에 적혀 있는 세 개의 숫자 중에서 하나를 골라서 시작하게 된다. 그리고 다음 줄로 내려가는데, 다음 줄로 내려갈 때에는 다음과 같은 제약 조건이 있다. 바로 아래의 수로 넘어가거나, 아니면 바로 아래의 수와 붙어 있는 수로만 이동할 수 있다는 것이다. 이 제약 조건을 그림으로 나타내어 보면 다음과 같다.

별표는 현재 위치이고, 그 아랫 줄의 파란 동그라미는 원룡이가 다음 줄로 내려갈 수 있는 위치이며, 빨간 가위표는 원룡이가 내려갈 수 없는 위치가 된다. 숫자표가 주어져 있을 때, 얻을 수 있는 최대 점수, 최소 점수를 구하는 프로그램을 작성하시오. 점수는 원룡이가 위치한 곳의 수의 합이다.

입력

첫째 줄에 N(1 ≤ N ≤ 100,000)이 주어진다. 다음 N개의 줄에는 숫자가 세 개씩 주어진다. 숫자는 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 중의 하나가 된다.

출력

첫째 줄에 얻을 수 있는 최대 점수와 최소 점수를 띄어서 출력한다.

예제 입력 1

예제 출력 1

18 6

소스코드

#include <iostream>
#include <algorithm>
using namespace std;
int n, a, b, c, curdp0, curdp1, curdp2, predp0, predp1, predp2, curmindp0, curmindp1, curmindp2, premindp0, premindp1, premindp2;
//슬라이딩 윈도우 방식으로 문제를 풀기위한 이전, 현재 dp값을 입력할 변수들과 현재 위치한 지점에서의 점수들을 입력 받을 변수 생성

int main(){
    cin >> n;
    for(int i = 1; i <= n; i++){
        predp0 = curdp0;
        predp1 = curdp1;
        predp2 = curdp2;
        premindp0 = curmindp0;
        premindp1 = curmindp1;
        premindp2 = curmindp2;
        //최신 dp 값이였던 값들을 새로운 값 입력을 위해 이전 dp값으로 변경
        
        cin >> a >> b >> c;
        //문제에서 주어진 입력 데이터
        
        if(i == 1){
            curdp0 = a;
            curdp1 = b;
            curdp2 = c;
            curmindp0 = a;
            curmindp1 = b;
            curmindp2 = c;
        }
        //i == 1 의 경우 이전 초기값이므로 예외를 두어 값을 입력
        
        else{
            curdp0 = max(predp0, predp1) + a;
            curdp1 = max(predp0, max(predp1, predp2)) + b;
            curdp2 = max(predp1, predp2) + c;
            curmindp0 = min(premindp0, premindp1) + a;
            curmindp1 = min(premindp0, min(premindp1, premindp2)) + b;
            curmindp2 = min(premindp1, premindp2) + c;
        }
        //직전 dp값들과 현재 위치한 지점의 점수가 제공되므로 모두 이용해 현재 위치한 지점의 dp값 계산
        
    }
    cout << max(curdp0, max(curdp1, curdp2)) << " " << min(curmindp0, min(curmindp1, curmindp2)) << '\n';
    //나온 결과들 중 조건에 맞는 가장 크거나 가장 작은 값을 출력
    
}

해설

이 문제를 일반적인 간단한 다이나믹 프로그래밍 문제처럼 접근했다 메모리 초과를 받았다

메모리 제한이 4MB인 것을 감안했을때, 일반적인 방식으로 정수형 DP배열, 정수 또는 문자형으로 배열을 생성해 입력 데이터를 저장하면 메모리 제한으로 인해 오답을 받게 된다

고민하던 중 문제의 알고리즘 분류가 슬라이딩 윈도우인 것을 확인하고 힌트를 얻었다

슬라이딩 윈도우란 보통 컴퓨터 네트워크에서 사용하는 용어로 간단하게 설명하면 현재 계산중인(네트워크에서는 주고 받는 중인 정도로 가정) 값들 근처의 값들과 함께 계속 그 위치를 조정하며 같이 가는 것이라 생각하면 될 듯하다

이 점을 다이나믹 프로그래밍의 관점에서 생각해보면

DP[i][0, 1, 2] = i 번째 위치에서 0, 1, 2 번째 점수를 택했을 때의 가장 최고점 또는 최저점

으로 생각하고 계산된 DP값들이나 문제에서 입력받는 데이터들을 따로 저장할 필요가 없다는 점에 집중하면

결과적으로 배열을 사용할 필요없이 직전에 계산된 DP값과 현재 계산되는 DP값과 현재 입력받은 세종류의 점수까지 총 9개의 변수면 DP값을 계속 계산할 수 있다는 결론에 도달한다

curdp0 = max(predp0, predp1) + a;
curdp1 = max(predp0, max(predp1, predp2)) + b;
curdp2 = max(predp1, predp2) + c;
curmindp0 = min(premindp0, premindp1) + a;
curmindp1 = min(premindp0, min(premindp1, premindp2)) + b;
curmindp2 = min(premindp1, premindp2) + c;
//직전 dp값들과 현재 위치한 지점의 점수가 제공되므로 모두 이용해 현재 위치한 지점의 dp값 계산

개발환경

C++@Xcode
macOS 10.14 Mojave

[백준] 1937번 : 욕심쟁이 판다 (C++)

우아한 컴공인 — Wed, 15 Apr 2020 16:15:04 +0900

욕심쟁이 판다

시간 제한	메모리 제한	제출	정답	맞은 사람	정답 비율
2 초	256 MB	19146	6071	3884	29.792%

문제

n*n의 크기의 대나무 숲이 있다. 욕심쟁이 판다는 어떤 지역에서 대나무를 먹기 시작한다. 그리고 그 곳의 대나무를 다 먹어 치우면 상, 하, 좌, 우 중 한 곳으로 이동을 한다. 그리고 또 그곳에서 대나무를 먹는다. 그런데 단 조건이 있다. 이 판다는 매우 욕심이 많아서 대나무를 먹고 자리를 옮기면 그 옮긴 지역에 그 전 지역보다 대나무가 많이 있어야 한다. 만약에 그런 지점이 없으면 이 판다는 불만을 가지고 단식 투쟁을 하다가 죽게 된다(-_-)

이 판다의 사육사는 이런 판다를 대나무 숲에 풀어 놓아야 하는데, 어떤 지점에 처음에 풀어 놓아야 하고, 어떤 곳으로 이동을 시켜야 둘 다 소중한 생명이지만 판다가 최대한 오래 살 수 있는지 고민에 빠져 있다. 우리의 임무는 이 사육사를 도와주는 것이다. n*n 크기의 대나무 숲이 주어져 있을 때, 이 판다가 최대한 오래 살려면 어떤 경로를 통하여 움직여야 하는지 구하여라.

입력

첫째 줄에 대나무 숲의 크기 n(1 ≤ n ≤ 500)이 주어진다. 그리고 둘째 줄부터 n+1번째 줄까지 대나무 숲의 정보가 주어진다. 대나무 숲의 정보는 공백을 사이로 두고 각 지역의 대나무의 양이 정수 값으로 주어진다. 대나무의 양은 1,000,000보다 작거나 같은 자연수이다.

출력

첫째 줄에는 판다가 최대한 살 수 있는 일수(K)를 출력한다.

예제 입력 1

예제 출력

소스코드

#include <iostream>
#include <algorithm>
using namespace std;
int n, dp[502][502], map[502][502], ans;
//입력 데이터를 받을 변수와 배열 생성, 최대로 생존 가능한 날을 저장할 배열 생성

struct move{
    int y;
    int x;
};
struct move m[4] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
//방향 탐색을 위한 구조체와 배열 생성

int func(int cury, int curx){
    if(dp[cury][curx] != 0)
        return dp[cury][curx];
    //이미 지난적이 있는 지역이면 더 계산할 필요 없이 이전에 이곳에서 계산된 값을 반환
    
    dp[cury][curx] = 1;
    //처음 방문하는 곳이라면 이곳을 시작점이라 생각해 1일 부터 시작
    
    for(int i = 0; i <= 4; i++){
        int my = cury + m[i].y;
        int mx = curx + m[i].x;
        if(my > 0 && my <= n && mx > 0 && mx <= n){
            if(map[my][mx] > map[cury][curx]){
                //4방향을 탐색하는데 주어진 배열의 범위에 속하고 데이터의 크기가 조건에 맞는 경우에만 계산
                
                dp[cury][curx] = max(dp[cury][curx], func(my, mx) + 1);
                //현재 좌표의 이미 있는 dp값과 이동하려는 좌표에서의 dp값에 1을 더한 것 중 큰 값을 dp에 입력
                
            }
        }
    }
    return dp[cury][curx];
    //계산된 현재 좌표의 dp값을 변환
    
}

int main(){
    cin >> n;
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= n; j++){
            cin >> map[i][j];
        }
    }
    //문제에서 주어진 데이터 입력
    
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= n; j++){
            func(i, j);
        }
    }
    //각 좌표에서 탐색 진행
    
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= n; j++){
            if(ans < dp[i][j])
                ans = dp[i][j];
        }
    }
    //가장 큰 dp값을 탐색
    
    cout << ans << '\n';
    //결과값 출력
    
}

해설

DP[i][j] = (i, j)에서 시작해 가장 오래 살 수 있는 기간

일반적인 "모든 좌표를 탐색하며 최대길이를 찾는 방법"으로 문제를 풀어나가면 문제에서 주어진 시간 제한(2초)에 해결되지 않아 시간초과가 발생한다

따라서 방법을 조금 수정해야하는데, 모든 좌표에서 탐색을 실행하되, 탐색하는 과정에서 만약 다음 좌표가 이미 수정된 내역이 있는 경우 이미 다른 경로에서 최대길이를 계산한것으로 간주하고 수정된 DP값을 그대로 가져온다

만약 수정되지 않은 경우, 즉 처음 지나가는 장소인 경우 DP값을 1로 수정하고 탐색을 다시 시작한다

if(dp[cury][curx] != 0)
        return dp[cury][curx];
    //이미 지난적이 있는 지역이면 더 계산할 필요 없이 이전에 이곳에서 계산된 값을 반환
    
    dp[cury][curx] = 1;
    //처음 방문하는 곳이라면 이곳을 시작점이라 생각해 1일 부터 시작

이때 주의해야할 점은, dp[cury][curx]는 4방향으로 이동 가능하므로 최대 4번 값이 수정 가능하므로 가능한 값들 중 가장 최대 값을 dp[cury][curx]에 집어넣어야 할 것이다

따라서 dp값을 수정시에는 아래와 같은 방법으로 진행한다

dp[cury][curx] = max(dp[cury][curx], func(my, mx) + 1);
//현재 좌표의 이미 있는 dp값과 이동하려는 좌표에서의 dp값에 1을 더한 것 중 큰 값을 dp에 입력

개발환경

C++@Xcode
macOS 10.14 Mojave

[백준] 11066번 : 파일 합치기 (C++)

우아한 컴공인 — Tue, 14 Apr 2020 18:21:23 +0900

파일 합치기

시간 제한	메모리 제한	제출	정답	맞은 사람	비율
2 초	256 MB	10738	5684	3634	51.937%

문제

소설가인 김대전은 소설을 여러 장(chapter)으로 나누어 쓰는데, 각 장은 각각 다른 파일에 저장하곤 한다. 소설의 모든 장을 쓰고 나서는 각 장이 쓰여진 파일을 합쳐서 최종적으로 소설의 완성본이 들어있는 한 개의 파일을 만든다. 이 과정에서 두 개의 파일을 합쳐서 하나의 임시파일을 만들고, 이 임시파일이나 원래의 파일을 계속 두 개씩 합쳐서 소설의 여러 장들이 연속이 되도록 파일을 합쳐나가고, 최종적으로는 하나의 파일로 합친다. 두 개의 파일을 합칠 때 필요한 비용(시간 등)이 두 파일 크기의 합이라고 가정할 때, 최종적인 한 개의 파일을 완성하는데 필요한 비용의 총 합을 계산하시오.

예를 들어, C1, C2, C3, C4가 연속적인 네 개의 장을 수록하고 있는 파일이고, 파일 크기가 각각 40, 30, 30, 50 이라고 하자. 이 파일들을 합치는 과정에서, 먼저 C2와 C3를 합쳐서 임시파일 X1을 만든다. 이때 비용 60이 필요하다. 그 다음으로 C1과 X1을 합쳐 임시파일 X2를 만들면 비용 100이 필요하다. 최종적으로 X2와 C4를 합쳐 최종파일을 만들면 비용 150이 필요하다. 따라서, 최종의 한 파일을 만드는데 필요한 비용의 합은 60+100+150=310 이다. 다른 방법으로 파일을 합치면 비용을 줄일 수 있다. 먼저 C1과 C2를 합쳐 임시파일 Y1을 만들고, C3와 C4를 합쳐 임시파일 Y2를 만들고, 최종적으로 Y1과 Y2를 합쳐 최종파일을 만들 수 있다. 이때 필요한 총 비용은 70+80+150=300 이다.

소설의 각 장들이 수록되어 있는 파일의 크기가 주어졌을 때, 이 파일들을 하나의 파일로 합칠 때 필요한 최소비용을 계산하는 프로그램을 작성하시오.

입력

프로그램은 표준 입력에서 입력 데이터를 받는다. 프로그램의 입력은 T개의 테스트 데이터로 이루어져 있는데, T는 입력의 맨 첫 줄에 주어진다.각 테스트 데이터는 두 개의 행으로 주어지는데, 첫 행에는 소설을 구성하는 장의 수를 나타내는 양의 정수 K (3 ≤ K ≤ 500)가 주어진다. 두 번째 행에는 1장부터 K장까지 수록한 파일의 크기를 나타내는 양의 정수 K개가 주어진다. 파일의 크기는 10,000을 초과하지 않는다.

출력

프로그램은 표준 출력에 출력한다. 각 테스트 데이터마다 정확히 한 행에 출력하는데, 모든 장을 합치는데 필요한 최소비용을 출력한다.

예제 입력 1

2
4
40 30 30 50
15
1 21 3 4 5 35 5 4 3 5 98 21 14 17 32

예제 출력 1

300
864

소스 코드

#include <iostream>
#define INF 987654321
//최소값 비교를 위해 아직 접근하지 않은 곳에 입력할 INF 선언

using namespace std;

int li[501], dp[501][501], sum[501], TC, N;
//문제에서 주어진 데이터를 입력받을 li배열, 최소값을 저장할 dp배열, 부분합을 저장할 sum배열 등 선언

int main(){
    cin >> TC;
    //테스트 케이스 입력
    
    while(TC--){
        cin >> N;
        //데이터의 개수 입력
        
        for(int i = 1; i <= N; i++){
            cin >> li[i];
            sum[i] = sum[i -  1] + li[i];
        }
        //데이터를 입력받고 부분합 입력
        
        for(int i = 1; i <= N; i++){
            for(int j = i; j <= N; j++){
                if(i != j){
                    dp[i][j] = INF;
                }
            }
        }
        //dp배열에 최소값 비교를 위한 INF값 입력
        
        for(int i = 1; i < N; i++){
            //탐색할 범위 지정
            
            for(int j = 1; j + i <= N; j++){
                //확인할 범위의 시작값 관련
                
                int k = j + i;
                //확인할 범위의 끝값 관련
                
                for(int mid = j; mid < k; ++mid){
                    dp[j][k] = min(dp[j][k], dp[j][mid] + dp[mid + 1][k] + sum[k] - sum[j - 1]);
                    //dp값을 수정
                }
            }
        }
        cout << dp[1][N] << '\n';
        //결과값 출력
    }
}

해설

이 문제와 같은 경우에는 다이나믹 프로그래밍으로 해결할 수 있었다

DP[i][j] = i ~ j 번째 파일을 모두 합치는데 필요한 비용

위와 같이 생각했을 때, 그 구현방법으로는 먼저 i부터 j 사이에 변수(mid)를 하나 둬 두 부분으로 나누어 준다

이때 DP값은 두 부분을 만들기까지의 각각의 비용

DP[i][mid], DP[mid + 1][j]

두 부분을 합치는데 드는 비용 = i부터 j 까지의 부분 합

Sum[j] - Sum[i - 1]

두가지를 모두 더한 값이 될 것이다

특히 DP값을 두 부분으로 나눈 위치에 따라서 그 값이 계속 변하기 때문에 수정 가능한 DP값 중 가장 작은 값을 입력해주어야 한다

dp[j][k] = min(dp[j][k], dp[j][mid] + dp[mid + 1][k] + sum[k] - sum[j - 1]);
//dp값을 수정

마지막으로 DP값을 수정할 반복문은 매번 1번째 인덱스부터 탐색하되, 마지막 파일의 범위를 계속 늘려가는 식으로 구현해야한다

for(int i = 1; i < N; i++){
            //탐색할 범위 지정
            
            for(int j = 1; j + i <= N; j++){
                //확인할 범위의 시작값 관련
                
                int k = j + i;
                //확인할 범위의 끝값 관련

개발환경

C++@Xcode
macOS 10.14 Mojave

[백준] 1915번 : 가장 큰 정사각형 (C++)

우아한 컴공인 — Mon, 13 Apr 2020 18:24:31 +0900

가장 큰 정사각형

시간 제한	메모리 제한	제출	정답	맞은 사람	비율
2 초	128 MB	17571	5293	3804	28.956%

문제

n×m의 0, 1로 된 배열이 있다. 이 배열에서 1로 된 가장 큰 정사각형의 크기를 구하는 프로그램을 작성하시오

0	1	0	0
0	1	1	1
1	1	1	0
0	0	1	0

위와 같은 예제에서는 가운데의 2×2 배열이 가장 큰 정사각형이다

입력

첫째 줄에 n, m(1 ≤ n, m ≤ 1,000)이 주어진다. 다음 n개의 줄에는 m개의 숫자로 배열이 주어진다

출력

첫째 줄에 가장 큰 정사각형의 넓이를 출력한다

예제 입력 1

예제 출력 1

소스 코드

#include <iostream>
using namespace std;

int n, m, dp[1002][1002], ans;
//배열의 사이즈를 저장할 변수와 정사각형의 크기를 저장할 dp, 최댓값을 저장할 ans 변수 생성
char map[1002][1002];
//문제에서 제시되는 0과 1의 데이터들을 저장할 배열

int main(){
    cin >> n >> m;
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= m; j++){
            cin >> map[i][j];
            if(map[i][j] == '1'){
                dp[i][j] = 1;
            }
        }
    }
    //문제에서 주어진 데이터들을 입력받고 map의 값이 '1'일 경우 1*1 정사각형이므로 dp[i][j]를 1로 변경
    
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= m; j++){
            if(dp[i][j]){
                dp[i][j] = min(dp[i-1][j- 1], min(dp[i-1][j], dp[i][j - 1])) + 1;
                //dp[i][j] 값을 인접한 세가지 값 중, 가장 작은 값 + 1 으로 변경
                
                ans = max(ans, dp[i][j]);
                //결과값 출력을 위한 ans 값 수정
            }
        }
    }
    
    cout << ans * ans << '\n';
    //결과값 출력
}

해설

이 문제가 주어진 데이터에서 가장 큰 정사각형을 찾는다는 점과, 배열 형태에 데이터를 돌면서 값을 수정한다는 점에 초점을 맞춰 생각해보면 배열을 돌며 만들어지는 정사각형의 맨 오른쪽 아래에 도달했을때 이 지점을 기준으로 정사각형이 형성되는지 확인하면 된다고 생각할 수 있다 왜 오른쪽에 아래냐고 묻는다면, 그 이유는 간단하다. 일반적으로 배열을 탐색하는 순서 때문이다

1	1	1	0
1	*1	*1	0
1	*1	*1	1
0	0	1	*1

위와 같은 형태로 데이터가 입력된 경우,

*1 이 입력된 곳은 2 * 2 정사각형이 만들어지는 곳이므로 dp[i][j] = 2 가 되어야한다

*1 이 입력된 곳은 3 * 3 정사각형이 만들어지는 곳이므로 dp[i][j] = 3 이 되어야한다

이러한 규칙으로 데이터가 배열 탐색 순서에 맞춰서 dp값이 수정된다고 가정했을때,

dp[i][j] = dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1] 중 가장 작은 값 + 1 이라고 생각할 수 있다

dp[i][j] = min(dp[i-1][j- 1], min(dp[i-1][j], dp[i][j - 1])) + 1;
//dp[i][j] 값을 인접한 세가지 값 중, 가장 작은 값 + 1 으로 변경

ans = max(ans, dp[i][j]);
//결과값 출력을 위한 값 수정

그 이유는 실제로 계산되는 과정을 보면 알 수 있다

*1 은 당연하게도 앞서 언급된 세가지 값이 모두 2이므로 dp[i][j] = 3 이 되는 것을 볼 수 있다

*1 은 비록 dp[i - 1][j - 1] = 3 이지만, 나머지 두 값이 1이므로 가장 작은 값에 1을 더한 dp[i][j] = 2 가 되는 것을 확인할 수 있다

다이나믹 프로그래밍 문제 관점에 보면 2차원 배열을 사용하는 기본적인 개념의 문제였다

개발환경

C++@Xcode
macOS 10.14 Mojave