因为只有4个方块，所以枚举每个方块的选择顺序和放置方向（横放还是纵放），放置方式只有题目给出的6中基本模式，分别算出不同模式下最小的面积，更新最优解。
第4、5个在本质上其实是一样。如图，不同模式对应的最小面积如下：
设w1,w2,w3,w4表示4个方块的横长，h1,h2,h3,h4表示4个方块的纵长。w,h表示最小。
1：w=w1+w2+w3+w4；h=max(h1,h2,h3,h4)
2：w=max(w1+w2+w3,w4)；h=max(h1,h2,h3)+h4
3：w=max(w1+w2,w3)+w4；h=max(h1+h3,h2+h3,h4)
4：w=w1+w2+max(w3,w4)；h=max(h1,h3+h4,h2)
5：h=max(h1+h3,h2+h4)
对于w，我们细分为如下四种形式：
(1)：h3>=h2+h4；w=max(w1,w3+w2,w3+w4)
(2)：h3>h4 and h3<h2+h4；w=max(w1+w2,w2+w3,w3+w4)
(3)：h4>h3 and h4<h1+h3；w=max(w1+w2,w1+w4,w3+w4)
(4)：h4>=h1+h3；w=max(w2,w1+w4,w3+w4)
*：h3=h4（图中没画）；w=max(w1+w2,w3+w4)
用一个数组记录最优解，最后排序输出即可。
2. 这道题真很恶心，枚举，中间还要用到dfs。还有六种情况。很复杂，直接读别人的解体报告，但是两个递归函数还是不是很明白，但是知道这个函数是做什么的，为什么会这么写还是不懂。。。等以后有时间还是要做这道题。
3. 我的代码（其实是看的官方代码，然后自己写出来的。。。。），原来写的函数总是出错，后来索性重新写了一遍，把错误的也放在上边了
/*
ID: dollar4
PROG: packrec
LANG: C++
*/
#include <iostream>
#include <fstream>
#include <string>
#include <algorithm>
#include <cstring>
using namespace std;
//define const int INT_MAX = 10000;
struct Node
{
int x, y;
} node[4],rec;
int rst[101], rstm = 10000;
void record()
{
int m = rec.x * rec.y;
if (m < rstm)
{
rstm = m;
memset(rst, 0, sizeof(rst));
}
if (m == rstm)
{
rst[min(rec.x, rec.y)] = 1;
}
}
/*void calculate()
{
int i;
rec.x = 0;
rec.y = 0;
for (i = 0; i < 4; i++)
{
rec.x += node[i].x;
if (rec.y < node[i].y)
rec.y = node[i].y;
}
record();
rec.x = 0;
rec.y = 0;
rec.x = node[0].x + node[1].x + node[2].x;
if (rec.x < node[3].x)
rec.x = node[3].x;
for (i = 0; i < 3; i++)
{
if (rec.y < node[i].y)
rec.y = node[i].y;
}
rec.y += node[4].y;
record();
rec.x = 0;
rec.y = 0;
rec.x = node[0].x + node[1].x;
if (rec.x < node[2].x)
rec.x = node[2].x;
rec.x += node[3].x;
int temp = node[1].y + node[0].y;
rec.y = node[2].y + node[1].y;
if (temp > rec.y)
rec.y = temp;
if (rec.y < node[3].y)
rec.y = node[3].y;
record();
rec.y = 0;
rec.x = 0;
rec.x = node[0].x + node[1].x + max(node[3].x, node[2].x);
rec.y = max(max(node[2].y + node[3].y, node[1].y), node[0].y);
record();
rec.x = 0;
rec.y = 0;
rec.y = max(node[0].y + node[2].y, node[1].y + node[3].y);
if (node[2].y >= node[1].y + node[3].y)
rec.x = max(node[0].x, max(node[2].x + node[1].x, node[2].x + node[3].x));
if (node[2].y > node[3].y && node[2].y < node[1].y + node[3].y)
rec.x = max(max(node[0].x + node[1].x, node[1].x +node[2].x), node[2].x + node[3].x);
if (node[3].y > node[2].y && node[3].y < node[0].y + node[2].y)
rec.x = max(max(node[0].x + node[1].x, node[0].x + node[3].x), node[2].x + node[3].x);
if (node[3].y >= node[0].y + node[2].y)
rec.x = max(max(node[0].x + node[1].x, node[1].x), node[2].x + node[3].x);
if (node[2].y == node[3].y)
rec.x = max(node[0].x + node[1].x, node[2].x + node[3].x);
record();
}
*/
void calculate()
{
//case 1
rec.x = 0;
rec.y = 0;
for (int i = 0; i < 4; ++i)
{
rec.x += node[i].x;
if (node[i].y > rec.y) rec.y = node[i].y;
}
record();
//case 2
rec.x = 0;
rec.y = 0;
for (int i = 1; i < 4; ++i)
{
rec.x += node[i].x;
if (node[i].y > rec.y) rec.y = node[i].y;
}
if (node[0].x > rec.x) rec.x = node[0].x;
rec.y += node[0].y;
record();
//case 3
rec.x = max(node[0].x+node[1].x, node[2].x)+node[3].x;
rec.y = max(max(node[0].y, node[1].y)+node[2].y, node[3].y);
record();
//case 4, 5
rec.x = node[0].x+max(node[1].x, node[2].x)+node[3].x;
rec.y = max(max(node[0].y, node[1].y+node[2].y), node[3].y);
record();
//case 6
rec.x = node[0].x+node[1].x;
rec.y = max(node[0].y+node[2].y, node[1].y+node[3].y);
if (node[0].y < node[1].y)
rec.x = max(rec.x, node[2].x+node[1].x);
if (node[0].y+node[2].y > node[1].y)
rec.x = max(rec.x, node[2].x+node[3].x);
if (node[1].y < node[0].y)
rec.x = max(rec.x, node[0].x+node[3].x);
rec.x = max(rec.x, node[2].x);
rec.x = max(rec.x, node[3].x);
record();
}
void rota(int a)
{
if (a == 4)
calculate();
else
{
rota(a + 1);
swap(node[a].x, node[a].y);
rota(a + 1);
swap(node[a].x, node[a].y);
}
}
void pf(int a)
{
if (a == 4)
rota(0);
else
{
for (int i = a; i < 4; i++)
{
swap(node[i], node[a]);
pf(a + 1);
swap(node[i], node[a]);
}
}
}int main()
{
ofstream fout ("packrec.out");
ifstream fin ("packrec.in");
int i;
for (i = 0; i < 4; i++)
fin >> node[i].x >> node[i].y;
pf(0);
fout << rstm << endl;
for (i = 0; i < 101; i++)
{
if (rst[i] == 1)
fout << i << " " << rstm / i << endl;
}
return 0;
}
4. 官方代码
This program is straightforward, but a bit long due to the geometry involved.
There are 24 permutations of the 4 rectangles, and for each permutation, 16 different ways to orient them. We generate all such orientations of permutations, and put the blocks together in each of the 6 different ways, recording the smallest rectangles we find.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct Rect Rect;
struct Rect {
int wid;
int ht;
};
Rect
rotate(Rect r)
{
Rect nr;
nr.wid = r.ht;
nr.ht = r.wid;
return nr;
}
int
max(int a, int b)
{
return a > b ? a : b;
}
int
min(int a, int b)
{
return a < b ? a : b;
}
int tot;
int bestarea;
int bestht[101];
void
record(Rect r)
{
int i;
if(r.wid*r.ht < tot)
*(long*)0=0;
if(r.wid*r.ht < bestarea || bestarea == 0) {
bestarea = r.wid*r.ht;
for(i=0; i<=100; i++)
bestht[i] = 0;
}
if(r.wid*r.ht == bestarea)
bestht[min(r.wid, r.ht)] = 1;
}
void
check(Rect *r)
{
Rect big;
int i;
/* schema 1: all lined up next to each other */
big.wid = 0;
big.ht = 0;
for(i=0; i<4; i++) {
big.wid += r[i].wid;
big.ht = max(big.ht, r[i].ht);
}
record(big);
/* schema 2: first three lined up, fourth on bottom */
big.wid = 0;
big.ht = 0;
for(i=0; i<3; i++) {
big.wid += r[i].wid;
big.ht = max(big.ht, r[i].ht);
}
big.ht += r[3].ht;
big.wid = max(big.wid, r[3].wid);
record(big);
/* schema 3: first two lined up, third under them, fourth to side */
big.wid = r[0].wid + r[1].wid;
big.ht = max(r[0].ht, r[1].ht);
big.ht += r[2].ht;
big.wid = max(big.wid, r[2].wid);
big.wid += r[3].wid;
big.ht = max(big.ht, r[3].ht);
record(big);
/* schema 4, 5: first two rectangles lined up, next two stacked */
big.wid = r[0].wid + r[1].wid;
big.ht = max(r[0].ht, r[1].ht);
big.wid += max(r[2].wid, r[3].wid);
big.ht = max(big.ht, r[2].ht+r[3].ht);
record(big);
/*
* schema 6: first two pressed next to each other, next two on top, like:
* 2 3
* 0 1
*/
big.ht = max(r[0].ht+r[2].ht, r[1].ht+r[3].ht);
big.wid = r[0].wid + r[1].wid;
/* do 2 and 1 touch? */
if(r[0].ht < r[1].ht)
big.wid = max(big.wid, r[2].wid+r[1].wid);
/* do 2 and 3 touch? */
if(r[0].ht+r[2].ht > r[1].ht)
big.wid = max(big.wid, r[2].wid+r[3].wid);
/* do 0 and 3 touch? */
if(r[1].ht < r[0].ht)
big.wid = max(big.wid, r[0].wid+r[3].wid);
/* maybe 2 or 3 sits by itself */
big.wid = max(big.wid, r[2].wid);
big.wid = max(big.wid, r[3].wid);
record(big);
}
void
checkrotate(Rect *r, int n)
{
if(n == 4) {
check(r);
return;
}
checkrotate(r, n+1);
r[n] = rotate(r[n]);
checkrotate(r, n+1);
r[n] = rotate(r[n]);
}
void
checkpermute(Rect *r, int n)
{
Rect t;
int i;
if(n == 4)
checkrotate(r, 0);
for(i=n; i<4; i++) {
t = r[n], r[n] = r[i], r[i] = t; /* swap r[i], r[n] */
checkpermute(r, n+1);
t = r[n], r[n] = r[i], r[i] = t; /* swap r[i], r[n] */
}
}
void
main(void)
{
FILE *fin, *fout;
Rect r[4];
int i;
fin = fopen("packrec.in", "r");
fout = fopen("packrec.out", "w");
assert(fin != NULL && fout != NULL);
for(i=0; i<4; i++)
fscanf(fin, "%d %d", &r[i].wid, &r[i].ht);
tot=(r[0].wid*r[0].ht+r[1].wid*r[1].ht+r[2].wid*r[2].ht+r[3].wid*r[3].ht);
checkpermute(r, 0);
fprintf(fout, "%d\n", bestarea);
for(i=0; i<=100; i++)
if(bestht[i])
fprintf(fout, "%d %d\n", i, bestarea/i);
exit(0);
}