14-redish03

[Redish03]

🔗 문제 링크

평범한 배낭

✔️ 소요된 시간

2day + a -> 포기..

✨ 수도 코드

❓ 문제 이해

• 물건이 N개 주어지고, 각 물건은 무게 w와 가치 v 를 가진다. 해당 물건을 배낭에 넣으면 V만큼 즐길 수 있다.
• 가방에 무게 제한이 있다. 가방에 최대 K 만큼의 무게만 넣을 수 있다.

❗ 문제 접근 1

일단 재귀부터 생각했다. 완탐에 가까운 느낌인데, 사실 쓰다가 아닌 것 같아서 그만뒀다. 시간 제한도 있고, 로직을 짤 머리가 안됐다. ㅎㅎ

#include <iostream>
#include <vector>

using namespace std;

int N, K;
vector<pair<int, int>> items(100);
int max_enjoy = -987654321;
// int max_enjoy[100];
// first -> 무게 w, second -> 가치 v

void rec(int cur_weight, int idx, int cur_enjoy)
{
    for (int i = idx; i < N; i++)
    {
        // cur_weight구하기
        // 만약 K 보다 크다면 return
        //

        if (cur_weight <= K)
        {
            cur_weight += items[i].first;
            cur_enjoy += items[i].second;
        }
        rec(cur_weight, i, cur_enjoy);
        cur_weight -= items[i].first;
        cur_enjoy -= items[i].second;
    }
}

int main()
{
    cin >> N >> K;

    for (int i = 0; i < N; i++)
    {
        cin >> items[i].first >> items[i].second;
    }

    rec(0, 0, 0);

    cout << max_enjoy;
}

• 사실 재귀 잘만 짜면 가능..할 것 같다. 아닌 걸 알았어서 하다가 그만둔..

❗문제 접근 2

• DP로 어떻게 풀지 고오오민 하다가 결국 포기하고 답지를 봤다. 난...응애 👶 🍼

• 배낭 알고리즘은 DP의 대표적인 유형 중 하나이다.
  

• 일단, 문제를 좀 본질적으로 생각해보자. 가방에는 무게 제한이 있다. 만약 무게 제한을 넘어서면, 어느 아이템도 넣을 수 없게 된다.

• 아무 것도 안 넣었거나, 무게 제한을 넘기지 않고 물건을 넣으면 우리는 두 가지 방법을 선택 할 수 있다.

  • 물건을 가방에 넣는다. 그리고 가방의 무게는 증가한다.
  • 물건을 가방에 넣지 않는다. 가방의 무게는 그대로.

• 그리고 우리가 구해야 할 것은, 가질 수 있는 최대 가치이다. 원래 각 칸마다의 최대 가치를 저장하려고 했는데, 매번 마다 가방에 얼마의 무게가 들어 갈 수 있는지 확인해야 한다.

💻 문제 풀이

• 냅색 알고리즘에서는 2차원 배열을 이용한다. i번째 아이템에 사용 가능한 배낭 무게가 w일 때, 최대 가치max_value를 저장한다.
• 이를 표현하면 다음과 같다.

dp[i][w] = max_value

그럼 dp배열에는, 최대 무게와 아이템 개수만큼 선언하게 된다. 따라서 선언한 dp 배열의 범위는 다음과 같다.

int dp[101][100001];

문제 입력에서는

다음과 같이 주어졌다. 이를 좀 더 보기 쉽게 가로로 눕혀주면 다음과 같다.

	첫 번째 item	두 번째 item	세 번째 item	네 번째 item
무게	6	4	3	5
가치	13	8	6	12

그리고 아까 위에서 나눈 경우에 대해서 생각해 주자.

1. 만약 배낭에 이미 다 찼다면.

• 그럼 우리는 선택지가 없다. 물건을 넣을 수 없다. i 번째 아이템을 확인한다 했을 때, 그럼 이 값은 이전의 값, 즉 이전의 최대 가치와 같다.
• 이는 다음과 같이 나타낼 수 있다.

dp[i][j] = dp[i - 1][j];

2. 만약 배낭에 다 차지 않았다면

• 우리는 두 가지 선택지가 있다.

  • i 번째 아이템을 선택하는 경우 (가방에 넣는 경우)
    • 그럼 사용 가능한 가방의 무게가 줄어든다. 그대신, 가지고 있는 가치는 증가한다.
    • 가방의 무게는 weight만큼 줄여주고, 가치는 dp에 더해주는 것이다
    • 식으로는 다음과 같다.

    •  dp[i - 1][j - weight[i]] + value[i];

  • i 번째 아이템을 선택하지 않는 경우 (가방에 넣지 않는 경우)
    • 이 경우, "배낭이 이미 다 찬 경우"와 같이 생각해 줄 수 있다. 결국 아이템을 선택하지 않은 것이므로, 이 값은 이전의 값, 즉 이전의 최대 가치와 같다. 식은 "배낭이 이미 다 찬 경우"와 같다.

