矩形切割题目

最新推荐文章于 2022-11-26 09:04:32 发布
最新推荐文章于 2022-11-26 09:04:32 发布
阅读量949 收藏
点赞数

hdu 3634 City Planning

题意：

给出n个矩形的左下角左边（x1,y1）以及右上角的坐标（x2,y2）以及每个矩形的单位面积所具有的的价值，求如何安排矩形的放置顺序是的总价值最大，输出总价值。

思路：
首先，这些矩形会有重叠的部分，重叠的部分肯定取val值最大的，所以我们首先按照每个矩形的val值排序，然后然后利用当前的矩形去切割前边切割出来的矩形，重叠部分肯定取当前的矩形的val计算，最后求切割出来的矩形的总价值即可。

View Code 
#include <iostream>
#include <cstdio>
#include <cmath>
#include <vector>
#include <cstring>
#include <algorithm>
#include <string>
#include <set>
#include <functional>
#include <numeric>
#include <sstream>
#include <stack>
#include <map>
#include <queue>

#define CL(arr, val)    memset(arr, val, sizeof(arr))
#define lc l,m,rt<<1
#define rc m + 1,r,rt<<1|1
#define pi acos(-1.0)
#define ll __int64
#define L(x)    (x) << 1
#define R(x)    (x) << 1 | 1
#define MID(l, r)   (l + r) >> 1
#define Min(x, y)   (x) < (y) ? (x) : (y)
#define Max(x, y)   (x) < (y) ? (y) : (x)
#define E(x)        (1 << (x))
#define iabs(x)     (x) < 0 ? -(x) : (x)
#define OUT(x)  printf("%I64d\n", x)
#define lowbit(x)   (x)&(-x)
#define Read()  freopen("din.txt", "r", stdin)
#define Write() freopen("dout.txt", "w", stdout);


#define M 30007
#define N 50007

using namespace std;

const int inf = 100000007;
const int mod = 1000000007;

struct node
{
    int p1[2],p2[2];//左下角的点，右上角的点
    int val;
}a[N],b[22];

int cmp(node a,node b)
{
    return a.val < b.val;
}
//判断是否相交
bool intersect(node a,node b)
{
    for (int i = 0; i < 2; ++i)
    {
        if (a.p2[i] <= b.p1[i] || a.p1[i] >= b.p2[i]) return false;
    }
    return true;
}
int tot;
//用ta矩形切割tb矩形
void cut(node ta,node tb)
{
    for (int i = 0; i < 2; ++i)
    {
        int k1 = max(ta.p1[i],tb.p1[i]);
        int k2 = min(ta.p2[i],tb.p2[i]);

        if (tb.p1[i] < k1)
        {
            a[++tot] = tb;
            a[tot].p2[i] = k1;
        }
        if (tb.p2[i] > k2)
        {
            a[++tot] = tb;
            a[tot].p1[i] = k2;
        }
        tb.p1[i] = k1; tb.p2[i] = k2;
    }
}
int main()
{
    int T,i,j;
    int cas = 1;
    int n;
    scanf("%d",&T);
    while (T--)
    {
        scanf("%d",&n);
        for (i = 1; i <= n; ++i)
        {
            scanf("%d%d%d%d%d",&b[i].p1[0],&b[i].p1[1],&b[i].p2[0],&b[i].p2[1],&b[i].val);
        }
        sort(b + 1, b + 1 + n,cmp);
        tot = 0;
        for (i = 1; i <= n; ++i)
        {
            for (j = tot; j >= 1; --j)
            {
                if (intersect(b[i],a[j]))
                {
                    cut(b[i],a[j]);
                    a[j] = a[tot--];//覆盖掉原来切割后的矩形
                }
            }
            //将最后的矩形放进来
            a[++tot] = b[i];
        }
        ll sum = 0;
        for (i = 1; i <= tot; ++i)
        {
//            printf("%d %d\n",i,a[i].val);
            sum += (ll)a[i].val*(a[i].p2[0] - a[i].p1[0])*(a[i].p2[1] - a[i].p1[1]);
        }
        printf("Case %d: %I64d\n",cas++,sum);
    }
    return 0;
}

 

 pku 2528 Mayor's posters

