NYOJ-16 矩形嵌套

NYOJ-16 矩形嵌套

思路：将所有矩形按一定的次序排序，比如，排在前面的肯定不能嵌套后面的（排后面的不一定能嵌套前面的），然后，可以看见主要功能函数是递归的，而且很多节点是递归了多次的，这个时候，就可以考虑第一次递归时打上标记，在之后，就不用往下递归，直接返回值就OK拉#^_^#

代码如下：

import java.util.Arrays;
import java.util.Scanner;

public class Main {

static class Node implements Comparable<Node>{
int a;
int b;
int value;
public Node(int a, int b) {
this.a=a;
this.b=b;
value=-1;
}
//最开始的比较我用的a*b，后来发现这样
//计算更少，起到的作用一样
@Override
public int compareTo(Node o) {
if(a>o.a)
return 1;
else if(a==o.a&&b>o.b)
return 1;
else
return -1;
}
boolean compatible(Node o){
return this.a<o.a&&this.b<o.b;
}
}

public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
for(int i=0;i<n;++i){
int m=sc.nextInt();
int tempa, tempb, t;
Node[] nodes=new Node[m];
for(int j=0;j<m;++j){
tempa=sc.nextInt();
tempb=sc.nextInt();
if(tempb>tempa){
t=tempb;
tempb=tempa;
tempa=t;
}
nodes[j]=new Node(tempa, tempb);
}
Arrays.sort(nodes);
int max, count;
max=count=0;
for(int j=0;j<m;++j){
count=f(nodes, j, m);
if(max<count)
max=count;
//排在nodes[j]后面的都不到max
//得到的f肯定不会大于max了，，
if(max+j>m)
break;
}
System.out.println(max+1);
}
sc.close();
}

//f计算的是nodes[j]后面还能排多少个矩形
private static int f(Node[] nodes, int j, int m) {
if(nodes[j].value!=-1)
return nodes[j].value;
int max=0;
int temp;
for(int i=j+1;i<m;++i){
if(nodes[j].compatible(nodes[i])){
temp=1+f(nodes, i, m);
if(temp>max)
max=temp;
}
}
nodes[j].value=max;
return max;
}
}