• 우리는 가방이 다 차지 않았다면 가방에 넣거나, 가방에 넣지 않는 경우를 선택해줘야 하기 때문에, 이 문제는 최대 가치를 구하는 것이므로 최댓값을 구해준다.

dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);

위 경우들을 코드로 정리해주면 다음과 같다.

• 이를 각각 모든 경우에 대해 생각한다. 모든 경우는, item의 순서가 i번째 일 때 사용 가능한 가방의 무게가 w라면의 경우이다. 이는 1번째 아이템의 사용가능한 무게가 1kg일 때 부터 가방의 최대 용량인 7kg까지 일 때라고 생각하면 된다.

    for (int i = 1; i <= N; i++)
    {
        for (int j = 1; j <= K; j++)
        {
            if (j >= weight[i])
            {
                dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
            }
            else
            {
                dp[i][j] = dp[i - 1][j];
            }
        }
    }

우리는 마지막 아이템까지 포함해서 사용 가능 배낭 무게가 K일 때 까지 일 때므로, 다음과 같이 출력해준다.

cout << dp[N][K];

전체 코드

#include <iostream>

using namespace std;

int N, K;
int dp[101][100001];
int weight[101];
int value[101];

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

    cin >> N >> K;

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

    for (int i = 1; i <= N; i++)
    {
        for (int j = 1; j <= K; j++)
        {
            if (j >= weight[i])
            {
                dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
            }
            else
            {
                dp[i][j] = dp[i - 1][j];
            }
        }
    }

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

📚 새롭게 알게된 내용

• 배낭 문제 자체를 처음 경험해봤다. 예전 이전 알고리즘 스터디 할 때 우동 호씨가 설명 해줬었는데 다 까먹어 버렸다 코ㅋㅎㅋㅋㅋㅎ
  호우동 KnapSack
• 그는 설명의 신이야,,
• 세 배열을 main 함수에 선언 했더니 메모리가 터졌다.

int dp[101][100001];
int weight[101];
int value[101];

이걸 main안에 넣었더니 input이 안받아지고 꺼져서 많이 당황했다 ㅋㅋㅋ ㅠㅠ 메모리도 관리해야한다..

[9kyo-hwang]

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main()
{
    cin.tie(nullptr)->sync_with_stdio(false);
    
    int N, K; 
    cin >> N >> K;
    
    vector<pair<int, int>> Objects(N);
    for(auto& [Weight, Value] : Objects)
    {
        cin >> Weight >> Value;
    }
    sort(Objects.begin(), Objects.end());
    
    vector<int> MaxValues(K + 1, 0);
    for(const auto&[Weight, Value] : Objects)
    {
        for(int MaxLoad = K; MaxLoad >= 0; --MaxLoad)
        {
            if(Weight > MaxLoad)
            {
                break;
            }
            
            MaxValues[MaxLoad] = max(MaxValues[MaxLoad], MaxValues[MaxLoad - Weight] + Value);
        }
    }
    
    cout << MaxValues[K];

    return 0;
}

정렬을 해준 이유는, 가벼운 무게의 물건부터 검사하기 때문에, 검사할 수록 확인해야 하는 범위가 좁혀지면서 속도 상 이득이 있기 때문입니다.

---

저희 팀원도 이 문제를 풀었어서 동일한 리뷰를 달았었는데, 이렇게 1차원 배열을 이용해 푸는 코드가 있더라구요.

[miniron-v]

1차원 DP로 풀다가 중복 계산에서 막혔는데, 교황 씨 코멘트(를 가장한 PR)를 보고 힌트를 얻어 깼네요.

초기 도전 코드

#include <iostream>
#include <vector>
#include <algorithm>

bool compare(std::pair<int, int> a, std::pair<int, int> b) {
	return a.first < b.first;
}

int main() {
	// 입력
	int n, k;
	std::cin >> n >> k;

	std::vector<std::pair<int, int>> stuff(n);
	for (int i = 0; i < n; ++i) {
		std::cin >> stuff[i].first >> stuff[i].second;
	}

	std::sort(stuff.begin(), stuff.end(), compare);

	// dp
	std::vector<int> max_cost(k + 1, 0);

	for (int i = 1; i <= k; ++i) {
		for (auto& s : stuff) {
			if (i - s.first < 0) {
				break;
			}

			if (max_cost[i - s.first] + s.second > max_cost[i]) {
				max_cost[i] = max_cost[i - s.first] + s.second;
			}
		}
	}

	std::cout << max_cost[k];
}

각 칸에 대해 계산을 실행해, 값을 갱신했습니다. 이랬더니 물건이 무한대인 경우 최대치가 반환됐습니다.

성공 코드

#include <iostream>
#include <vector>
#include <algorithm>

bool compare(std::pair<int, int> a, std::pair<int, int> b) {
	return a.first < b.first;
}

