NYOJ-16 矩形嵌套

矩形嵌套

时间限制： 3000 ms  |  内存限制： 65535 KB

难度： 4

描述

有n个矩形，每个矩形可以用a,b来描述，表示长和宽。矩形X(a,b)可以嵌套在矩形Y(c,d)中当且仅当a<c,b<d或者b<c,a<d（相当于旋转X90度）。例如（1,5）可以嵌套在（6,2）内，但不能嵌套在（3,4）中。你的任务是选出尽可能多的矩形排成一行，使得除最后一个外，每一个矩形都可以嵌套在下一个矩形内。

输入

第一行是一个正正数N(0<N<10)，表示测试数据组数，
每组测试数据的第一行是一个正正数n，表示该组测试数据中含有矩形的个数(n<=1000)
随后的n行，每行有两个数a,b(0<a,b<100)，表示矩形的长和宽

输出

每组测试数据都输出一个数，表示最多符合条件的矩形数目，每组输出占一行

解题思路一：动态规划

Max 表示最多可嵌套的矩形数目

Max（矩形1。。矩形n）＝max（Max（矩形1）、Max（矩形2）。。Max（矩形n））

Max（矩形n）＝ max（ Max（矩形a）、Max（矩形b）。。Max（矩形c））＋1 ； max的括号里的矩形a、b、c 代表可嵌套于矩形n的所有矩形

边界：矩形m  只有本身 没有其他矩形可嵌套于它 时 Max（矩形m）＝1

根据 递推方式 计算出 每个矩形的最多可嵌套的矩形数目 

 


//
//  main.cpp
//  NYLG-16 矩形嵌套
//  动态规划：矩形n 可嵌套数目＝ Max（矩形a、矩形b。。）＋1 括号里的矩形a、b 是指可嵌套在矩形n的
//  Created by H@L on 14-6－30.
//  Copyright (c) 2014年 Hzw. All rights reserved.
//


#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

class Rectangle
{
public:
    Rectangle(){
        m_iLength = 0;
        m_iWidth = 0;
        m_iNum = 1;
    }
    ~Rectangle(){};
    bool ifNest(Rectangle &in_data);
public:
    int m_iLength;
    int m_iWidth;
    int m_iNum; //记录内可以嵌套数目包含本身
};


bool Rectangle::ifNest(Rectangle &in_data)
{
    if(in_data.m_iLength < this->m_iLength && in_data.m_iWidth < this->m_iWidth)
        return true;
    else
        return false;
};

bool compare_less (const Rectangle &data1,const Rectangle & data2)
{
    if (data1.m_iLength < data2.m_iLength) {
        return true;
    }
    if (data1.m_iLength == data2.m_iLength && data1.m_iWidth < data2.m_iWidth) {
        return true;
    }
    return false;
}

int main()
{
    int n;
	cin>>n;
	while(n--)
	{
        int m;
        vector<Rectangle> vBuf;
        vBuf.clear();
        cin >> m;
        while (m--) {
            Rectangle data;
            cin >> data.m_iLength >> data.m_iWidth;
            if (data.m_iWidth > data.m_iLength) {
                swap(data.m_iLength, data.m_iWidth);
            }
            vBuf.push_back(data);
        }
        sort(vBuf.begin(), vBuf.end(),compare_less);
        
        int iMax_s = 0; //全局最大
        int iMax = 0; //i可嵌套里的矩形的m_iNum最大值
        for (int i= 0; i < vBuf.size(); i++)
        {
            iMax = 0;
            for (int j=i-1; j >= 0;  j--) {
                if(vBuf[i].ifNest(vBuf[j]) && vBuf[j].m_iNum > iMax)
                    iMax = vBuf[j].m_iNum;
            }
            vBuf[i].m_iNum += iMax;
            if(vBuf[i].m_iNum > iMax_s)
                iMax_s = vBuf[i].m_iNum;
        }
        cout << iMax_s << endl;
    }
	return 0;
}

解题思路二：构造最长递增（减）序列（含有点贪心算法）

注意排序的 顺序

 
//
//  main.cpp
//  NYLG-16 矩形嵌套
//  动态规划：构造最长单调递增或递减序列方式求个数
//  Created by H@L on 14-6－30.
//  Copyright (c) 2014年 Hzw. All rights reserved.
//


#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

class Rectangle
{
public:
    Rectangle(){
        m_iLength = 0;
        m_iWidth = 0;
        m_iNum = 1;
    }
    ~Rectangle(){};
public:
    int m_iLength;
    int m_iWidth;
    int m_iNum; //记录内可以嵌套数目包含本身
};


bool Rectangle_equal(const Rectangle &data1,const Rectangle &data2)
{
    if(data1.m_iLength == data2.m_iLength && data1.m_iWidth == data2.m_iWidth)
        return true;
    else
        return false;
};

bool compare_less (const Rectangle &data1,const Rectangle & data2)
{
    if (data1.m_iLength < data2.m_iLength) {
        return true;
    }
    if (data1.m_iLength == data2.m_iLength && data1.m_iWidth > data2.m_iWidth) {
        return true;
    }
    return false;
}

int main()
{
    int n;
	cin>>n;
	while(n--)
	{
        int m;
        vector<Rectangle> vBuf;
        vBuf.clear();
        cin >> m;
        while (m--) {
            Rectangle data;
            cin >> data.m_iLength >> data.m_iWidth;
            if (data.m_iWidth > data.m_iLength) {
                swap(data.m_iLength, data.m_iWidth);
            }
            vBuf.push_back(data);
        }
        sort(vBuf.begin(), vBuf.end(),compare_less);
        //删除重复的矩形 大小一样的矩形只需要1个
        vBuf.erase(unique(vBuf.begin(), vBuf.end(), Rectangle_equal),vBuf.end());
        vector<int> vLenth; //只用来求个数，最终里面的元素不一定是最长系列的元素
        vLenth.push_back(0); // 构造一个假设的矩形 长度、宽为0 这样任何矩形都可以包含它
        for (int i= 0; i < vBuf.size(); i++)
        {
            for (int j = vLenth.size()-1; j>=0; j--) {
                if (vBuf[i].m_iWidth > vLenth[j])
                {
                    if (j+1 == vLenth.size())
                        vLenth.push_back(vBuf[i].m_iWidth);
                    else
                        vLenth[j+1] =vBuf[i].m_iWidth;
                    break;
                   
                }
            }
        }
        cout << vLenth.size() - 1 << endl;
    }
	return 0;
}