USACO Packing Rectangles

最新推荐文章于 2014-03-29 11:37:25 发布
最新推荐文章于 2014-03-29 11:37:25 发布
阅读量289 收藏
点赞数
分类专栏： USACO
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bluecat56/article/details/13023013
版权

1、USACO真是相当重口，才1.4节就给了一道95年的IOI题目，如果不是事先知道用搜索做，而且还有测试数据（21组！）的话，以我的水平，真的很可能做不出来。

2、这个程序需要6个dfs，也就是每一种情况都要分别为它写一个dfs，最后一种“田”字型是最难的，要分成四类，刚开始因为思路不清晰在乱做，所以总是WA。一定要注意分类讨论要不重不漏，也就是大于等于的等于号不能少。

3、注意，标号为1,2,3,4的四个位置要轮流放一遍那些长方形，共4！种可能，而且每个长方形都有两种放法，所以这道题总共是6*4！*2^4种情况。

4、程序虽然很长，但是6个dfs只有微小差别。画个图可能更容易帮助理解。

5、哦，对了，因为没注意答案要按升序排列（其实注意到了，但是写着写着又忘了），所以WA了几次，一定要注意。

6、虽然一共交了十次才过，但我完全是独立思考并完成的，真的很有成就感！

/*
ID:mrxy564
PROG:packrec
LANG:C++
*/
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
struct Rec{
    int l,w;
};
struct Sqr{
    int s,l,w;
    bool operator<(const Sqr &obj)const{
        return l<obj.l||l==obj.l&&w<obj.w;
    }
    bool operator ==(const Sqr &obj)const{
        return l==obj.l&&w==obj.w;
    }
    bool operator>(const Sqr &obj)const{
        return l>obj.l||l==obj.l&&w>obj.w;
    }
};
Rec a[4],b[4];
Sqr ans[5000];
int vis[4],cnt=0,minn;
void dfs1(int depth,Rec* b){
    if(depth==4){
        int len=0,wid=0;
        for(int i=0;i<4;i++){
          len=max(len,b[i].l);
          wid+=b[i].w;
        }
        ans[cnt].s=len*wid;
        ans[cnt].l=len;
        ans[cnt].w=wid;
        if(ans[cnt].s<minn) minn=ans[cnt].s;
        cnt++;
        return;
    }
    for(int i=0;i<4;i++){
      if(!vis[i]){
        vis[i]=1;
        b[depth].l=a[i].l;
        b[depth].w=a[i].w;
        dfs1(depth+1,b);
        b[depth].l=a[i].w;
        b[depth].w=a[i].l;
        dfs1(depth+1,b);
        vis[i]=0;
      }
    }
    return;
}
void dfs2(int depth,Rec* b){
    if(depth==4){
         int len=0,wid=0;
         for(int i=0;i<3;i++)
           len=max(len,b[i].l+b[3].l);
         wid=max(b[3].w,b[0].w+b[1].w+b[2].w);
         ans[cnt].s=len*wid;
         ans[cnt].l=len;
         ans[cnt].w=wid;
         if(ans[cnt].s<minn) minn=ans[cnt].s;
         cnt++;
         return;
    }
    for(int i=0;i<4;i++){
      if(!vis[i]){
        vis[i]=1;
        b[depth].l=a[i].l;
        b[depth].w=a[i].w;
        dfs2(depth+1,b);
        b[depth].l=a[i].w;
        b[depth].w=a[i].l;
        dfs2(depth+1,b);
        vis[i]=0;
      }
    }
    return;
}
void dfs3(int depth,Rec* b){
    if(depth==4){
         int len=0,wid=0;
         for(int i=0;i<2;i++)
           len=max(len,b[i].l+b[3].l);
         len=max(len,b[2].l);
         wid=max(b[0].w+b[1].w+b[2].w,b[3].w+b[2].w);
         ans[cnt].s=len*wid;
         ans[cnt].l=len;
         ans[cnt].w=wid;
         if(ans[cnt].s<minn) minn=ans[cnt].s;
         cnt++;
         return;
    }
    for(int i=0;i<4;i++){
      if(!vis[i]){
        vis[i]=1;
        b[depth].l=a[i].l;
        b[depth].w=a[i].w;
        dfs3(depth+1,b);
        b[depth].l=a[i].w;
        b[depth].w=a[i].l;
        dfs3(depth+1,b);
        vis[i]=0;
      }
    }
    return;
}
void dfs4(int depth,Rec* b){
    if(depth==4){
         int len=0,wid=0;
         len=max(b[0].l,b[3].l);
         len=max(len,b[1].l+b[2].l);
         wid=max(b[0].w+b[1].w+b[3].w,b[0].w+b[2].w+b[3].w);
         ans[cnt].s=len*wid;
         ans[cnt].l=len;
         ans[cnt].w=wid;
         if(ans[cnt].s<minn) minn=ans[cnt].s;
         cnt++;
         return;
    }
    for(int i=0;i<4;i++){
      if(!vis[i]){
        vis[i]=1;
        b[depth].l=a[i].l;
        b[depth].w=a[i].w;
        dfs4(depth+1,b);
        b[depth].l=a[i].w;
        b[depth].w=a[i].l;
        dfs4(depth+1,b);
        vis[i]=0;
      }
    }
    return;
}
void dfs5(int depth,Rec* b){
    if(depth==4){
         int len=0,wid=0;
         len=max(b[2].l,b[3].l);
         len=max(len,b[0].l+b[1].l);
         wid=max(b[0].w+b[2].w+b[3].w,b[1].w+b[2].w+b[3].w);
         ans[cnt].s=len*wid;
         ans[cnt].l=len;
         ans[cnt].w=wid;
         if(ans[cnt].s<minn) minn=ans[cnt].s;
         cnt++;
         return;
    }
    for(int i=0;i<4;i++){
      if(!vis[i]){
        vis[i]=1;
        b[depth].l=a[i].l;
        b[depth].w=a[i].w;
        dfs5(depth+1,b);
        b[depth].l=a[i].w;
        b[depth].w=a[i].l;
        dfs5(depth+1,b);
        vis[i]=0;
      }
    }
    return;
}
void dfs6(int depth,Rec* b){
    if(depth==4){
         int len,wid;
         if(b[1].l>=b[3].l&&b[1].w>=b[0].w||b[1].l<b[3].l&&b[1].w<b[0].w){
           len=wid=0;
           len=max(b[0].l+b[1].l,b[2].l+b[3].l);
           wid=max(b[0].w,b[1].w)+max(b[2].w,b[3].w);
           ans[cnt].s=len*wid;
           ans[cnt].l=len;
           ans[cnt].w=wid;
           if(ans[cnt].s<minn) minn=ans[cnt].s;
           cnt++;
         }
         if(b[1].l<b[3].l&&b[1].w>=b[0].w||b[1].l>=b[3].l&&b[1].w<b[0].w){
           len=wid=0;
           len=max(b[0].l+b[1].l,b[2].l+b[3].l);
           wid=max(b[0].w+b[2].w,b[1].w+b[3].w);
           ans[cnt].s=len*wid;
           ans[cnt].l=len;
           ans[cnt].w=wid;
           if(ans[cnt].s<minn) minn=ans[cnt].s;
           cnt++;
         }
         return;
    }
    for(int i=0;i<4;i++){
      if(!vis[i]){
        vis[i]=1;
        b[depth].l=a[i].l;
        b[depth].w=a[i].w;
        dfs6(depth+1,b);
        b[depth].l=a[i].w;
        b[depth].w=a[i].l;
        dfs6(depth+1,b);
        vis[i]=0;
      }
    }
    return;
}
int main(){
    freopen("packrec.in","r",stdin);
    freopen("packrec.out","w",stdout);
    for(int i=0;i<4;i++)
        scanf("%d%d",&a[i].l,&a[i].w);
    memset(b,0,sizeof(b));
    memset(ans,-1,sizeof(ans));
    memset(vis,0,sizeof(vis));
    minn=2147483647;
    dfs1(0,b);
    dfs2(0,b);
    dfs3(0,b);
    dfs4(0,b);
    dfs5(0,b);
    dfs6(0,b);
    for(int i=0;i<cnt;i++)
       if(ans[i].l>ans[i].w)
           swap(ans[i].l,ans[i].w);
    sort(ans,ans+cnt);
    cnt=unique(ans,ans+cnt)-ans;
    printf("%d\n",minn);
    for(int i=0;i<cnt;i++)
       if(ans[i].s==minn){
             printf("%d %d\n",ans[i].l,ans[i].w);
       }
    return 0;
}
官方题解：

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);
}

 

