USACO sec1.4 Packing Rectangles

　　这道题是 IOI95 的题目，直接做感觉有难度，主要原因是题目描述的六种形式是否是完备的，其实这个问题不需要考虑（题目已经明确指出了，或许已经被证明了），剩下的就是枚举了；

1Y，这道题考的是生成排列的方法和模拟中细节的处理。

/*
PROG : packrec
LANG : C++
*/
# include <cstdio>
# include <cstdlib>

int h[5][2];
int pp[25][5], k = 0;
int solu[6*24*16+5][2], n = 0, m = 0;

/******************************************************************************/
void read(void)
{
    int i;
    for (i = 1; i < 5; ++i)
        scanf("%d%d", &h[i][0], &h[i][1]);
}

/******************************************************************************/

int Max(int x, int y)
{
    return x > y ? x : y;
}

int Min(int x, int y)
{
    return x < y ? x : y;
}

int cal(int ic, int od, int st)
{
    int x, y;
    int a, b, c, d;
    int p, q, r, s;

    /****************************/
    a = pp[od][1];
    b = pp[od][2];
    c = pp[od][3];
    d = pp[od][4];
    p = (st&0x1) ? 1:0;
    q = (st&0x2) ? 1:0;
    r = (st&0x4) ? 1:0;
    s = (st&0x8) ? 1:0;
    /****************************/
    switch(ic)
    {
        case 1:
            {
                x = h[a][1-p]+h[b][1-q]+h[c][1-r]+h[d][1-s];
                y = Max(h[a][p], Max(h[b][q], Max(h[c][r], h[d][s])));
                break;
            }
        case 2:
            {
                x = Max(h[a][1-p]+h[b][1-q]+h[c][1-r], h[d][1-s]);
                y = Max(h[a][p], Max(h[b][q], h[c][r])) + h[d][s];
                break;
            }
        case 3:
            {
                x = Max(h[a][1-p]+h[b][1-q], h[d][1-s]) + h[c][1-r];
                y = Max(Max(h[a][p], h[b][q])+h[d][s], h[c][r]);
                break;
            }
        case 4:
            {
                x = Max(h[a][1-p], h[b][1-q])+h[c][1-r]+h[d][1-s];
                y = Max(h[a][p]+h[b][q], Max(h[c][r], h[d][s]));
                break;
            }
        case 5:
            {
                if (h[b][q] < h[a][p])      return -1;
                if (h[c][1-r]>h[a][1-p]) return -1;
                if (h[d][1-s]>h[a][1-p]) return -1;
                if (h[c][1-r]>h[b][1-q] && h[d][s]+h[a][p]>h[b][q] &&
                    h[d][1-s]+h[c][1-r]>h[a][1-p]+h[b][1-q])
                    return -1;
                
                x = Max(h[a][1-p]+h[b][1-q], h[c][1-r]+h[d][1-s]);
                y = Max(h[a][p]+h[d][s], h[b][q]+h[c][r]);
/*                
                if (ic==5 && od==2 && st==12)
                {
                    printf(":: %d\t%d\t%d\t%d\n", p, q, r, s);
                    printf(":: %d\t%d\n", h[c][1-r], h[d][1-s]);
                }
*/                
                break;
            }
    }
    solu[n][0] = Min(x, y);
    solu[n][1] = Max(x, y);
    ++n;
/* 
    if (x*y == 36)
        printf("%d\t%d\t%d\n", ic, od, st);
*/
    return x * y;
}

/******************************************************************************/

int cmp(const void *xx, const void *yy)
{
    int x = *(int*)xx;
    int y = *(int*)yy;
    if (x == y) return *((int*)xx+1) - *((int*)yy+1);
    return x - y;
}

void solve(void)
{
    int i, j, s, ans = 0X7FFFFFFF, tmp;
    for (i = 1; i <= 5; ++i)
    for (j = 0; j < k; ++j)
    for (s = 0; s < 16; ++s)
    {
        tmp = cal(i, j, s);
        if (tmp > 0) ans = Min(tmp, ans);
    }
    printf("%d\n", ans);
    qsort(solu, n, sizeof(solu[0]), cmp);
    for (i = 1; i < n; ++i)
    {
        if (solu[i][0] == solu[m][0] && solu[i][1] == solu[m][1])
            continue;
        else
        {
            ++m;
            solu[m][0] = solu[i][0], solu[m][1] = solu[i][1];
         }
    }    
    for (i = 0; i <= m; ++i)
    {
        if (solu[i][0]*solu[i][1] == ans)
            printf("%d %d\n", solu[i][0], solu[i][1]);
    }
}

/******************************************************************************/
void dfs(int *A, int cnt)
{
    int i, j, ok;
    if (cnt == 4)
    {
        for (i = 1; i < 5; ++i) pp[k][i] = A[i];
/*
        printf("%d : ", k);
        for (i = 1; i < 5; ++i) printf("%d ", A[i]);
        putchar('\n');
*/
        ++k;
    }
    else
    {
        for (i = 1; i < 5; ++i)
        {
            ok = 1;
            for (j = 1; j <= cnt; ++j) if (A[j] == i) {ok = 0; break;}
            if (ok)
            {
                A[cnt+1] = i;
                dfs(A, cnt+1);
            }
        }
    }
}

void compute_permutation(void)
{
    int a[4];
    dfs(a, 0);
}
/******************************************************************************/

int main()
{
    freopen("packrec.in", "r", stdin);
    freopen("packrec.out", "w", stdout);

    int i, j;

    compute_permutation();
/*
    for (i = 0; i < k; ++i)
    {
        if (i != 0) putchar('\n');
        printf("%d", pp[i][1]);
        for (j = 2; j < 5; ++j) printf(" %d", pp[i][j]);
    }
*/
    read();
    solve();

    fclose(stdin);
    fclose(stdout);

    return 0;
}

代码写了一个多小时，修改+调试。