๐Ÿ’ก Algorithm

[Greedy] Knanspack ์•Œ๊ณ ๋ฆฌ์ฆ˜ - C์–ธ์–ด

jcowwk 2025. 2. 3. 00:36

Knapsack ์•Œ๊ณ ๋ฆฌ์ฆ˜ - C์–ธ์–ด


1. Knapsack ์•Œ๊ณ ๋ฆฌ์ฆ˜

2. ์ฝ”๋“œ ๊ตฌํ˜„

 

์•Œ๊ณ ๋ฆฌ์ฆ˜ ๋ณต์Šตํ•˜๊ธฐ ์œ„ํ•ด ํฌ์ŠคํŒ… ํ•˜๊ณ  ์žˆ์Šต๋‹ˆ๋‹ค.


1. Knapsack ์•Œ๊ณ ๋ฆฌ์ฆ˜

๋ฐฐ๋‚ญ ๋ฌธ์ œ(Knapsack Problem)์€ ์ œํ•œ๋œ ์šฉ๋Ÿ‰์„ ๊ฐ€์ง„ ๊ฐ€๋ฐฉ์— ์—ฌ๋Ÿฌ ๊ฐœ์˜ ๋ฌผ๊ฑด์„ ๋„ฃ์„ ๋•Œ, ๊ฐ€์น˜์˜ ํ•ฉ์ด ์ตœ๋Œ€๊ฐ€ ๋˜๋„๋ก ํ•˜๋Š” ์ตœ์ ํ™” ๋ฌธ์ œ์ž…๋‹ˆ๋‹ค. ๋ฐฐ๋‚ญ ๋ฌธ์ œ์˜ ์ข…๋ฅ˜์—๋Š” 0/1 ๋ฐฐ๋‚ญ ๋ฌธ์ œ(DP)์™€ ๋ถ„ํ•  ๊ฐ€๋Šฅ ๋ฐฐ๋‚ญ ๋ฌธ์ œ(๊ทธ๋ฆฌ๋”” ์•Œ๊ณ ๋ฆฌ์ฆ˜์œผ๋กœ ํ•ด๊ฒฐ ๊ฐ€๋Šฅ)๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค.

 

ํ•ด๋‹น ํฌ์ŠคํŒ…์—์„œ๋Š” ๊ทธ๋ฆฌ๋”” ์•Œ๊ณ ๋ฆฌ์ฆ˜๋ฅผ ๋‹ค๋ค„๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

 

2. ์ฝ”๋“œ ๊ตฌํ˜„

- ์ „์ฒด ์ฝ”๋“œ

#include <stdio.h>
#include <stdlib.h>

typedef struct Bag {
    int value;
    int weight;
    float ratio;
} Bag;

int compare(const void *a, const void *b) {
    Bag *bag1 = (Bag *)a;
    Bag *bag2 = (Bag *)b;
    
    if (bag1->ratio < bag2->ratio) {
        return 1;
    } else if (bag1->ratio > bag2->ratio) {
        return -1;
    }
    return 0;
}

float knapSack(int W, Bag bag[], int n) {
    for (int i = 0; i < n; i++) {
        bag[i].ratio = (float)bag[i].value / bag[i].weight;
    }

    qsort(bag, n, sizeof(Bag), compare);
    
    float totalValue = 0.0;
    int currentWeight = 0;
    
    for (int i = 0; i < n; i++) {
        if (currentWeight + bag[i].weight <= W) {
            currentWeight += bag[i].weight;
            totalValue += bag[i].value;
        } else {
            int remainingWeight = W - currentWeight;
            totalValue += bag[i].value * ((float)remainingWeight / bag[i].weight);
            break;
        }
    }
    
    return totalValue;
}

int main() {
    int val[] = {10, 40, 30, 50};
    int wt[] = {5, 4, 6, 3};
    int W = 10;
    int n = 4;

    Bag bag[n];

    for (int i = 0; i < n; i++) {
        bag[i].value = val[i];
        bag[i].weight = wt[i];
    }

    printf("์ตœ๋Œ€ ๊ฐ€์น˜: %.2f\n", knapSack(W, bag, n));

    return 0;
}

 

- ๊ทธ๋ฆฌ๋”” ํ•ต์‹ฌ ์ฝ”๋“œ ์„ค๋ช…

 

1. bag[i].ratio = (float)bag[i].value / bag[i].weight;

๊ฐ€์น˜/๋ฌด๊ฒŒ ๋น„์œจ์„ ๊ณ„์‚ฐํ•ฉ๋‹ˆ๋‹ค.

 

2. qsort(bag, n, sizeof(Bag), compare);

๋ฌผ๊ฑด์„ ๊ฐ€์น˜/๋ฌด๊ฒŒ ๋น„์œจ ๊ธฐ์ค€์œผ๋กœ ๋‚ด๋ฆผ์ฐจ์ˆœ ์ •๋ ฌํ•ฉ๋‹ˆ๋‹ค.

