database.sarang.net
UserID
Passwd
Database
DBMS
MySQL
PostgreSQL
Firebird
ㆍOracle
Informix
Sybase
MS-SQL
DB2
Cache
CUBRID
LDAP
ALTIBASE
Tibero
DB 문서들
스터디
Community
공지사항
자유게시판
구인|구직
DSN 갤러리
도움주신분들
Admin
운영게시판
최근게시물
Oracle Q&A 40747 게시물 읽기
No. 40747
체적쿼리 질문입니다.
작성자
초보자
작성일
2015-03-18 17:08
조회수
9,545

안녕하세요

박스체적 쿼리를 작성하는데 해결이 안되 도움을 얻고자 합니다.

 

박스에 상품을 담는데 박스부피를 넘을 경우 새로운 박스에 담을수 있도록

데이터를 만들어야 합니다.

 

예를들어

 

박스부피 500

 

상품 수량 부피 부피합계

A 2 200 400

B 5 100 500

 

데이터가 있습니다.

 

이 데이터를

 

상품 수량 부피 부피합계 박스번호

A 2 200 400 1

B 1 100 100 1

B 4 100 400 2

 

이런식으로 만들려고 하는데 아무리 해도 잘 되질 않네요....

방법이 있을까요?

이 글에 대한 댓글이 총 11건 있습니다.

-- mssql 로 작성되었습니다...

-- 쿼리가 좀 복잡합니다 -_-;;; 실력이 부족해서리..

-- 데이터는 테스트한다고 일부 변경해두었습니다.

 

--쿼리 시작

With detail As
(
     Select 'A'  As 상품, 2 As 수량, 200 As 부피, 400  As 부피합계 ,1 As 박스종류 Union All
     Select 'B'  As 상품, 10 As 수량, 100 As 부피, 1000  As 부피합계 ,1 As 박스종류
)
,box_detail As
(
     Select  1    As 박스종류,  400 As 부피 Union All
     Select  2    As 박스종류,  500 As 부피
)
,data As
(
     Select
            a.상품
           ,a.수량
           ,a.부피
           ,(
               Case When a.부피합계 - b.부피 = 0
                       Then 0
                    Else
                       Round ( a.부피합계 / b.부피 , 0 )
               End
            )   As row
           ,seq = 1
           ,a.부피합계
           ,b.부피 As 박스부피
           ,초과부피 = a.부피합계 - b.부피
           ,초과수량 = Round( ( a.부피합계 - b.부피 ) / a.부피,0)
           ,박스당적용수량 = Round ( b.부피/a.부피 , 0)
       From detail As a
                        Inner Join
                                   box_detail As b
                                                   On a.박스종류 = b.박스종류
                                                  
  Union All                                                 

     Select
            a.상품
           ,a.수량
           ,a.부피
           ,a.row   As row
           ,seq = seq + 1
           ,a.부피합계
           ,a.박스부피
           ,a.초과부피
           ,a.초과수량
           ,a.박스당적용수량
       From data As a
      Where seq <= a.row
        And a.row <> 0
)
  Select
         a.상품
        ,(
            Case When a.row = 0
                    Then a.수량
                 Else
                    (
                        Case When a.seq = (
                                             Select MAX(b.seq)
                                               From data As b
                                              Where b.상품 = a.상품
                                          )
                                Then a.수량 - ( a.박스당적용수량 * row )
                             Else a.박스당적용수량
                        End
                    )
            End
         )     As 수량
        ,a.부피
        ,(
            Case When a.row = 0
                    Then a.수량
                 Else
                    (
                        Case When a.seq = (
                                             Select MAX(b.seq)
                                               From data As b
                                              Where b.상품 = a.상품
                                          )
                                Then a.수량 - ( a.박스당적용수량 * row )
                             Else a.박스당적용수량
                        End
                    )
            End
         ) * a.부피    As 부피합계
        ,a.seq
        ,a.박스부피       
    From data As a