经典的贴海报的那个离散化+线段树的题目， 不过这里可以用矩形切割（这里是线段切割）来做，这里到了（10^8*T）不过可能后台数据比较弱，竟然也能过。

根据当前线段切割之前切出来的线段，然后求解即可。

View Code 
#include <iostream>
#include <cstdio>
#include <cmath>
#include <vector>
#include <cstring>
#include <algorithm>
#include <string>
#include <set>
#include <functional>
#include <numeric>
#include <sstream>
#include <stack>
#include <map>
#include <queue>

#define CL(arr, val)    memset(arr, val, sizeof(arr))
#define lc l,m,rt<<1
#define rc m + 1,r,rt<<1|1
#define pi acos(-1.0)
#define ll __int64
#define L(x)    (x) << 1
#define R(x)    (x) << 1 | 1
#define MID(l, r)   (l + r) >> 1
#define Min(x, y)   (x) < (y) ? (x) : (y)
#define Max(x, y)   (x) < (y) ? (y) : (x)
#define E(x)        (1 << (x))
#define iabs(x)     (x) < 0 ? -(x) : (x)
#define OUT(x)  printf("%I64d\n", x)
#define lowbit(x)   (x)&(-x)
#define Read()  freopen("din.txt", "r", stdin)
#define Write() freopen("dout.txt", "w", stdout);


#define M 30007
#define N 1000007

using namespace std;

const int inf = 100000007;
const int mod = 1000000007;

struct node
{
    int p1,p2;
    int col;
}a,b[N];
bool vt[10007];
int tot;

