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

  1 /**
  2  * UVa
  3  * Problem#12099
  4  * Accepted
  5  * Time:90ms
  6  */
  7 #include <bits/stdc++.h>
  8 using namespace std;
  9 typedef bool boolean;
 10 const signed int inf = (signed)((1u << 31) - 1);
 11 #define smin(a, b) (a) = min((a), (b))
 12 #define max3(a, b, c) max((a), max((b), (c)))
 13
 14 typedef class Book {
 15     public:
 16         int w;
 17         int h;
 18
 19         Book(int w = 0, int h = 0):w(w), h(h) {        }
 20
 21         boolean operator < (Book b) const {
 22             if(h != b.h) return h > b.h;
 23             return w > b.w;
 24         }
 25 }Book;
 26
 27 typedef class Status {
 28     public:
 29         int stage;
 30         int w2;
 31         int w3;
 32
 33         Status(int stage = 0, int w2 = 0, int w3 = 0):stage(stage), w2(w2), w3(w3) {        }
 34 }Status;
 35
 36 int n;
 37 int res;
 38 Book *bs;
 39 int *sumw;
 40 inline void init() {
 41     scanf("%d", &n);
 42     res = inf;
 43     bs = new Book[(n + 1)];
 44     sumw = new int[(n + 1)];
 45     for(int i = 1; i <= n; i++)
 46         scanf("%d%d", &bs[i].h, &bs[i].w);
 47 }
 48
 49 inline int getW1(Status& s) {
 50     return sumw[s.stage] - s.w2 - s.w3;
 51 }
 52
 53 inline void fix(Status& s) {
 54     int w1 = getW1(s);
 55     int a[3] = {w1, s.w2, s.w3};
 56     sort(a, a + 3);
 57     s.w2 = a[1], s.w3 = a[0];
 58 }
 59
 60 int f[71][1060][710];
 61 queue<Status> que;
 62 inline void dp() {
 63     memset(f, 0x7f, sizeof(f[0]) * (n + 1));
 64     f[0][0][0] = 0;
 65     que.push(Status(0, 0, 0));
 66     while(!que.empty()) {
 67         Status e = que.front(), eu;
 68         que.pop();
 69 //        printf("f(%d, %d, %d, %d) = %d\n", e.stage, getW1(e), e.w2, e.w3, f[e.stage][e.w2][e.w3]);
 70         if(e.stage == n) {
 71             if(getW1(e) && e.w2 && e.w3)
 72                 smin(res, (max3(getW1(e), e.w2, e.w3)) * f[n][e.w2][e.w3]);
 73             continue;
 74         }
 75
 76         eu = Status(e.stage + 1, e.w2, e.w3);
 77         fix(eu);
 78         if(f[eu.stage][eu.w2][eu.w3] == 0x7f7f7f7f)
 79             que.push(eu);
 80         smin(f[eu.stage][eu.w2][eu.w3], f[e.stage][e.w2][e.w3] + ((getW1(e)) ? (0) : (bs[eu.stage].h)));
 81
 82         eu = Status(e.stage + 1, e.w2 + bs[e.stage + 1].w, e.w3);
 83         fix(eu);
 84         if(f[eu.stage][eu.w2][eu.w3] == 0x7f7f7f7f)
 85             que.push(eu);
 86         smin(f[eu.stage][eu.w2][eu.w3], f[e.stage][e.w2][e.w3] + ((e.w2) ? (0) : (bs[eu.stage].h)));
 87
 88         eu = Status(e.stage + 1, e.w2, e.w3 + bs[e.stage + 1].w);
 89         fix(eu);
 90         if(f[eu.stage][eu.w2][eu.w3] == 0x7f7f7f7f)
 91             que.push(eu);
 92         smin(f[eu.stage][eu.w2][eu.w3], f[e.stage][e.w2][e.w3] + ((e.w3) ? (0) : (bs[eu.stage].h)));
 93     }
 94 }
 95
 96 inline void solve() {
 97     sort(bs + 1, bs + n + 1);
 98     sumw[0] = 0;
 99     for(int i = 1; i <= n; i++)
100         sumw[i] = sumw[i - 1] + bs[i].w;
101     dp();
102     printf("%d\n", res);
103 }
104
105 inline void clear() {
106     delete[] bs;
107 }
108
109 int T;
110 int main() {
111     scanf("%d", &T);
112     while(T--) {
113         init();
114         solve();
115         clear();
116     }
117     return 0;
118 }