๋น„์œจ์ด ๋†’์€ ๋ฌผ๊ฑด์„ ๋จผ์ € ๋‹ด๊ณ  ์ด๋ ‡๊ฒŒ ์ •๋ ฌ๋œ ๋ฐฐ์—ด์—์„œ ๋ฌผ๊ฑด์„ ํ•˜๋‚˜ ์”ฉ ์„ ํƒํ•˜๋ฉด์„œ ๋ฐฐ๋‚ญ์— ๋‹ด์„ ์ˆ˜ ์žˆ๋Š”์ง€ ์ฒดํฌํ•ฉ๋‹ˆ๋‹ค.

 

3. if (currentWeight + bag[i].weight <= W)

๋ฐฐ๋‚ญ์ด ํ•ด๋‹น ๋ฌผ๊ฑด์„ ๋‹ด์„ ์ˆ˜ ์žˆ๋Š”์ง€ ํ™•์ธํ•ฉ๋‹ˆ๋‹ค.

๋ฐฐ๋‚ญ์˜ ์ตœ๋Œ€ ํ—ˆ์šฉ ๋ฌด๊ฒŒ๋ฅผ ์ดˆ๊ณผํ•˜์ง€ ์•Š๋Š”๋‹ค๋ฉด ๊ทธ๋Œ€๋กœ ์ถ”๊ฐ€ํ•ฉ๋‹ˆ๋‹ค.

 

4. int remainingWeight = W - currentWeight; totalValue += bag[i].value * ((float)remainingWeight / bag[i].weight);

๋ฐฐ๋‚ญ์— ๋ฌผ๊ฑด์„ ์ „์ฒด์ ์œผ๋กœ ๋‹ด์„ ์ˆ˜ ์—†์„ ๊ฒฝ์šฐ ์ผ๋ถ€๋งŒ ๋‹ด์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

์ด๋•Œ ๋ฐฐ๋‚ญ์˜ ์ตœ๋Œ€ ๋ฌด๊ฒŒ(W)์—์„œ ํ˜„์žฌ ๋ฐฐ๋‚ญ์— ๋‹ด๊ธด ์ด ๋ฌด๊ฒŒ(currentWeight)๋ฅผ ๋นผ์„œ ๋ฐฐ๋‚ญ์— ๋‚จ์•„ ์žˆ๋Š” ๊ณต๊ฐ„์˜ ํฌ๊ธฐ(remainingWeight)๋ฅผ ๊ตฌํ•ฉ๋‹ˆ๋‹ค. ๊ทธ ํ›„ ์ „์ฒด ๋ฌผ๊ฑด์„ ๋‹ค ๋„ฃ์„ ์ˆ˜ ์—†๋‹ค๋ฉด ์ผ๋ถ€๋งŒ ๋„ฃ๊ณ  ๊ทธ์— ๋น„๋ก€ํ•œ ๊ฐ€์น˜๋งŒ ์ถ”๊ฐ€ํ•ฉ๋‹ˆ๋‹ค.

 

๋ฐฐ๋‚ญ์˜ ์ตœ๋Œ€ ๋ฌด๊ฒŒ๊ฐ€ 10kg์ด๊ณ , ํ˜„์žฌ ๋ฐฐ๋‚ญ์— ๋‹ด๊ธด ๋ฌด๊ฒŒ๊ฐ€ 8kg์ธ ์ƒํ™ฉ์œผ๋กœ ๊ฐ€์ •ํ•ฉ๋‹ˆ๋‹ค.

์ด๋•Œ ์ƒˆ๋กœ์šด ์•„์ดํ…œ์˜ ๋ฌด๊ฒŒ๋Š” 5kg, ์•„์ดํ…œ์˜ ๊ฐ€์น˜๋Š” 100์ž…๋‹ˆ๋‹ค.

 

์ด ๊ฒฝ์šฐ์— ๋ฐฐ๋‚ญ์—๋Š” 2kg๊ฐ€ ๋‚จ์•„์žˆ๊ณ , ์•„์ดํ…œ์˜ ๋ฌด๊ฒŒ๋Š” 5kg์ด๊ธฐ ๋•Œ๋ฌธ์— ์ „๋ถ€ ๋„ฃ์„ ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค.

์ด๋•Œ ์•„์ดํ…œ์˜ ์ผ๋ถ€๋งŒ ๋„ฃ๊ณ , ๊ทธ์— ํ•ด๋‹นํ•˜๋Š” ๊ฐ€์น˜๋งŒ ์ถ”๊ฐ€ํ•˜๋ฉด ๋ฉ๋‹ˆ๋‹ค.


๋ฌธ์ œ๊ฐ€ ์žˆ์œผ๋ฉด ๋Œ“๊ธ€ ๋‚จ๊ฒจ์ฃผ์„ธ์š” !

ํ”ผ๋“œ๋ฐฑ์€ ์–ธ์ œ๋‚˜ ํ™˜์˜์ž…๋‹ˆ๋‹ค <3