UVa 12099 The Bookcase - 动态规划

---

　　题目大意 给定一些书，每个书有一个高度和宽度，然后将它们放到一个三层的书架里(要求每一层都不为空)。定义书架的大小为每层最大的高度和 乘 每层宽度和的最大值。求最小的书架大小。

　　考虑动态规划。

　　然后确定状态，f[i][j][k]表示正在考虑第i本书，第2层的宽度和为j，第3层的宽度和为k（这样第一层的宽度和就可以计算出来）最小的高度和。然后发现无处下手。。。难道要把所有高度记录下来？

　　现在来考虑优化，最简单的一种就是去除无用、重复状态。

　　step 1 >> 放书的顺序和结果关系大吗？

　　　　　　显然不，所以为了更好地进行动态规划，决定现将所有书按照高度排序，这样每次放书的时候就判读放的那一层是否为空就能够进行快速的转移了。

　　然后发现状态总数 70 * 2100 * 2100 似乎会TLE(假设UVa的机子没有cf的辣么快，刘汝佳的书上说这会MLE，但是UVa不测内存啊)，继续考虑优化吧。(如果您用bfs记忆化搜索似乎也可以)

　　step 2 >> 考虑第一层放了宽度总和为8的书，第二层放了总和为4的书，和第一层放了总和为4的书，第二层放了总和为8的书有差别吗？

　　　　　　显然答案与此无关，但是在上面的动态规划中，如果我们认为这样的状态是相同的，那么它岂不是把同一个状态计算了4次？

　　　　　　所以我们规定，第一层的书的宽度和大于等于第二层，第二层的书的宽度总和大于第三层，这样就可以减少状态总数。

　　然后状态总数70 * 1050 * 700，似乎就差不多。刚开始想滚动一下，就写的bfs来dp。

Code

 /**
  * UVa
  * Problem#12099
  * Accepted
  * Time:90ms
  */
 #include <bits/stdc++.h>
 using namespace std;
 typedef bool boolean;
 const signed int inf = (signed)((1u << ) - );
 #define smin(a, b) (a) = min((a), (b))
 #define max3(a, b, c) max((a), max((b), (c)))

 typedef class Book {
     public:
         int w;
         int h;

         Book(int w = , int h = ):w(w), h(h) {        }

         boolean operator < (Book b) const {
             if(h != b.h) return h > b.h;
             return w > b.w;
         }
 }Book;

 typedef class Status {
     public:
         int stage;
         int w2;
         int w3;

         Status(int stage = , int w2 = , int w3 = ):stage(stage), w2(w2), w3(w3) {        }
 }Status;

 int n;
 int res;
 Book *bs;
 int *sumw;
 inline void init() {
     scanf("%d", &n);
     res = inf;
     bs = new Book[(n + )];
     sumw = new int[(n + )];
     for(int i = ; i <= n; i++)
         scanf("%d%d", &bs[i].h, &bs[i].w);
 }

 inline int getW1(Status& s) {
     return sumw[s.stage] - s.w2 - s.w3;
 }

 inline void fix(Status& s) {
     int w1 = getW1(s);
     int a[] = {w1, s.w2, s.w3};
     sort(a, a + );
     s.w2 = a[], s.w3 = a[];
 }

 int f[][][];
 queue<Status> que;
 inline void dp() {
     memset(f, 0x7f, sizeof(f[]) * (n + ));
     f[][][] = ;
     que.push(Status(, , ));
     while(!que.empty()) {
         Status e = que.front(), eu;
         que.pop();
 //        printf("f(%d, %d, %d, %d) = %d\n", e.stage, getW1(e), e.w2, e.w3, f[e.stage][e.w2][e.w3]);
         if(e.stage == n) {
             if(getW1(e) && e.w2 && e.w3)
                 smin(res, (max3(getW1(e), e.w2, e.w3)) * f[n][e.w2][e.w3]);
             continue;
         }

         eu = Status(e.stage + , e.w2, e.w3);
         fix(eu);
         if(f[eu.stage][eu.w2][eu.w3] == 0x7f7f7f7f)
             que.push(eu);
         smin(f[eu.stage][eu.w2][eu.w3], f[e.stage][e.w2][e.w3] + ((getW1(e)) ? () : (bs[eu.stage].h)));

         eu = Status(e.stage + , e.w2 + bs[e.stage + ].w, e.w3);
         fix(eu);
         if(f[eu.stage][eu.w2][eu.w3] == 0x7f7f7f7f)
             que.push(eu);
         smin(f[eu.stage][eu.w2][eu.w3], f[e.stage][e.w2][e.w3] + ((e.w2) ? () : (bs[eu.stage].h)));

         eu = Status(e.stage + , e.w2, e.w3 + bs[e.stage + ].w);
         fix(eu);
         if(f[eu.stage][eu.w2][eu.w3] == 0x7f7f7f7f)
             que.push(eu);
         smin(f[eu.stage][eu.w2][eu.w3], f[e.stage][e.w2][e.w3] + ((e.w3) ? () : (bs[eu.stage].h)));
     }
 }

 inline void solve() {
     sort(bs + , bs + n + );
     sumw[] = ;
     for(int i = ; i <= n; i++)
         sumw[i] = sumw[i - ] + bs[i].w;
     dp();
     printf("%d\n", res);
 }

 inline void clear() {
     delete[] bs;
 }

 int T;
 int main() {
     scanf("%d", &T);
     while(T--) {
         init();
         solve();
         clear();
     }
     return ;
 }