int main() {
	// 입력
	int n, k;
	std::cin >> n >> k;

	std::vector<std::pair<int, int>> stuff(n);
	for (int i = 0; i < n; ++i) {
		std::cin >> stuff[i].first >> stuff[i].second;
	}

	std::sort(stuff.begin(), stuff.end(), compare);

	// dp
	std::vector<int> max_cost(k + 1, 0);

	for (auto& s : stuff) {
		for (int i = k; i >= 1; --i) {
			if (i - s.first < 0) {
				break;
			}

			if (max_cost[i - s.first] + s.second > max_cost[i]) {
				max_cost[i] = max_cost[i - s.first] + s.second;
			}
		}
	}

	std::cout << max_cost[k];
}

for문의 순서를 바꿔, 각 물건에 대해 계산, 뒤쪽 칸부터 채워나갔습니다.
이러면 물건의 개수가 정해진 경우의 최댓값이 반환되더군요.

고찰

왜 그럴까 고찰해봤는데, 먼저 각 물건별로 계산하는 경우, 어떤 물건이 들어가거나 안 들어가거나, 두 가지가 연산됩니다.
들어갈 수 있으면 들어가고, 못 들어가면(혹은 무게는 되는데 가치가 줄어들면) 빠지는 식으로 연산되죠. 그래서 물건 개수에 맞는 최댓값이 반환되었습니다.

반대로 각 칸(무게)별로 계산하는 경우, 각 칸에 물건을 전부 넣어보며 계산이 진행됩니다. 그러다보니 1번 칸에서 무게가 3인 물체가 들어갔어도, 2번 칸에서도 무게가 3인 물체를 검사하죠. 그래서 물건이 무한대일 때 최댓값을 반환합니다.

좀 더 추상화하면 문제 유형 별 접근법으로 정리할 수 있겠네요.

1. 물건이 무한대로 존재하는 경우(중복이 가능한 경우)
   1-1. 각 칸을 기준으로, 모든 물건을 넣어보며 진행
2. 물건이 제한되어 있는 경우(중복이 불가한 경우)
   2-1. 각 물건을 기준으로, 모든 칸에 넣어보며 진행

DP 레벨 업 버섯 낭낭하게 먹고 갑니다~

[bomik0221]

문제 풀이 2일..?! 고생하셨습니다ㅠㅠ
그런데 분명 성우님 PR인데 끝까지 다 읽고나니까 왜 이 페이지에만 PR이 3개인걸까요...? ㅋㅋㅋ
한 pr 안에서 다양한 풀이를 볼 수 있어서 시야를 넓히게 된 것 같은 기분입니다..!

[rivkms]

7팀에서 구경왔습니다 😆

✔️ 확실히 0,1-Knapsack 문제가 2차원 배열을 쓰느냐, 1차원 배열을 쓰느냐는 문제와 스타일에 따라서 많이 갈리긴 하더라고요.

• 저 같은 경우에는 DP 맵 그대로 구현을 하다보니 2차원 배열이 편했고 또 1차원 배열은 관계식을 적을 때 햇깔려했어서 2차원 배열을 선호합니다.
• 반면에 1차원 배열을 선호하시는 분들도 있고 오히려 메모리도 더 적게 차지하기도 한다는 장점이 있긴 하겠죠.

✔️ 제 교수님께서 Knapsack을 강의해주실 때는 2차원 배열로 설명해주셨으나, 1차원 배열로 해도 되냐는 질문에 그 방법도 좋은 방법이라고 답해주시고 설명도 추가로 해주셨습니다. ‼️둘 다 좋은 방법이라는 뜻이겠죠‼️

📝 이 문제에서는 어떤 방법을 사용하든지 상관없지만, 다른 DP문제에서는 문제 조건과 관계식을 어떻게 짜느냐에 따라 특정 방법으로 풀이를 해야하니 둘 다 알아야하더라고요...

• 위에서 두 방법에 대해 자세하게 설명해주셔서 많이 배울 수 있었던 거 같습니다 👍

수고하셨습니다 😁

[miniron-v]

• 저 같은 경우에는 DP 맵 그대로 구현을 하다보니 2차원 배열이 편했고 또 1차원 배열은 관계식을 적을 때 햇깔려했어서 2차원 배열을 선호합니다.
• 반면에 1차원 배열을 선호하시는 분들도 있고 오히려 메모리도 더 적게 차지하기도 한다는 장점이 있긴 하겠죠.

✔️ 제 교수님께서 Knapsack을 강의해주실 때는 2차원 배열로 설명해주셨으나, 1차원 배열로 해도 되냐는 질문에 그 방법도 좋은 방법이라고 답해주시고 설명도 추가로 해주셨습니다. ‼️둘 다 좋은 방법이라는 뜻이겠죠‼️

📝 이 문제에서는 어떤 방법을 사용하든지 상관없지만, 다른 DP문제에서는 문제 조건과 관계식을 어떻게 짜느냐에 따라 특정 방법으로 풀이를 해야하니 둘 다 알아야하더라고요...

확실히 전 1차원 배열로 쓰는 게 더 직관적이어서 1차원 배열을 선호하는데, 민성님 코멘트를 보니 둘 다 다룰 수 있어야겠다고 생ㄱ각이 드네요. 2차원으로 생각하고 구현하는 방법도 해봐야겠습니다!