--쿼리 끝

 

--결과

 

|------|----|------|--------|---|---------|
| 상품 |수량| 부피 |부피합계|seq|박스부피 |
|------|----|------|--------|---|---------|
|  A   | 2  | 200  | 400    |1  | 400     |
|  B   | 4  | 100  | 400    |1  | 400     |
|  B   | 4  | 100  | 400    |2  | 400     |
|  B   | 2  | 100  | 200    |3  | 400     |
|------|----|------|--------|---|---------|
 

최한영(terry0515)님이 2015-03-18 19:52에 작성한 댓글입니다.

답변감사합니다 .

그런데 문제가 박스 부피가 500 일경우

A 상품 2개(400)  만큼 이 1번 박스에 들어가고

남은박스 공간(100) 에 B 상품 1개(100) 들거 가야 합니다.

이경우 어찌 해야 하는지.... 머리 아프네요

그래도 답변 해주신 쿼리로 많은 진전이 있었습니다

감사합니다.

초보자님이 2015-03-18 21:06에 작성한 댓글입니다. Edit

 요건이 불분명합니다.(위의 예제는 우연히 딱 맞아 떨어지는 케이스라서 알 수가 없네요...)

 

위와 같은 문제는 일반적으로 알고리즘에서 다항시간안에 풀수 없는 문제로 알려져 있는 채우기 문제에 대한 질문인 것 처럼 보이는데요...

 

즉... 

일반적인 SQL로 해결할 방법이 없다는....

(예를 들어 박스 부피가 500이고 단위 부피가 300,200 인 물품이 각각 5개씩이면 박스가 5개 필요하겠죠?

왜냐면 딱 맞아떨어지니까...

그런데 이런건 간단해도

만약 박스가 500인데 부피가 171이 4개,223이 6개,63이4개,43이5개,... 이런 식이면 어떻게 넣어야 할지 감이 잡히시나요?

)

이 문제는 효율적인 짐싸기 문제라고 해서 알고리즘에서 유명한 문제들 중 하나입니다.

만약 이 문제를 SQL로 해결한다면 엄청 대단한 성과라는....

 

인테넷에서 

 bin packing problem 으로 검색해보면 공개되어 있는 소프트웨어도 있는 것 같네요...

김흥수(protokhs)님이 2015-03-19 01:47에 작성한 댓글입니다.
이 댓글은 2015-03-19 02:12에 마지막으로 수정되었습니다.

with t (prod,cnt,vol,volsum)
      as( select 'A', 2, 200, 400 from dual
union all select 'B', 5, 100, 700 from dual
)
, b(boxvol) as(select 500 from dual)
select box,prod,sum(cnt),max(vol),sum(vol)
from(
select * from(
select column_value rn,t.prod,1 cnt, vol, boxvol
from t,table(select collect(level) from dual connect by level <= t.cnt), b
)
model
dimension by(rownum rn)
measures(prod,cnt,vol,boxvol,0 sum, 0 put, 0 box)
RULES
(
      sum[any] = case when vol[cv()] + nvl(sum[cv()-1],0) > boxvol[cv()] then vol[cv()] + nvl(sum[cv()-1],0) - boxvol[cv()] else vol[cv()] + nvl(sum[cv()-1],0)  end 
    , put[any] = vol[cv()] + sum[cv()]
    , put[any] = case when sum[cv()] <= boxvol[cv()] then vol[cv()] else 0 end
    , box[any] = case when vol[cv()] + nvl(sum[cv()-1],0) > boxvol[cv()] then box[cv()-1] + 1 else nvl(box[cv()-1],1) end 
)
)
group by box,prod
order by box,prod
 

잘 응용해 보세요

최성준(junkk)님이 2015-03-20 15:35에 작성한 댓글입니다.

 최성준님 쿼리는

200 짜리 2개
300 짜리 2개인 경우를 대입하면
 
with t (prod,cnt,vol,volsum) as
          select 'A', 2, 200, 400 from dual 
