URAL - 1078 Segments

URAL - 1078 

题目大意：有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;
}

View Code

 

转载于:https://www.cnblogs.com/CJLHY/p/7354448.html