矩形切割题目

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

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
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
小明有一些矩形的材料，他要从这些矩形材料中切割出一些正方形。 当他面对一块矩形材料时，他总是从中间切割一刀，切出一块最大的正方 形
Han19980124的博客
09-18 2725
小明有一些矩形的材料，他要从这些矩形材料中切割出一些正方形。 当他面对一块矩形材料时，他总是从中间切割一刀，切出一块最大的正方 形，剩下一块矩形，然后再切割剩下的矩形材料，直到全部切为正方形为止。 例如，对于一块两边分别为 5 和 3 的材料（记为 5 × 3），小明会依次切出 3 × 3、2 × 2、1 × 1、1 × 1 共 4 个正方形。 现在小明有一块矩形的材料，两边长分别是 2019 和 324。请问小明最终会切出多少个正方形？ 【答案提交】 这是一道结果填空的题，你只需要算出结果后提交即可。本题
矩形切割
MADNESS
01-11 1511
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 286
【问题描述】 小明有一些矩形的材料，他要从这些矩形材料中切割出一些正方形。 当他面对一块矩形材料时，他总是从中间切割一刀，切出一块最大的正方形，剩下一块矩形，然后再切割剩下的矩形材料，直到全部切为正方形为止。 例如，对于一块两边分别为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）进行图形绘制时。...
2024年五一赛A钢板最优切割路径问题的研究word版-一等奖
最新发布
05-31
此外，还需要使用图论模型中的欧拉回路理论来指导切割顺序，即先切割内部矩形件，再切割外部矩形件。这种方法有助于减少切割机的重复移动，从而降低空程距离。 最终，根据N4的参数，计算得出的最短空程为36.56单位...
线切割考试题分享.pdf
01-04
8. **快走丝线切割常用波形**：快走丝线切割通常采用矩形波形进行加工。 9. **电极材料**：电火花型腔加工的电极材料常见为纯铜和石墨。 10. **电火花成形加工原理**：这种加工方法是通过将电极形状复制到工件上来...
ai认证考试题目2.pdf
12-20
11. 恢复矩形选择框：执行“图形 > 变换 > 恢复矩形选择框”命令可以将旋转后的矩形选择框恢复到水平状态。 12. 图形混合：多个图形进行混合操作时，它们不一定都是封闭图形。选择所有图形后执行“图形 > 混合 > ...
数控线切割操作工应知考核试题与参考答案.doc
09-28
- 快走丝线切割常采用矩形波作为加工波形。 - 加工速度是电火花线切割加工中不稳定的参数之一。 - 线切割机床的照明灯工作电压通常是36V。 - 在线切割开始时，电极丝应沿远离夹具的方向进行加工，以避免影响加工...
矩形切割，用的是递归算法。
06-16
矩形切割,c++实现，主要是通过递归实现。且程序支持绘图过程，值得看看。
对矩形切割的分析，自己觉得挺实用
05-31
自己觉得挺实用，就贴上来了------------------
第十二届蓝桥杯大赛(Python组)——样题1：矩形切割（结果填空题）
少年龙龙的博客
04-15 984
【问题描述】   小明有一些矩形的材料，他要从这些矩形材料中切割出一些正方形。   当他面对一块矩形材料时，他总是从中间切割一刀，切出一块最大的正方形，剩下一块矩形，然后再切割剩下的矩形材料，直到全部切为正方形为止。例如，对于一块两边分别为 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 778
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 387
【代码】矩形切割方法。
蓝桥杯：矩形切割
weixin_62305124的博客
01-16 1396
矩形的切割要求切完之后所有的都只剩下正方形（这个正方形无论大小），那么就很好解决了，递归最后终止的时候只需要让最后一块长等于宽就OK，停止递归就可以了。然后主体部分判断两边的大小关系，能截出正方形的一定是短边，那就找出较长的那一条边，截掉以较短边为正方形的长度之后作为新的长度代入递归函数中进行下一轮调用即可。 ...
sgu 177 Square 矩形切割
Broken Wings
01-24 1168
n*n的矩形，由1*1的单位方格构成，先可以对其中的子矩形染色(黑或白)，染色完成后，有多少个白色单位方格？第一次做这种题，第一眼看上去感觉应该是二维线段树....后来在网上查了查这类覆盖，统计的问题可以用矩形切割来写，果断学习到了新的姿势...大致思路就是倒着扫描每个矩形，处理每个矩形时，向后遍历判断后面的矩形是否与其重叠，重叠的话就分割冲若干种小的矩形继续处理，直到最后统计没有被覆盖的面积..
矩形分割（二分） ，北京大学ACM/ICPC竞赛训练暑假课
SYITwin的博客
08-09 516
总时间限制:  1000ms   内存限制:  65536kB 描述 平面上有一个大矩形，其左下角坐标（0，0），右上角坐标（R,R)。大矩形内部包含一些小矩形，小矩形都平行于坐标轴且互不重叠。所有矩形的顶点都是整点。要求画一根平行于y轴的直线x=k（k是整数) ，使得这些小矩形落在直线左边的面积必须大于等于落在右边的面积，且两边面积之差最小。并且，要使得大矩形在直线左边的的面积尽可能...
c语言将矩形分成多个小正方形,蓝桥杯练习算法题（矩形切割成正方形）
06-03
接下来，我们可以用一个循环来不断地将这个新的矩形切割成正方形，每次切割的大小都是矩形较小的一边。如果切割后还剩下一个矩形，我们可以将它的长和宽再次除以最大公约数，得到一个新的矩形，然后继续切割。 最后...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值