union all select 'B', 2, 300, 600 from dual
)
, b(boxvol) as(select 500 from dual)
select box,prod,sum(cnt),max(vol),sum(vol)
from(
select * from(
select column_value rn,t.prod,1 cnt, vol, boxvol
from t,table(select collect(level) from dual connect by level <= t.cnt), b
)
model
dimension by(rownum rn)
measures(prod,cnt,vol,boxvol,0 sum, 0 put, 0 box)
RULES
      sum[any] = case when vol[cv()] + nvl(sum[cv()-1],0) > boxvol[cv()] then vol[cv()] + nvl(sum[cv()-1],0) - boxvol[cv()] else vol[cv()] + nvl(sum[cv()-1],0)  end  
    , put[any] = vol[cv()] + sum[cv()]
    , put[any] = case when sum[cv()] <= boxvol[cv()] then vol[cv()] else 0 end
    , box[any] = case when vol[cv()] + nvl(sum[cv()-1],0) > boxvol[cv()] then box[cv()-1] + 1 else nvl(box[cv()-1],1) end  
)
)
group by box,prod
order by box,prod
 
결과가
 
BOX PROD SUM(CNT) MAX(VOL) SUM(VOL)
1 A 2 200 400
2 B 2 300 600
 
 
이렇게 나오는데요...
 
그러면 2번 박스가 500을 초과합니다...
김흥수(protokhs)님이 2015-03-20 16:53에 작성한 댓글입니다.

RULES
(
      sum[any] = case when vol[cv()] + nvl(sum[cv()-1],0) > boxvol[cv()] then vol[cv()] else vol[cv()] + nvl(sum[cv()-1],0)  end 
    , put[any] = vol[cv()] + sum[cv()]
    , put[any] = case when sum[cv()] <= boxvol[cv()] then vol[cv()] else 0 end
    , box[any] = case when vol[cv()] + nvl(sum[cv()-1],0) > boxvol[cv()] then box[cv()-1] + 1 else nvl(box[cv()-1],1) end 
)
위부분으로 바꿔서 해보세요

모든 상황을 고려한다는게 어렵습니다

요점은 RULES 로 로직을 쿼리에 심을 수 있다는 걸 보여 준겁니다

학문적으로 접근하기는 어렵고요 어느정도 융통성을 갖고 

클라이언트와 열심히 상의하다보면 타협점이 있을겁니다

예제를 조금 더 확장해서 경우에 수를 관리하는 것도 하나에 방법이겠죠

디테일하게 처리하지는 않았습니다만

with o (prod,cnt,vol,volsum)--상품 테이블
      as( select 'A', 2, 200, 400 from dual
union all select 'B', 2, 300, 500 from dual
)
, b(boxvol) --포장 테이블
   as(select 500 from dual)
,t as (select column_value grn,o.prod,1 cnt, vol, boxvol
from o,table(select collect(level) from dual connect by level <= o.cnt), b
)
,p(boxvol,sot,prod,mods) as(--경우에 수 관리 테이블
          select 500,'r1','A',1 from dual
union all select 500,'r1','B',1 from dual
union all select 500,'r2','B',2 from dual
union all select 500,'r2','C',1 from dual
union all select 500,'r3','A',1 from dual
union all select 500,'r3','C',2 from dual
)
select * from(
select t.*
    , trunc((row_number() over(partition by t.prod order by 1)-1)/mods)+1 rn
from t inner join p on t.prod = p.prod and p.sot = 'r1'
order by rn,t.prod
)
model
dimension by(rownum rn)
measures(prod,cnt,vol,boxvol,0 sum, 0 put, 0 box)
RULES
(
      sum[any] = case when vol[cv()] + nvl(sum[cv()-1],0) > boxvol[cv()] then vol[cv()] else vol[cv()] + nvl(sum[cv()-1],0)  end 
    , put[any] = vol[cv()] + sum[cv()]
    , put[any] = case when sum[cv()] <= boxvol[cv()] then vol[cv()] else 0 end
    , box[any] = case when vol[cv()] + nvl(sum[cv()-1],0) > boxvol[cv()] then box[cv()-1] + 1 else nvl(box[cv()-1],1) end 
)