bool intersect(node a,node b)
{
    if (a.p2 < b.p1 || a.p1 > b.p2) return false;
    return true;
}
void cut(node ta,node tb)
{
    int k1 = max(ta.p1,tb.p1);
    int k2 = min(ta.p2,tb.p2);
    if (tb.p1 < k1)
    {
        b[++tot] = tb;
        b[tot].p2 = k1 - 1;
    }
    if (tb.p2 > k2)
    {
        b[++tot] = tb;
        b[tot].p1 = k2 + 1;
    }
}
int cmp(node a,node b)
{
    return a.col < b.col;
}
int main()
{
    int T,i,j;
    int n;
    scanf("%d",&T);
    while (T--)
    {
        scanf("%d",&n);
        tot = 0;
        for (i = 1; i <= n; ++i)
        {
            scanf("%d%d",&a.p1,&a.p2);
            a.col = i;
            for (j = tot; j >= 1; --j)
            {
                if (intersect(a,b[j]))
                {
                    cut(a,b[j]);
                    b[j] = b[tot--];
                }
            }
            b[++tot] = a;
        }
//        sort(b + 1,b + 1 + tot,cmp);
        int ans = 0;
        CL(vt,false);
        for (i = 1; i <= tot; ++i)
        {
            if (!vt[b[i].col])
            {
                ans++; vt[b[i].col] = true;
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}

 

 pku 1151 Atlantis

 同样是经典的线段树求矩形面积并的题目，这里用矩形切割的话，代码量很短。

同时注意精度的处理，同时还要理解一个问题，当我们给出左上角和右下角的坐标是我们是按照左上角为(0,0)建立的坐标系，如果给出左下角和右上角的时候是按照左下角为(0,0)建立的图，所以我们的for循环处理判断相交是都是对的。

View Code 
#include <iostream>
#include <cstdio>
#include <cmath>
#include <vector>
#include <cstring>
#include <algorithm>
#include <string>
#include <set>
#include <functional>
#include <numeric>
#include <sstream>
#include <stack>
#include <map>
#include <queue>

#define CL(arr, val)    memset(arr, val, sizeof(arr))
#define lc l,m,rt<<1
#define rc m + 1,r,rt<<1|1
#define pi acos(-1.0)
#define ll __int64
#define L(x)    (x) << 1
#define R(x)    (x) << 1 | 1
#define MID(l, r)   (l + r) >> 1
#define Min(x, y)   (x) < (y) ? (x) : (y)
#define Max(x, y)   (x) < (y) ? (y) : (x)
#define E(x)        (1 << (x))
#define iabs(x)     (x) < 0 ? -(x) : (x)
#define OUT(x)  printf("%I64d\n", x)
#define lowbit(x)   (x)&(-x)
#define Read()  freopen("din.txt", "r", stdin)
#define Write() freopen("dout.txt", "w", stdout);


#define M 30007
#define N 107

using namespace std;

const int inf = 100000007;
const int mod = 1000000007;
const double eps = 1e-6;

struct node
{
    double p1[2],p2[2];
}a,b[N*N];
int tot;

int dblcmp(double x)
{
    if (x > eps) return 1;
    else if (x < -eps) return -1;
    else return 0;
}
bool intersect(node ta,node tb)
{
    for (int i = 0; i < 2; ++i)
    {
        if (dblcmp(ta.p2[i] - tb.p1[i]) <= 0 || dblcmp(ta.p1[i] - tb.p2[i]) >= 0) return false;
    }
    return true;
}
void cut(node ta,node tb)
{
    for (int i = 0; i < 2; ++i)
    {
        int k1 = max(ta.p1[i],tb.p1[i]);
        int k2 = min(ta.p2[i],tb.p2[i]);

        if (dblcmp(tb.p1[i] - k1) < 0)
        {
            b[++tot] = tb;
            b[tot].p2[i] = k1;
        }
        if (dblcmp(tb.p2[i] - k2) > 0)
        {
            b[++tot] = tb;
            b[tot].p1[i] = k2;
        }
        tb.p1[i] = k1;
        tb.p2[i] = k2;
    }
}
int main()
{
    int n,i,j;
    int cas = 1;
    while (~scanf("%d",&n))
    {
        if (!n) break;
        tot = 0;
        for (i = 1; i <= n; ++i)
        {
            scanf("%lf%lf%lf%lf",&a.p1[0],&a.p1[1],&a.p2[0],&a.p2[1]);
            for (j = tot; j >= 1; --j)
            {
                if (intersect(a,b[j]))
                {
                    cut(a,b[j]);
                    b[j] = b[tot--];
                }
            }
            b[++tot] = a;
        }
        double sum = 0;
        for (i = 1; i <= tot; ++i)
        {
            sum += (b[i].p2[0] - b[i].p1[0])*(b[i].p2[1] - b[i].p1[1]);
        }
        printf("Test case #%d\n",cas++);
        printf("Total explored area: %.2lf\n\n",sum);
    }
    return 0;
}

 

pku 3277 City Horizon

题意：

给出n个矩形的最下边一条边在x轴上的坐标以及该矩形的高度，求n个矩形面积的并。

思路：

n很大，觉得矩形切割肯定会超时，怎么会分到矩形切割呢。于是就将给出的矩形转化成左下角坐标和右上角坐标，求解。结果真的tle了。后来看了看解题报告， 原来按照高度排序转化成线段切割就好了。不过感觉数据量依然很大，理论上应该是会超时的可是这里可能是后台数据弱吧。

View Code 
#include <iostream>
#include <cstdio>
#include <cmath>
#include <vector>
#include <cstring>
#include <algorithm>
#include <string>
#include <set>
#include <functional>
#include <numeric>
#include <sstream>
#include <stack>
#include <map>
#include <queue>

#define CL(arr, val)    memset(arr, val, sizeof(arr))
#define lc l,m,rt<<1
#define rc m + 1,r,rt<<1|1
#define pi acos(-1.0)
#define ll long long
#define L(x)    (x) << 1
#define R(x)    (x) << 1 | 1
#define MID(l, r)   (l + r) >> 1
#define Min(x, y)   (x) < (y) ? (x) : (y)
#define Max(x, y)   (x) < (y) ? (y) : (x)
#define E(x)        (1 << (x))
#define iabs(x)     (x) < 0 ? -(x) : (x)
#define OUT(x)  printf("%I64d\n", x)
#define lowbit(x)   (x)&(-x)
#define Read()  freopen("din.txt", "r", stdin)
#define Write() freopen("dout.txt", "w", stdout);


#define M 30007
#define N 4000007

using namespace std;

const int inf = 100000007;
const int mod = 1000000007;
const double eps = 1e-6;


struct node
{
    ll p1,p2;
    ll h;
}a[N],b[N];

int tot;

int cmp(node a,node b)
{
    return a.h < b.h;
}
bool intersect(node ta,node tb)
{

    if (ta.p2 <= tb.p1 || ta.p1 >= tb.p2) return false;

    return true;
}
void cut(node ta,node tb)
{

    ll k1 = max(ta.p1,tb.p1);
    ll k2 = min(ta.p2,tb.p2);

    if (tb.p1 < k1)
    {
        b[++tot] = tb;
        b[tot].p2 = k1;
    }
    if (tb.p2 > k2)
    {
        b[++tot] = tb;
        b[tot].p1 = k2;
    }
}
int main()
{
//    Read();
    int i,j,n;
    scanf("%d",&n);
    for (i = 1; i <= n; ++i)
    {
        scanf("%I64d%I64d%I64d",&a[i].p1,&a[i].p2,&a[i].h);
    }
    sort(a + 1,a + 1 + n,cmp);

    tot = 0;
    for (i = 1; i <= n; ++i)
    {
        for (j = tot; j >= 1; --j)
        {
            if (intersect(a[i],b[j]))
            {
                cut(a[i],b[j]);
                b[j] = b[tot--];
            }
        }
        b[++tot] = a[i];
    }
    ll sum = 0;
    for (i = 1; i <= tot; ++i)
    {
        sum += (b[i].p2 - b[i].p1)*b[i].h;
    }
    cout<<sum<<endl;
    return 0;
}

 

 

weixin_34273046
关注
小明有一些矩形的材料，他要从这些矩形材料中切割出一些正方形。 当他面对一块矩形材料时，他总是从中间切割一刀，切出一块最大的正方 形
Han19980124的博客
09-18 2777
小明有一些矩形的材料，他要从这些矩形材料中切割出一些正方形。 当他面对一块矩形材料时，他总是从中间切割一刀，切出一块最大的正方 形，剩下一块矩形，然后再切割剩下的矩形材料，直到全部切为正方形为止。 例如，对于一块两边分别为 5 和 3 的材料（记为 5 × 3），小明会依次切出 3 × 3、2 × 2、1 × 1、1 × 1 共 4 个正方形。 现在小明有一块矩形的材料，两边长分别是 2019 和 324。请问小明最终会切出多少个正方形？ 【答案提交】 这是一道结果填空的题，你只需要算出结果后提交即可。本题
矩形切割
MADNESS
01-11 1546
Previous related blog: http://blog.csdn.net/lllcfr/article/details/7567045 先判断是否重叠，然后切割．注意答案要求的是哪一部分． １． 二维矩形 USACO 5-3-window #include #include #include #include #include #include #i
Java矩形切割和特殊的数之和
Fiona20的博客
04-20 309
【问题描述】 小明有一些矩形的材料，他要从这些矩形材料中切割出一些正方形。 当他面对一块矩形材料时，他总是从中间切割一刀，切出一块最大的正方形，剩下一块矩形，然后再切割剩下的矩形材料，直到全部切为正方形为止。 例如，对于一块两边分别为5和3的材料（记为5×3），小明会依次切出3×3、2×2、1×1、1×1共4个正方形。 现在小明有一块矩形的材料，两边长分别是2019和324。请问小明最终会...
矩形分割
05-29
在IT行业中，尤其是在图形用户界面（GUI）开发中，"矩形分割"是一个常见的概念，尤其是在Windows编程领域，如使用MFC（Microsoft Foundation Classes）和GDI+（Graphics Device Interface Plus）进行图形绘制时。...
蓝桥杯真题练习-矩形切割
linghuanhuayu的博客
03-16 492
蓝桥杯真题练习-矩形切割 ## 填空题 2019 省赛 题目地址 题目概述 给定一个矩形，每次切一刀，得到一个最大的正方形，最终能获得多少个正方形 思路 1.规定好长边短边变量，一个计数器，一个辅助变量 2.每次切割，得到的正方形的边长就是短边的边长，而形成的新矩形的两个边，一个是原短边边长，一个是原长边边长减去原短边边长。注意，此时可不一定哪个长，因此，需要判断一下，数大的赋值给长边变量，数小的给短边变量。 3.没了，如果感觉解释的不清楚，自己画画 #include<iostream> u
矩形分割(二分答案)
weixin_46503238的博客
04-20 2290
题目 平面上有一个大矩形，其左下角坐标 (0,0)，右上角坐标 (R,R)。大矩形内部包含一些小矩形，小矩形都平行于坐标轴且互不重叠。所有矩形的顶点都是整点。要求画一根平行于y轴的直线x=k（ k 是整数)，使得这些小矩形落在直线左边的面积必须大于等于落在右边的面积，且两边面积之差最小。并且，要使得大矩形在直线左边的的面积尽可能大。注意：若直线穿过一个小矩形，将会把它切成两个部分，分属左右两侧。 Input 第一行是整数 R，表示大矩形的右上角坐标是 (R,R)。 接下来的一行是整数 N,表示一共有
算法学习之——矩形切割思想
热门推荐
MPS的博客
11-19 1万+
算法学习之——矩形切割思想
ACM算法详解：矩形切割与竞赛策略
"矩形切割-ａｃｍ算法详解" 这篇内容主要探讨了ACM（Association for Computing Machinery）算法在矩形切割问题中的应用。ACM是计算机科学领域历史悠久且具有影响力的组织，它主办的国际大学生程序设计竞赛（ICPC）...
矩形切割，用的是递归算法。
06-16
矩形切割,c++实现，主要是通过递归实现。且程序支持绘图过程，值得看看。
第十二届蓝桥杯大赛(Python组)——样题1：矩形切割（结果填空题）
少年龙龙的博客
04-15 1065
【问题描述】   小明有一些矩形的材料，他要从这些矩形材料中切割出一些正方形。   当他面对一块矩形材料时，他总是从中间切割一刀，切出一块最大的正方形，剩下一块矩形，然后再切割剩下的矩形材料，直到全部切为正方形为止。例如，对于一块两边分别为 5 和 3 的材料（记为 5×3），小明会依次切出 3×3、2×2、1×1、1×1 共 4 个正方形。   现在小明有一块矩形的材料，两边长分别是 2019 和 324。请问小明最终会切出多少个正方形？ 【答案】 21 【代码】 x = 2019 y = 324 num
【矩形切割】Atlantis
wu_yihao的专栏
04-22 821
Atlantis Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 11113   Accepted: 4359 Description There are several ancient Greek texts that contain descriptions o
矩形切割方法
最新发布
weixin_66107154的博客
11-26 427
【代码】矩形切割方法。
蓝桥杯：矩形切割
weixin_62305124的博客
01-16 1431
矩形的切割要求切完之后所有的都只剩下正方形（这个正方形无论大小），那么就很好解决了，递归最后终止的时候只需要让最后一块长等于宽就OK，停止递归就可以了。然后主体部分判断两边的大小关系，能截出正方形的一定是短边，那就找出较长的那一条边，截掉以较短边为正方形的长度之后作为新的长度代入递归函数中进行下一轮调用即可。 ...
sgu 177 Square 矩形切割
Broken Wings
01-24 1199
n*n的矩形，由1*1的单位方格构成，先可以对其中的子矩形染色(黑或白)，染色完成后，有多少个白色单位方格？第一次做这种题，第一眼看上去感觉应该是二维线段树....后来在网上查了查这类覆盖，统计的问题可以用矩形切割来写，果断学习到了新的姿势...大致思路就是倒着扫描每个矩形，处理每个矩形时，向后遍历判断后面的矩形是否与其重叠，重叠的话就分割冲若干种小的矩形继续处理，直到最后统计没有被覆盖的面积..
矩形分割（二分） ，北京大学ACM/ICPC竞赛训练暑假课
SYITwin的博客
08-09 535
总时间限制:  1000ms   内存限制:  65536kB 描述 平面上有一个大矩形，其左下角坐标（0，0），右上角坐标（R,R)。大矩形内部包含一些小矩形，小矩形都平行于坐标轴且互不重叠。所有矩形的顶点都是整点。要求画一根平行于y轴的直线x=k（k是整数) ，使得这些小矩形落在直线左边的面积必须大于等于落在右边的面积，且两边面积之差最小。并且，要使得大矩形在直线左边的的面积尽可能...
<模板> 矩形分割
无奈滴微笑
08-13 1433
描述 N个不同的颜色的不透明的长方形(1 [编辑]格式 PROGRAM NAME: rect1 INPUT FORMAT: (file rect1.in) 按顺序输入放置长方形的方法。第一行输入的是那个放在底的长方形(即白纸)。 第 1 行: A ， B 和 N由空格分开 (1 第 2 到N+1行: 为五个整数　llx, lly, urx,
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值