【UVA103】Stacking Boxes(LIS输出路径)

Stacking Boxes

Time Limit:3000MS     Memory Limit:0KB     64bit IO Format:%lld
& %llu

Submit Status Practice UVA
103

Appoint description: 
System Crawler  (2015-07-19)

Description

Background

Some concepts in Mathematics and Computer Science are simple in one or two dimensions but become more complex when extended to arbitrary dimensions. Consider solving differential equations in several dimensions
and analyzing the topology of an n-dimensional hypercube. The former is much more complicated than its one dimensional relative while the latter bears a remarkable resemblance to its ``lower-class‘‘ cousin.

The Problem

Consider an n-dimensional ``box‘‘ given by its dimensions. In two dimensions the box (2,3) might represent a box with length 2 units and width 3 units. In three dimensions the box (4,8,9) can represent
a box  (length, width, and height). In 6 dimensions it is, perhaps, unclear what the box (4,5,6,7,8,9) represents;
but we can analyze properties of the box such as the sum of its dimensions.

In this problem you will analyze a property of a group of n-dimensional boxes. You are to determine the longest nesting string of boxes, that is a sequence of boxes  such
that each box  nests in box  (  .

A box D = (  ) nests in a box E = (  )
if there is some rearrangement of the  such that when rearranged each dimension is less than the corresponding
dimension in box E. This loosely corresponds to turning box D to see if it will fit in box E. However, since any rearrangement suffices, box D can be contorted, not just turned (see examples below).

For example, the box D = (2,6) nests in the box E = (7,3) since D can be rearranged as (6,2) so that each dimension is less than the corresponding dimension in E. The box D = (9,5,7,3) does NOT nest in the box
E = (2,10,6,8) since no rearrangement of D results in a box that satisfies the nesting property, but F = (9,5,7,1) does nest in box E since F can be rearranged as (1,9,5,7) which nests in E.

Formally, we define nesting as follows: box D = (  ) nests in
box E = (  ) if there is a permutation  of such
that (  ) ``fits‘‘ in (  )
i.e., if  for all  .

The Input

The input consists of a series of box sequences. Each box sequence begins with a line consisting of the the number of boxes k in the sequence followed by the dimensionality of the boxes, n (on
the same line.)

This line is followed by k lines, one line per box with the n measurements of each box on one line separated by one or more spaces. The  line
in the sequence (  ) gives the measurements for the  box.

There may be several box sequences in the input file. Your program should process all of them and determine, for each sequence, which of the k boxes determine the longest nesting string and the length
of that nesting string (the number of boxes in the string).

In this problem the maximum dimensionality is 10 and the minimum dimensionality is 1. The maximum number of boxes in a sequence is 30.

The Output

For each box sequence in the input file, output the length of the longest nesting string on one line followed on the next line by a list of the boxes that comprise this string in order. The ``smallest‘‘ or ``innermost‘‘
box of the nesting string should be listed first, the next box (if there is one) should be listed second, etc.

The boxes should be numbered according to the order in which they appeared in the input file (first box is box 1, etc.).

If there is more than one longest nesting string then any one of them can be output.

Sample Input

5 2
3 7
8 10
5 2
9 11
21 18
8 6
5 2 20 1 30 10
23 15 7 9 11 3
40 50 34 24 14 4
9 10 11 12 13 14
31 4 18 8 27 17
44 32 13 19 41 19
1 2 3 4 5 6
80 37 47 18 21 9

Sample Output

5
3 1 2 4 5
4
7 2 5 6

多边形嵌套 不过除了要求输出最多嵌套多少个之外 还要输出嵌套的是哪一个多边形 LIS输出路径也就是

就是LIS 用一个是s数组来存放上升子序列的上一个 最后用递归 逆序输出

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int maxn = 55;
int dp[maxn], s[maxn];
struct Node{
    int index;
    int an[12];
}arr[maxn];
int n, k;

bool cmp(Node c, Node d);
bool judge(int i, int j);
void dfs(int i);

int main(){
    while(scanf("%d%d", &k, &n) != EOF){
        for(int i = 0; i < k; ++i){
            for(int j = 0; j < n; ++j){
                scanf("%d", &arr[i].an[j]);
            }
            arr[i].index = i+1;
            sort(arr[i].an, arr[i].an+n);
            dp[i] = 1;
            s[i] = 1;
        }

        sort(arr, arr+k, cmp);
        s[0] = 0;
        int ans = 1;
        int pos = 0;
        for(int i = 1; i < k; ++i){
            for(int j = 0; j < i; ++j){
                if(judge(j, i) && dp[i] < dp[j] + 1){
                    dp[i] = dp[j] + 1;
                    s[i] = j;
                }
            }
            if(ans < dp[i]){
                ans = dp[i];
                pos = i;
            }
        }

        printf("%d\n", ans);
        dfs(pos);
        puts("");
    }
    return 0;
}

bool cmp(Node c, Node d){
    for(int i = 0; i < n; ++i){
        if(c.an[i] > d.an[i]){
            return false;
        }
    }
    return true;
}

bool judge(int i, int j){
    for(int t = 0; t < n; ++t){
        if(arr[i].an[t] >= arr[j].an[t]){
            return false;
        }
    }
    return true;
}

void dfs(int i){
    if(s[i] != i){
        dfs(s[i]);
    }
    printf("%d ", arr[i].index);
}

版权声明:本文为博主原创文章,未经博主允许不得转载。

时间: 2024-11-08 05:24:27

【UVA103】Stacking Boxes(LIS输出路径)的相关文章

UVa 103 - Stacking Boxes (LIS,打印路径)

链接:UVa 103 题意:给n维图形,它们的边长是{d1,d2,d3...dn},  对于两个n维图形,求满足其中一个的所有边长 按照任意顺序都一一对应小于另一个的边长,这样的最长序列的个数,并且打印任意一个最长子串的路径, 例如:a(9,5,7,3),b(6,10,8,2),c(9,7,5,1),a和b不满足,但c和b满足 分析:首先对没组边长从小到大排序,再对各组图形按最小边排序,再求最大子串, 对于打印路径,可以逆序循环,也可递归求解 #include<cstdio> #include

uva103 - Stacking Boxes(DAG)

题目:uva103 - Stacking Boxes(DAG) 题目大意:给出N个boxes, 并且给出这些箱子的维度,要求找一个最长的序列,能够使得下面的箱子一定能够有个维度序列大于上面的那个箱子的维度序列.例如:A箱子(2 3 4),B箱子(3 4 5),因为有个序列2 3 4 , 3 4 5使得B每个维度的值都大于A,所以A可以在B上面 . 解题思路:DAG.将这些箱子哪个能在哪个上面处理出有向图出来,这里判断是否可以在上面的情况,只要将这两个箱子的维度都从小到大排下序,然后比较一下是否对

uva 103 Stacking Boxes(最长上升子序列)

Description  Stacking Boxes  Background Some concepts in Mathematics and Computer Science are simple in one or two dimensions but become more complex when extended to arbitrary dimensions. Consider solving differential equations in several dimensions

UVa 103 Stacking Boxes --- DAG上的动态规划

UVa 103 题目大意:给定n个箱子,每个箱子有m个维度, 一个箱子可以嵌套在另一个箱子中当且仅当该箱子的所有的维度大小全部小于另一个箱子的相应维度, (注意箱子可以旋转,即箱子维度可以互换),求最多能套几个箱子. 第一行输入为n,m,之后是n行m维的箱子 解题思路:嵌套关系是二元关系,因此这题即在DAG上做动态规划, 只不过将二维的判断改成了n维,其他不变. 详细看考:DAG上的动态规划之嵌套矩形  (ps:这题可以理解成嵌套m边形) /* UVa 103 Stacking Boxes --

uva 103 Stacking Boxes (DAG)

uva 103 Stacking Boxes Background Some concepts in Mathematics and Computer Science are simple in one or two dimensions but become more complex when extended to arbitrary dimensions. Consider solving differential equations in several dimensions and a

UVA - 103 - Stacking Boxes (动态规划)

UVA - 103 Stacking Boxes Time Limit: 3000MS   Memory Limit: Unknown   64bit IO Format: %lld & %llu Submit Status Description Background Some concepts in Mathematics and Computer Science are simple in one or two dimensions but become more complex when

MapReduce 编程 系列八 根据输入路径产生输出路径和清除HDFS目录

有了前面的MultipleOutputs的使用经验,就可以将HDFS输入目录的路径解析出来,组成输出路径,这在业务上是十分常用的.这样其实是没有多文件名输出,仅仅是调用了MultipleOutputs的addNamedOutput方法一次,设置文件名为result. 同时为了保证计算的可重入性,每次都需要将已经存在的输出目录删除. 先看pom.xml, 现在参数只有一个输入目录了,输出目录会在该路径后面自动加上/output. <project xmlns="http://maven.ap

vc下DLL项目设置dll和lib库输出路径以及使用lib/dll库时的包含路径

include 头文件包含路径设置: project->setting->C/C++->常规: Additional include directories(附加包含目录): ../../include等等 链接文件输出目录:    project->setting->配置属性->常规:输出目录 例如:输出目录:$(SolutionDir)Temp\Link\$(ProjectName)\$(ConfigurationName) 解释:项目目录-Temp-Link-工程

HD1385Minimum Transport Cost(Floyd + 输出路径)

Minimum Transport Cost Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)Total Submission(s): 9109    Accepted Submission(s): 2405 Problem Description These are N cities in Spring country. Between each pair of cities