참고하세요

http://www.jlcomp.demon.co.uk/faq/Bin_Fitting.html 함 참고하세요

최성준(junkk)님이 2015-03-20 17:25에 작성한 댓글입니다.
이 댓글은 2015-03-21 00:11에 마지막으로 수정되었습니다.

 최성준님께는 좀 송구스러운 면이 있는데요...

 

최성준님이 제시하신  쿼리로 변경해도

BOX PROD SUM(CNT) MAX(VOL) SUM(VOL)
1 A 2 200 400
2 B 1 300 300
3 B 1 300 300
 
이처럼 나오는데요...
 
사실 300짜리 2개 200 짜리 2개면
쿼리로 안해봐도 암산으로
500짜기 박스 2개면 된다는 것을 바로 알 수 있지만
쿼리로 그것을 구현해내는 것은 거의 불가능하다는 것을 말씀드리려는 뜻입니다.
 
위에서도 말씀드렸듯이
저 문제는 짐싸기 문제라는 알고리즘 문제인데요...
다항시간에 푸는 것이 불가능하여
다항시간에 풀리는 유사 알고리즘이 있는(효율적인 짐싸기 문제) 것입니다.
즉 정확한 결과를 얻으려면 쿼리로는 안되는 것도 있다는 것을 말씀드리려는 뜻이구요..
 
질문자님이 요건을 분명히 하시면...
최성준님의 쿼리는 훌륭한 대안이 됩니다.
왜냐면
짐싸기 문제가 최적 해는 아니더라도
큰 짐을 우선적으로 싸고 남은 부분에 나머지 짐을 싸는 형태로 하면
대략 최적해에 비하여 20% 정도 이내로 최적에 가까워 진다고 합니다.
 
그리고 질문자님의 요건은 1차원 짐싸기 문제이구요..
 
질문 예제는 3차원 짐싸기 문제로 보입니다(왜냐면 부피이니까요..)
3차원 짐싸기 문제는 효율적인 알고리즘이 있는지 저도 잘 모르겠습니다.(2차원 짐싸기는 있는 것으로 알고 있습니다.)
 
1차원 짐싸기 문제는 파이프를 주문 사이즈로 재단하는 문제 같은 것을 예로 들 수있습니다.
 
김흥수(protokhs)님이 2015-03-20 17:42에 작성한 댓글입니다.

자꾸 안된다고 해서 미안한 마음이 드네요.^^;;;;;..

최성준님께서 올리신 수정된 쿼리는 룰을 사람이 결정해야 하고

상품종류가 늘어나면 조합이 어마어마해지는 문제가 있겠죠...

 

그리고 참조하라고 걸어주신 링크를 가보았는데 해당 링크의 문제는  관련이 없어 보입니다. 

일종의 온라인 균형 할당 문제(일종의 메모리 할당 알고리즘 같은) 더군요

대상 버킽 3개에 순차적으로 들어오는 요구를 균형 잡게 하는 문제로

단순 결정으로 되돌이가 없는 문제입니다.

 

모델절을 안써도 다음과 같이 하여도 문제가 풀립니다.

with  base_table as
(
    SELECT
        item_name
        ,item_value
        , row_NUMBER() OVER (ORDER BY item_value desc) rn 
    FROM t
)
, recur (item_name,item_value,rn, p1,p2,p3) as
(
    select
        a.item_name
        , a.item_value
        , a.rn
        , a.item_value
        , 0
        , 0
    from    base_table a
    where   a.rn = 1
    union all
    select
        a.item_name
        , a.item_value
        , a.rn
        , case when least(b.p1,b.p2+0.00001,b.p3+0.00002) = b.p1 then b.p1 + a.item_value else b.p1 end
        , case when least(b.p1,b.p2+0.00001,b.p3+0.00002) = b.p2+0.00001 then b.p2 + a.item_value else b.p2 end
        , case when least(b.p1,b.p2+0.00001,b.p3+0.00002) = b.p3+0.00002 then b.p3 + a.item_value else b.p3 end
    from    base_table a
            , recur b
    where   a.rn = b.rn + 1
)
select
    *
