본문 바로가기
dev, tech/data structure

greedy knapsack(리눅스->비주얼C)

by 구띵 2007. 5. 17.
질문:고수님들~! 리눅스 gcc c프로그램을 비주얼C에서 돌아갈수있게- 바꿔주세요hyos0326/ 2005-06-16 03:55
 gcc로 컴파일해야하는 코드인데,
비주얼C로 돌릴수있게 바꿔주세요ㅠㅠ




/*  CC = gcc
  LIBS =
  CFLAGS = -ggdb
  TARGET = knapsack
  all: $(TARGET)
  knapsack: knapsack.c
        $(CC) $(CFLAGS) -o knapsack knapsack.c $(LIBS)
  clean: rm -f $(TARGET)
# CFLAGS 에 KNAPSACK01 을 정의하면 0/1 knapsack 으로 실행되고,
#           KNAPSACKGREEDY 을 정의하면 greedy knapsack으로 실행된다.
# ex) CFLAGS = -ggdb KNAPSACK01*/

#include
#include
#include
#include
#include
#include
#include
#include
#define MAXITEM 100
#define MAXWEIGHT 1000
void knapsack01(int *,int *, int, int);
void greedyKnapsack(int *,int *, int, int);
int main(int argc, char **argv)
{
    int i;
    int maxW;
    int items;
    FILE *fp;
/*    clock_t start, end;*/

    int eachProfit[MAXITEM]; // item's profit
    int eachWeight[MAXITEM]; // item's weight

    if(argc != 2) {
        fprintf(stdout,"%s usage: %s inputdata.filen",argv[0], argv[0]);
        exit(0);
    }
    if((fp = fopen(argv[1], "r")) == NULL) {
        printf("fail open file");
        exit(0);
    }
    fscanf(fp, "%d", &items); /* 항목수 */
    fscanf(fp, "%d", &maxW); /* 배낭의 무게 */
    for(i = 0 ; i
    for(i = 0 ; i
    fclose(fp);
#ifdef KNAPSACK01
    // 0/1
    printf("n[0/1]============================================n");
    knapsack01(eachProfit, eachWeight, maxW, items);
/*    printf("%2.3f초n",(((double)end - (double)start)/CLOCKS_PER_SEC)); */
#endif

#ifdef KNAPSACKGREEDY
    // Greedy
    printf("nn[Greedy]========================================n");
    greedyKnapsack(eachProfit, eachWeight, maxW, items);
/*    printf("시간:%2.3f초n",(((double)end -(double)start)/CLOCKS_PER_SEC)); */
#endif
    return 0;
}

/ * 01배낭채우기 동적 계획법  */
void knapsack01(int *p,int *w, int maxW, int items)
{
    int i,j,wk;
    int c[MAXITEM][MAXWEIGHT];
    int item[MAXITEM][MAXWEIGHT];
    int count = 0; // 실행 횟수
    j = 0;

    memset(c,0,sizeof(c));
    memset(item,0,sizeof(item));

    for(i=1;i<= items;i++)
    {
        c[i][0] = 0;

        for(wk = 1 ; wk<= maxW ; wk++)
        {
            count++;

            if(w[i-1]<= wk)
            {
                if(p[i-1] + c[i-1][wk-w[i-1]] > c[i-1][wk])
                {
                    c[i][wk] = p[i-1] + c[i-1][wk-w[i-1]];

                    item[i-1][wk] = 1;
                } else
                    c[i][wk] = c[i-1][wk];

            } else {
                c[i][wk] = c[i-1][wk];
                item[i-1][wk] = 0; // test
            }
        }
    }

    printf("배낭에 들어간 아이템들 n");

    wk = maxW;

    / * 동적계획적인 접근 방법에 의하면,
     *
     *            +- maximum(P[i - 1][w], pi + P[i-1][w - wi]) if wi<= w
     * P[i-1][w] =|
     *            +- P[i-1][w]                                 if wi > w
     *
     * 배낭에 들어간 아이템은 가장 큰 경우이므로,
     * P[n - 1][w] 와 p[i] + P[n - 1][w - wn]를 비교하여 이를 출력한다.   */
    for(i = items ; i >= 1 ; i--)
    {
        if((c[i-1][wk]0)
        {
            wk = wk - w[i-1];
            printf("[무게:=, 이익:=]n",w[i-1], p[i-1]);
        }
    }

    for( i = 0 ; i<= maxW ; i++)
    {
        if(c[items][maxW] == c[items][i])
        {
            printf("n배낭에 들어간 무게 := n",i);
            break;
        }
    }

    printf("이익 : =n",c[items][maxW]);
    printf("n반복 횟수 : %d n",count);
}

/*
 * greedy 배낭채우기
 */
void greedyKnapsack(int *p, int *w, int maxW, int items)
{
    int i,j;
    int tempP, tempW;
    int weight=0, profit=0;
    int cu = maxW;
    int count = 0; // 실행 횟수
    float x[100] = {.0};
    /* 배낭에 들어간 아이템 목록.
     * 0: weight
     * 1: profit     */
    float inputItem[2][MAXITEM];

    /* greedy 알고리즘이므로 무게당 이익 순으로 정렬한다.    */
    for( i = 0 ; i
    {
        for( j = i+1 ; j
        {
            count++;

            if(p[i]/w[i]
            {
                tempP = p[i];
                tempW = w[i];
                p[i]  = p[j];
                w[i]  = w[j];
                p[j]  = tempP;
                w[j]  = tempW;
            }
        }
    }

    /*  배낭에 item을 넣는다.  */
    for( i = 0 ;i
    {
        count++;
        /*  배낭에 최대한 넣을 수 있는 양을 넣게 되면 더 이상
         * 넣을 수 없으므로 배낭에 item을 넣지 않는다.   */
        if(w[i] > cu)
            break;  

        cu = cu - w[i];
        x[i] = 1;

        weight += w[i];
        profit += p[i];

        inputItem[0][i] = w[i]; /* weight */
        inputItem[1][i] = p[i]; /* profit */
    }
    /* greedy 알고리즘은 마지막 남은 공간까지 채워넣어야한다.
     * 그러기 위해서 마지막 item의 무개를 넣을 수 있게 나눠야한다.*/
    if(i<= items){
        x[i] = (float)cu/(float)w[i];
        inputItem[0][i] = p[i];
        inputItem[1][i]= w[i];
    }
    profit += x[i] * p[i];
    weight += x[i] * w[i];

    printf("배낭에 들어간 아이템들 n");
    for(j=0;j<=i;j++)
        printf("[무게:%5.1f 이익:%3.0f] n",inputItem[0][j], inputItem[1][j]);

    printf("n배낭에 들어간 무게:=n",weight);
    printf("이익:=nn",profit);
    printf("항목수:%dn",i);
    printf("마지막항목:%.1fn",x[i]);
    printf("n반복 횟수 : %d n",count);
}
답변:re: 고수님들~! 리눅스 gcc c프로그램을 비주얼C에서 돌아갈수있게- 바꿔주세요naruan/ 2005-06-15 09:35

stdio.h  stdlib.h  string.h 헤더 파일 세개 외에는 사용하는 것이 없어서 지우셔도

 

되구요. 주석처리 부분에 오류가 있어서( /*를 / *라고 적음) 그 부분만 수정해

&...

'dev, tech > data structure' 카테고리의 다른 글

재귀함수  (0) 2007.03.15
하노이의 탑  (0) 2007.03.13

댓글