codevs 线段覆盖系列

题目：
http://codevs.cn/problem/?q=%E7%BA%BF%E6%AE%B5%E8%A6%86%E7%9B%96

明确总套路：

按每条线段的右端点从小到大排序；

原因：右端点是线段的终点，可以确定线段”具体位置”，换句话说，我们需要的不是它何时开始，而是它何时结束，这样我们才可以比较前后两条线段，然后进行选择；
如果按左端点排序，会产生混乱，即我们无法挖掘所有情况；

显然选1,2比选3更优，如果按左端点排序，选的只有3；

贪心：

线1，线3 :
在”当前”答案不变的情况下，优先选右端点小的，以留给后面线段更多的空间；
所以需要按右端点从小到大sort;

DP：

线2：
定义dp[i]：以第i条线段结尾的最大价值；
像最长上升子序列那样做就行了；
注意需要边转移边记录最大值；

线4，线5：
n太大，需要O(nlogn)，考虑重新定义状态；

dp[i]:前i条线段所能形成的最大价值；
显然，这是个01背包；
考虑用二分优化；
二分：最后一个与当前直线不相交的直线的下标；
正确性：每条线段的右端点满足单调性；

dp[i]=max(dp[i-1],dp[f(i)]+ma[i].c)；

线1、3：

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

const int MAXN=2000001;
struct hh
{
    int l,r;
}ma[MAXN];
int n,tot;
bool cmp(hh a,hh b)
{
    if(a.r==b.r) return a.l>b.l;
    else return a.r<b.r;
}
void solve()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++) 
    {
        scanf("%d%d",&ma[i].l,&ma[i].r);
        if(ma[i].l>ma[i].r) swap(ma[i].l,ma[i].r);
    }
    sort(ma+1,ma+n+1,cmp);
    int y=-9999;
    for(int i=1;i<=n;i++)
    {
        if(ma[i].l>=y)
            tot++,y=ma[i].r;
    }
    cout<<tot<<endl;

}

int main()
{
    solve();
    return 0;
}

线2：

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

const int MAXN=2001;
int n,ans=-21321;
int dp[MAXN];
struct hh
{
    int l,r,c;
}ma[MAXN];

bool cmp(hh a,hh b)
{
    if(a.r==b.r) 
        return a.l>b.l;
    else 
        return a.r<b.r;
}

void solve()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%d%d%d",&ma[i].l,&ma[i].r,&ma[i].c);
        if(ma[i].l>ma[i].r) swap(ma[i].l,ma[i].r);
    }
    sort(ma+1,ma+n+1,cmp);

    for(int i=1;i<=n;i++) dp[i]=ma[i].c;
    for(int i=1;i<=n;i++)
        for(int j=1;j<i;j++)
        {
            if(ma[i].l>=ma[j].r)
                dp[i]=max(dp[j]+ma[i].c,dp[i]);
            ans=max(dp[i],ans);
        }
    cout<<ans<<'\n';
    return;
}

int main()
{
    solve();
    return 0;
}

线4，线5：

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

typedef long long ll;
const ll MAXN=2000001;
ll n;
ll dp[MAXN];
struct hh
{
    ll l,r,c;
}ma[MAXN];

bool cmp(hh a,hh b)
{
    if(a.r==b.r) return a.l>b.l;
    return a.r<b.r;
}

ll f(ll x)
{
    ll l=0,r=x;
    while(r - l > 1)
    {
        ll mid=(l+r)>>1;
        if(ma[mid].r>ma[x].l) r=mid;
        else l=mid;
    }
    return l;
}

void solve()
{
    scanf("%lld",&n);
    for(ll i=1;i<=n;i++) 
        scanf("%lld%lld%lld",&ma[i].l,&ma[i].r,&ma[i].c);
    sort(ma+1,ma+n+1,cmp);

    for(ll i=1;i<=n;i++)
        dp[i]=max(dp[i-1],dp[f(i)]+ma[i].c);
    printf("%lld\n",dp[n]);
}

int main()
{
    solve();
    return 0;
}

总结：
1.贪心正确性的证明；
2.明确状态，套DP模型;