from    recur
 
 
그리고 제가 자꾸 안된다고 올려서 기분이 상하실 수도 있어서 말씀드립니다.
최성준님의 제안이 틀렸다고 말씀드리는 것은 절대 아닙니다.
위에서도 언급했듯이 잘 응용하면 최적해는 아니더라도 결과가 나올 것입니다.
단지 이 문제는 이미 다른 정답이 있는 문제이니 그 부분을 알아보시라고 말씀을 드리는 것입니다.
그리고 이경우는  SQL을 쓰지 않는 편이 훨씬 문제를 쉽게 해결하는 길입니다.
저도 재미로는  SQL로 별거를 다 시도하지만
실제 솔루션으로는 이 문제는 다른 대안이 더 좋다는 말씀을 드리는 것입니다.
 
말이 길어져 죄송합니다.
김흥수(protokhs)님이 2015-03-22 12:26에 작성한 댓글입니다.
이 댓글은 2015-03-22 23:05에 마지막으로 수정되었습니다.

 SQL로도 아니고

완전히 최적해도 아니지만

간단하게 부피가 큰 물건부터 채우는 알고리즘을 사용하면 다음과 같은 식으로 됩니다.

create type 박스 as object
(
    박스번호    number
    , 상품      varchar2(100)
    , 수량      number
    , 부피      number
);
/
create type 박스들 as table of 박스
;
/
create or replace function 박스분할
(
    커서        in  SYS_REFCURSOR 
    , 박스용량      number
)
return 박스들
pipelined
is
    type rec is record
    (
        박스번호    number
        ,잔여용량   number
    );
    type tbl is table of rec
    index by binary_integer;
    박스목록    tbl;
    빈박스      rec;
    v_상품      varchar(100);
    v_수량      number;
    v_부피      number;
    v_채운수량  number;
    v_채운부피  number;
begin
    loop
        fetch 커서 into v_상품,v_수량,v_부피;
        exit when 커서%notfound;
            -- 이미 할당한 박스에서 남은 부분에 상품을 채운다.
            for i in 1..박스목록.count loop
                빈박스 := 박스목록(i);
                v_채운수량 := least(v_수량,trunc(빈박스.잔여용량 / nullif(v_부피,0)));
                v_채운부피 := v_채운수량 * v_부피;
                if v_채운수량 > 0 then
                    pipe row(박스(빈박스.박스번호,v_상품,v_채운수량,v_채운부피));
                    빈박스.잔여용량 := nvl(빈박스.잔여용량,0) - v_채운부피;
                    박스목록(i) := 빈박스;
                    v_수량 := nvl(v_수량,0) - v_채운수량;
                end if;
            end loop;
            -- 새 박스에 남은 수량을 채우고 박스로 등록한다.
            loop
                exit when v_수량 <= 0;
                빈박스.박스번호 := 박스목록.count + 1;
                빈박스.잔여용량 := 박스용량;
                v_채운수량 := least(v_수량,trunc(빈박스.잔여용량 / nullif(v_부피,0)));
                v_채운부피 := v_채운수량 * v_부피;
                if v_채운수량 > 0 then
                    pipe row(박스(빈박스.박스번호,v_상품,v_채운수량,v_채운부피));
                    빈박스.잔여용량 := nvl(빈박스.잔여용량,0) - v_채운부피;
                    박스목록(빈박스.박스번호) := 빈박스;
                    v_수량 := nvl(v_수량,0) - v_채운수량;
                end if;
            end loop;
    end loop;
    close 커서;