深蓝色的猫
关注
专栏目录
USACO.zip_usaco
09-24
USACO，全称为USA Computing Olympiad，是一项针对中学生举办的国际编程竞赛，旨在培养参赛者的算法设计、问题解决和编程技能。这个压缩包“USACO.zip_usaco”包含了作者在USACO前两章学习过程中编写的代码，且所有...
USACO Section 1.4 Packing Rectangles（枚举）
angtongyou1893的博客
08-27 180
Packing RectanglesIOI 95The six basic layouts of four rectangles Four rectangles are given. Find the smallest enclosing (new) rectangle into which these four may be fitted without overlapping. ...
[USACO] Packing Rectangles
天下的技术专栏
04-12 1341
最近一个月一直在忙GSoC，没时间做题，也就没更新，很惭愧。。。本想速战速决来个开门红，结果遇到了传说中usaco第一道杀脑细胞的题，用了一天时间外加网上提示才搞定，真是失败！这道题想法倒是不难，枚举所有的可能情况，6种基本布局，每个布局有4！种放矩形的可能，又因为矩形的位置固定后可以旋转，故每种放置又有2*2*2*2中旋转可能，对每一种可能找到它的外围矩形，然后更新最小面积值。最开始我理解题目出现错误，我以为四个矩形必须拼成一个完整的大矩形（例子给的四个矩形和输出就可以，被误导了！），结果有一组数据过不去
USACO-Packing Rectangles
anyuan5299的博客
10-06 129
http://ace.delos.com/usacoprob2?a=GOVL6gcgbQL&S=packrec 嗯，一道无比恶心的题。。。。 观察好这几个图形，基本上就要靠这几个图形做题了。这题恶心的地方除了这几个图形，还有就是暴搜的方法，要全排列生成4个矩形的排列，然后才能按照上面几个图形来划分cases。注意了，第四个和第五个图形是一样的，只不过把中间的一列和左边的一...
USACO Packing Rectangles [cheated]
06-16 339
不会做，枚举麻烦，这题看着烦，先cheat过去以后再写 参考： http://zqynux.iteye.com/blog/616878 http://www.cnblogs.com/sunzhenxing19860608/archive/2011/07/07/2100246.html http://blog.sina.com.cn/s/blog_4e4c6ca501000cpt
usaco 1.4.1 Packing Rectangles
shshwdr的专栏
02-22 1020
Packing Rectangles IOI 95 The six basic layouts of four rectangles Four rectangles are given. Find the smallest enclosing (new) rectangle into which these four may be fitted without overlap
USACO.rar_usaco
09-20
《USACO电脑奥林匹克试题解码之旅》 USACO，全称为United States of America Computing Olympiad，是美国的一项计算机科学竞赛，旨在激发中学生对计算机编程的兴趣和潜能。这个竞赛涵盖了一系列的算法和数据结构...
USACO：1.4.1 Packing Rectangles 铺放矩形块（IOI 95）解析
蓝e的专栏
03-29 2974
USACO：Packing Rectangles 铺放矩形块（IOI 95） 解析 题目描述：        给定4 个矩形块，找出一个最小的封闭矩形将这4 个矩形块放入，但不得相互重叠。所谓最小矩形指该矩形面积最小。所有4 个矩形块的边都与封闭矩形的边相平行，图1 示出了铺放4 个矩形块的6 种方案.这6 种方案仅只是可能的基本铺放方案。因为其它方案能由基本方案通过旋转和镜像反射得到。可能存
Usaco 1.4.1 铺放矩形块（Packing Rectangles）
慢慢前行，跨越预言
08-05 1640
题目：  铺放矩形块 来源：  Usaco1.4.1 题目大意：  已知4个矩形的长宽，求其各自不覆盖所组成的最小矩形（已给出六个模板），输出最小矩形面  积和各个解（即该矩形长宽，按升序排，且第一个值小于等于该行
USACO 1.4.1 Packing Rectangles —— 暴力+ 模拟
XMzhou的专栏
11-20 1985
Packing Rectangles IOI 95   The six basic layouts of four rectangles Four rectangles are given. Find the smallest enclosing (new) rectangle into which these four may be fitted without overlapping.
USACO Contact
01-29 833
1、这是98年的一道IOI题目，本来以为要用到KMP，后来发现O（m*n）的算法就可以了。要注意的是0,00,000的二进制值是一样的，为了区分，需要在所有数前面加上一个“1”，这样相当于构建了一个新的映射s->1s，更方便计算（遵循KISS原则：Keep It Simple and Stupid,不要给自己找不痛快）。 2、统计完毕后先按照频率排，频率相同按照长度排（这里可以直接按值的大小，想
USACO 【10 Mar Gold】Great Cow Gathering
11-28 456
1、树形DP。。。算子树的权和的方法很巧妙。 2、学习了二维vector的用法。 3、由于输入输出的速度太慢，所以不知道是因为文件太大超时还是算法不够优超时，总之前6组数据过了，姑且算这道题过了吧。 #include #include #include using namespace std; int n,a,b,c; long long cow[100010],down[1000
USACO Magic Squares
02-08 423
1、这是96年的一道IOI题目，一道恶心的搜索。。。最近USACO快做哭了，根本没把我当初学者T T。。。谁说“做完前三章，稳拿一等奖”啊，岂止一等奖，明明可以参加NOI了。。。 2、刚开始我脑子发昏，竟然倒序输出，所以怎么都不对，没法输出字典序最小，还以为是搜索顺序的问题，硬是把程序改复杂了。。。 3、算法嘛，就是bfs+康托展开+逆康托展开即可。注意题目给出的数字顺序和常规不太一样，初始状
USACO Runaround Numbers
01-18 398
1、唉，我真是太浮躁了，不好好读题，所以做错了两次。 2、要注意题干中说digits是“unique”的，也就是各不相同，还说每次产生的新数不能和原数相同（其实和前一个条件是一个意思）。 3、我还把memset写到循环外面了，造成死循环，其实只要测试一下81360这个数字就能发现问题了，但我就是抱有侥幸心理。。。 4、以后要注意！ /* ID:mrxy564 PROG:runround
USACO Stamps
01-29 391
1、这是一道DP，我感觉设计好状态真的很重要，刚开始我的dp【i】是表示“能否凑成数额i”，这就要求一定要等所有面值都算完后，再从头开始搜索看哪个面值不能凑成。比如面值56凑不成，而可能的面值有2000000种，那是巨大的浪费，算法是O（K*K*maxn*N)的，会超时。 2、另一种状态是用dp【i】表示“凑成i最少需要的邮票张数”，这样只要把初始值设为INF，然后从头开始递推即可，一旦不满足要
USACO Score Inflation
01-27 387
1、完全背包问题。。。1Y，《背包九讲》真的很不错。 /* ID:mrxy564 PROG:inflate LANG:C++ */ #include #include #include using namespace std; int m,n,w[10010],c[10010],dp[10010]; void CompletePack(int w,int c){
USACO Shaping Regions
01-29 380
1、呼。。。终于过了这道，考察离散化+线段树的区间修改。因为是零基础，所以专门跑到POJ找了一道相似的题目做（POJ 2528）。。。终于写出来了~ 2、所谓离散化，就是将无限空间映射到有限区域，通俗一点讲，就是只记录边界线。本题对x和y坐标均离散化，然后枚举x点并更新（合法的）x点对应的线段树（也就是说x要在该操作所包围的范围内），接着统计每种颜色的数量。要注意setv【0】初始值应设为1（表
USACO Bessie Come Home
01-26 374
1、这道题用Dijkstra做，我居然做到一半忘了有重边，WA一次。。。 2、Bessie和Farmer John的故事真有趣~ /* ID:mrxy564 PROG:comehome LANG:C++ */ #include #include using namespace std; const int INF=~0U>>2; char s1[2],s2[2]; int
USACO 【08 Jan Gold】Cell Phone Network
11-26 371
1、我的第一道树形DP~感觉对树的定义还是不熟，题目都说得那么直白了。。。最多n-1条边，每两点有且仅有一条通路。。。不看题解根本不知道是树。 2、正好趁这道题熟悉了一下vector的用法，注意clear是不会改变元素数量的。。。 3、WA了好几次，原来是INF设得太大了（题目中涉及累加操作，容易溢出），要注意。 4、dp【i】【0】表示覆盖子树且i作为根有一个电台，dp【i】【1】表示覆盖
USACO训练题翻译全集
这份资源包含USACO训练题目全集的翻译，对于学习算法和准备参加USACO比赛的学生来说非常有价值。 章节1涵盖了基础的编程和算法概念，包括： 1.1.1 Your Ride Is Here：这道题可能涉及到时间规划或排序问题，可能是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值