【USACO】packrec

这道题卡了很久，开始没读清楚题，没看到题目中给的6个组合是仅可能的组合，一直自己想有多少种组合方式。后来才发现，于是就想到写遍历。我想的是，这六种情况下，每个位置摆哪个矩形是不确定的，于是可以对方块的排列方法遍历，对每个方块是横放还是竖放遍历。写了一个9层的循环，效率很低，有非常多的重复。不过通过了。

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

typedef struct
{
    int x;
    int y;
}RECTANGLE;

typedef struct
{
    RECTANGLE r[];
}RECRotate;

int cmp(const void *a1, const void *a2)
{
    return ((RECTANGLE *)a1)->x - ((RECTANGLE *)a2)->x;
}

int max(int a, int b)
{
    return a > b ? a : b;
}
int min(int a, int b)
{
    return a < b ? a : b;
}

int assem(int c, RECTANGLE r1, RECTANGLE r2, RECTANGLE r3, RECTANGLE r4, RECTANGLE *out)
{
    switch(c)
    {
    case :
        out->x = r1.x + r2.x + r3.x + r4.x;
        out->y = max(r4.y, max(r3.y, max(r1.y, r2.y)));
        break;
    case :
        out->x = max(r4.y, r1.x + r2.x + r3.x);
        out->y = max(r3.y, max(r1.y, r2.y)) + r4.x;
        break;
    case :
        out->x = max(r1.x + r2.x + r3.x, r3.x + r4.y);
        out->y = max(r1.y + r4.x, max(r3.y, r2.y + r4.x));
        break;
    case : //basic 4 and basic 5 have the same area
        out->x = max(r2.x, r3.x) + r1.x +r4.x;
        out->y = max(r2.y + r3.y, max(r1.y, r4.y));
        break;
    case :
        if(r3.y >= r4.y)
        {
            out->x = max(r2.y + r3.x, max(r3.x + r4.x, r1.x + r2.y));
            out->y = max(r1.y + r3.y, r2.x + r4.y);
        }
        break;
    default:
        break;
    }
    return ;
}

int isfirst(RECTANGLE *outr, int num, RECTANGLE tmp) //判断答案是否第一次出现 因为计算有冗余 可能有相同答案出现多次
{
    int i;
    for(i = ; i < num; i++)
    {
        if(tmp.x == outr[i].x || tmp.y == outr[i].x)
        {
            return ;
        }
    }
    return ;
}
int main()
{
    FILE *in, *out;
    RECRotate recin[]; //原始输入矩阵
    RECTANGLE outr[];

    int i, j[], k[];
    in = fopen("packrec.in", "r");
    out = fopen("packrec.out", "w");

    for(i = ; i < ; i++)
    {
        fscanf(in, "%d %d", &recin[i].r[].x, &recin[i].r[].y);
        recin[i].r[].x = recin[i].r[].y;
        recin[i].r[].y = recin[i].r[].x;
    }

    RECTANGLE R1;
    RECTANGLE R2;
    RECTANGLE R3;
    RECTANGLE R4;
    RECTANGLE OUTTMP;
    int minarea = ;
    int outnum = ;
    for(j[] = ; j[] < ; j[]++) //对每个位置采用第几个方块遍历
    {
        for(j[] = ; j[] < ; j[]++)
        {
            if(j[] == j[]) continue;
            for(j[] = ; j[] < ; j[]++)
            {
                if(j[] == j[] || j[] == j[]) continue;
                for(j[] = ; j[] < ; j[]++)
                {
                    if(j[] == j[] || j[] == j[] || j[] == j[]) continue;
                    for(k[] = ; k[] < ; k[]++)
                    {
                        for(k[] = ; k[] < ; k[]++) //对每个方块采用横放竖放遍历
                        {
                            for(k[] = ; k[] < ; k[]++)
                            {
                                for(k[] = ; k[] < ; k[]++)
                                {
                                    R1 = recin[j[]].r[k[]];
                                    R2 = recin[j[]].r[k[]];
                                    R3 = recin[j[]].r[k[]];
                                    R4 = recin[j[]].r[k[]];
                                    for(i = ; i < ; i++)   //对6种情况遍历
                                    {
                                        assem(i, R1, R2, R3, R4, &OUTTMP);
                                        if(OUTTMP.x * OUTTMP.y < minarea)
                                        {
                                            minarea = OUTTMP.x * OUTTMP.y;
                                            outnum = ;
                                            outr[outnum - ] = OUTTMP;
                                        }
                                        else if(OUTTMP.x * OUTTMP.y == minarea && isfirst(outr, outnum, OUTTMP))
                                        {
                                            outnum++;
                                            outr[outnum - ] = OUTTMP;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    for(i = ; i < outnum; i++) //令短边长在前
    {
        if(outr[i].x > outr[i].y)
        {
            int tmp = outr[i].x;
            outr[i].x = outr[i].y;
            outr[i].y = tmp;
        }
    }
    qsort(outr, outnum, sizeof(outr[]), cmp);  //按照短边长从小到大输出

    fprintf(out, "%d\n", minarea);
    for(i = ; i < outnum; i++)
    {
            fprintf(out, "%d %d\n", outr[i].x, outr[i].y);
    }

    return ;
}