exception
    when others then
        if 커서%isopen then
            close 커서;
        end if;
end;
/
--테스트는 다음과 같이 할 수 있다.
select
    *
from    table(박스분할(cursor(
            select 'A' 상품 ,2 수량 ,400 부피 from    dual
union all   select 'B' 상품 ,2 수량 ,300 부피 from    dual
union all   select 'C' 상품 ,6 수량 ,200 부피 from    dual
union all   select 'D' 상품 ,6 수량 ,100 부피 from    dual
order by
    부피 desc
),500))
/
결과는 다음과 같다.
박스번호 상품 수량 부피
1 A 1 400
2 A 1 400
3 B 1 300
4 B 1 300
3 C 1 200
4 C 1 200
5 C 2 400
6 C 2 400
1 D 1 100
2 D 1 100
5 D 1 100
6 D 1 100
7 D 2 200
 
 
 
 
select
    박스번호
    ,sum(부피) 부피계
from    table(박스분할(cursor(
            select 'A' 상품 ,2 수량 ,400 부피 from    dual
union all   select 'B' 상품 ,2 수량 ,300 부피 from    dual
union all   select 'C' 상품 ,6 수량 ,200 부피 from    dual
union all   select 'D' 상품 ,6 수량 ,100 부피 from    dual
order by
    부피 desc
),500))
group by
    박스번호
/
 
박스번호 부피계
1 500
6 500
2 500
4 500
5 500
3 500
7 200
 
 
코드는 참조만 하시고 그대로 쓰시면 버그가 있으니 주의바랍니다.
(예를 들어 경계조건 테스트가 빠져있습니다. 만약 박스크기보다 상품부피가 크다면 무한루프..)
김흥수(protokhs)님이 2015-03-22 22:47에 작성한 댓글입니다.
이 댓글은 2015-03-22 22:53에 마지막으로 수정되었습니다.

 최적해는 아니구요...

위에서 프로시져로 처리한 로직과 동일한 로직을 적용하여

최성준님이 제시하신 방법에 따라 모델절을 사용하여 만든 SQL은 다음과 같이 됩니다.

with 상품목록 as
(
            select 'A' 상품, 300 부피, 5 수량 from dual
union all   select 'B' 상품, 200 부피, 2 수량 from dual
union all   select 'C' 상품, 100 부피, 12 수량 from dual
)
, 정렬된상품목록 as
(
    select
        a.상품
        , a.부피
        , a.수량
        , row_number() over (order by a.부피 desc ) 순번
        , count(*) over() 상품수
    from    상품목록 a
)
select
    *
