矩形嵌套-DAG上的动态规划

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

分析：
矩形之间的”可嵌套”关系是一个典型的二元关系，二元关系可以用图来建模。如果矩形X可以嵌套在矩形Y里，我们就从X到Y连一条有向边。这个有向图是无环的，因为一个矩形无法直接或间接地嵌套在自己的内部。换句话说，它是一个DAG。这样，我们的任务便是求DAG上的最长路径。

import java.util.Scanner;

/**
 * Created by lion on 2017/4/25.
 */
public class DAGqiandaojuxing {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[][] G = new int[n][n]; //DAG图的矩阵表示
        int[] d = new int[n];//d[i]定点i的最长路径
        int[][] rectangles = new int[n][2];
        int c = 0;
        while (c < n){
            int max = scanner.nextInt();
            int min = scanner.nextInt();
            if (max > min){
                rectangles[c][0]= min;
                        rectangles[c++][1] = max;
            }else {
                rectangles[c][0]= max;
                rectangles[c++][1] = min;
            }
        }
        createGraph(rectangles,G,n);

        int ans=0;
        for(int i=0;iint tmp = dp(i,d,n,G);
            ans=ans>tmp?ans:tmp;
        }
        System.out.printf("%d\n",ans);

    }
    //打印出图的邻接矩阵
    public static void print_Graph(int[][] rec,int[][] G,int n){
        System.out.print("|矩 形|");
        for(int i=0;iout.printf("%2d,%2d|",rec[i][0],rec[i][1]);
        System.out.println();

        for(int i=0;ifor(int k=0;k<=n;k++)
                System.out.print("------");
            System.out.println();
            System.out.printf("|%2d,%2d|",rec[i][0],rec[i][1]);
            for(int j=0;jout.printf("  %d  |",G[i][j]);
            }
            System.out.println();
        }
    }

    //构造图
    public static void createGraph(int[][] rec, int[][] G, int n)
    {
        for(int i=0;ifor(int j=0;jif(rec[i][0]>rec[j][0] && rec[i][1]>rec[j][1]){
                    G[i][j]=1;  //rec[i] 包含 rec[j]
                }
            }
        }
        print_Graph(rec,G,n);
    }

    public static int dp(int i,int[] d,int n,int[][] G){
        if (d[i] > 0) return d[i];
        d[i] = 1;
        for (int j = 0; j < n; j++){
            if (G[i][j] > 0) { //如果可以包起来
                int tmp = dp(j,d,n,G); //获取包起来的d[j]  递归获得
                d[i] = d[i] > tmp+1?d[i]:tmp+1;  //判断 是 d[j]包起来的大，还是 d[i]一开始的大
            }
        }
        return d[i];
    }
}