題目大意：有n條線段，一個線段a 完全覆蓋另一個線段b 當且僅當，a.l < b.l && a.r>b.r。問你

一個線段覆蓋一個線段再覆蓋一個線段再.......，問你最多幾個線段屬於這種關系，並打印出路徑。

這題的的 n 太小了，n^3的方法都能過。

思路：1. 我們設dp[ i ] 為 以 i 位最外層的答案為多少，n^3的方法是，我們先將所有dp的值設為1，

枚舉最外層的點，再枚舉其內層的點更新，一次更新肯定是不夠的，我們更新到它沒有更新了再

退出，感覺和最短路的貝爾曼算法相似，這種方法顯然復雜度很高。

2.第一種方法中我們顯然是無腦地枚舉邊，怎麽才能減少不必要的操作呢。我們將邊按左端點的

大小排序，然後從後往前枚舉最外層的點，因為是按左端點排序的而且是從後往前枚舉，所以能

被當前點包含的肯定在該點的後面，這樣我們每次更新當前點之後，當前點的dp值肯定是最優值，

這樣我們就將復雜度降到了n^2。（雖然我排了序，但我是傻逼從前往後枚舉，雖然優化了一點，還是n^3）

3.這是一個學姐的方法，也是復雜度應該也是n^2，我們將每條線段都看成一個點，然後如果一條

線段能包含另一條線段，我們就在他們之間連一條有向邊。那麽我們就從各個點出發，看每個點

到最深處的路徑長度是多少，顯然也能用記憶化搜索。（這個方法我感覺好牛逼啊）

這裏貼一下第二種方法的代碼吧QAQ

#include<bits/stdc++.h>
using
 
 namespace std;
const int N=505;
int n,pre[505],dp[505];
struct node
{
    int fi,se,id;
    bool operator < (const node &t)const
    {
        return fi<t.fi;
    }
}seg[505];
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++) scanf("%d%d",&seg[i].fi,&seg[i].se),seg[i].id=pre[i]=i;
    sort(seg
 
+1,seg+n+1);
    for(int i=1;i<=n;i++) dp[i]=1;
    for(int i=n;i>=1;i--)
    {
        for(int j=i+1;j<=n;j++)
        {
            if(seg[j].fi>seg[i].fi && seg[j].se<seg[i].se && dp[i]<dp[j]+1)
            {
                dp[i]=dp[j]+1;
                pre[i]=j;
            }
        }
    }
    int mx=0,item;
    for(int i=1;i<=n;i++)
    {
        if(dp[i]>mx)
        {
            mx=dp[i];
            item=i;
        }
    }
    cout<<mx<<endl;
    vector<int> ans;
    ans.push_back(seg[item].id);
    while(item!=pre[item])
    {
        item=pre[item];
        ans.push_back(seg[item].id);
    }
    int len=ans.size();
    for(int i=len-1;i>=0;i--) printf("%d%c",ans[i],i==0 ? ‘\n‘:‘ ‘);
    return 0;
}

URAL - 1078 Segments