from
    (
        select
            설정_박스번호
            ,설정_상품
            ,설정_수량
            ,설정_부피
            ,설정_채운수량
        from    정렬된상품목록 
        model   
        dimension by (순번)
        measures 
        (
            상품수,상품,부피,수량,1 상품번호,수량 잔여수량, 0 총잔여수량,순번 남은상품번호
            ,0 박스번호,0 최종박스번호,:박스용량 잔여용량,0 임시_채운수량,0 발견_채운수량,cast ( null as varchar2(100)) 발견_상품,0 발견_수량,0 발견_박스번호,0 발견_부피, 0 발견_채운부피
            ,0 설정_박스번호,cast ( null as varchar2(100)) 설정_상품,0 설정_수량,0 설정_부피,0 설정_채운수량
        )
        rules iterate(1000000)
        until (0 >= 총잔여수량[1] )
        (
            총잔여수량[1] = sum(잔여수량)[any]
            ,상품번호[1] = min(남은상품번호)[any]
            ,최종박스번호[1] = max(박스번호)[any]
            ,잔여용량[iteration_number+1] = case when 상품수[1] < iteration_number+1 then :박스용량 else 잔여용량[iteration_number+1] end
            ,박스번호[iteration_number+1] = case when 상품수[1] < iteration_number+1 then iteration_number+1 else cv(순번) end
            ,임시_채운수량[any] = trunc(잔여용량[cv()] / 부피[상품번호[1]])
            ,발견_채운수량[any] = least(잔여수량[상품번호[1]],case when nvl(sum(임시_채운수량) over (order by 순번 rows between unbounded preceding and 1 preceding),0) > 0 then 0 else 임시_채운수량[cv()] end)
            ,발견_상품[any] = case when 발견_채운수량[cv()] > 0 then 상품[상품번호[1]] end
            ,발견_수량[any] = case when 발견_채운수량[cv()] > 0 then 수량[상품번호[1]] end
            ,발견_부피[any] = case when 발견_채운수량[cv()] > 0 then 부피[상품번호[1]] end
            ,발견_채운부피[any] = case when 발견_채운수량[cv()] > 0 then 부피[상품번호[1]] * 발견_채운수량[cv()] end
            ,발견_박스번호[any] = case when 발견_채운수량[cv()] > 0 then 박스번호[cv()] end
            ,설정_박스번호[iteration_number+1] = max(발견_박스번호)[any]
            ,설정_상품[iteration_number+1] = max(발견_상품)[any]
            ,설정_수량[iteration_number+1] = max(발견_수량)[any]
            ,설정_부피[iteration_number+1] = max(발견_부피)[any]
            ,설정_채운수량[iteration_number+1] = max(발견_채운수량)[any]
            ,잔여용량[any] = 잔여용량[cv()] - nvl(발견_채운부피[cv()],0)
            ,잔여수량[상품번호[1]] = nvl(잔여수량[상품번호[1]],0) - max(발견_채운수량)[any]
            ,남은상품번호[상품번호[1]] = case when 잔여수량[상품번호[1]] <= 0 then null else 상품번호[1] end
        )
    )
where   설정_박스번호 is not null
order by
    설정_박스번호
    ,설정_상품
/
 
제딴에는 최대한 간단하게 하고 가독성도 신경을 쓴 것입니다만...
이정도가 한계네요...
 
 
 ** 오류가 발견되어 수정하였습니다.
(수정사항 : 설정_채운수량 ==> 발견_채운수량 )
 
김흥수(protokhs)님이 2015-03-23 11:29에 작성한 댓글입니다.
이 댓글은 2015-03-23 13:10에 마지막으로 수정되었습니다.

질문자는 내용이  FFD, NFD? 인듯 하고

김흥수님은 휴리스틱 방식을 얘기하신 듯 하고 

그외에 방법은 BF? or WFD? 에 예제를 링크해 두었습니다.

수학전공이 아니면 용어가 생소 할 수 있을겁니다.

위 알고리즘은 이산수학 시간에서 배울겁니다. 

그리고 bin packing은 난제가 풀리지 않았다면 아직 NP-hard 입니다.

최성준(junkk)님이 2015-03-24 20:40에 작성한 댓글입니다.
이 댓글은 2015-12-27 23:47에 마지막으로 수정되었습니다.
[Top]
No.
제목
작성자
작성일
조회
40750계층형구조에서 하위 데이터 카운트 [1]
이혜미
2015-03-20
10152
40749OCP 자격 취득
정용석
2015-03-19
6346
40748오라클 tree 구조 질문좀 드립니다. [6]
ka
2015-03-19
7910
40747체적쿼리 질문입니다. [11]
초보자
2015-03-18
9545
40746쿼리 퀴즈입니다.(파스칼 삼각형) [1]
김흥수
2015-03-18
6965
40745마농님 지정시간 관련 sql 문의드립니다. [2]
김태경
2015-03-17
7292
40744그룹해서 최대 데이터 4개 출력 [2]
윤민근
2015-03-17
6350
Valid XHTML 1.0!
All about the DATABASE... Copyleft 1999-2024 DSN, All rights reserved.
작업시간: 0.018초, 이곳 서비스는
	PostgreSQL v16.2로 자료를 관리합니다