H
题目链接
参考博客
题意：给你20w条线段，问你选其中若干条两两不相互覆盖的线段，最多能覆盖1-n这个区间中多少个点。
思路：
　　把所有线段的两个端点，离散化。用新的格式保存：线段右端点作为一个集合，把左端点都压进去。然后枚举线段右端点，更新dp。
　　dp[i]：前i个点最多能覆盖多少。
mycode：

#include<bits/stdc++.h>
using namespace std;
const int maxn = 3e6+12217;
struct node
{
    long long l,r;
    bool operator<(const node&a)const
    {
        if(r==a.r)return l<a.l;
        else return r<a.r;
    }
}a[maxn];
int cmp(node a,node b)
{
    if(a.r<b.l)return 1;
    else return 0;
}
long long  dp[maxn];
long long  uu[maxn];
int ans;
void erfen(int l,int r,long long val)
{
    if(l>r)return;
    int mid = (l+r)>>1;
    if(a[mid].r<val)
    {
        ans= mid;
        erfen(mid+1,r,val);
    }
    else
        erfen(l,mid-1,val);
}
int main()
{
    long long n,k;
    cin>>n>>k;
    for(int i=1;i<=k;i++)
    {
        cin>>a[i].l>>a[i].r;

    }
    memset(dp,0,sizeof dp);
    sort(a+1,a+1+k);

   for(int i=1;i<=k;i++)uu[i] = a[i].r;
    for(int i=1;i<=k;i++)
    {
     // ans = -1;
     // erfen(1,i,a[i].l);
      // int h = lower_bound(uu+1,uu+i,a[i].l)-uu-1;
        int h = lower_bound(a+1,a+i,a[i],cmp)-a-1;

  // cout<<ans<<endl;
        if(h==0)
        {
            dp[i] =max(dp[i-1],a[i].r-a[i].l+1);
        }
        else
        {
            dp[i] = max(dp[i-1],a[i].r-a[i].l+1+dp[h]);
       }
    }
    cout<<n-dp[k]<<endl;
    return 0;
}

记录一下离散化写法

#pragma comment(linker, "/STACK:1024000000,1024000000")
struct Node{
  LL l, r;
  bool operator < (const Node &p) const{
    return l < p.l || l == p.l && r < p.r;
  }
};
map<LL, int> mp;
Node a[maxn];
vector<LL> v;
LL dp[maxn<<1];

int main(){
  LL n;
  scanf("%I64d %d", &n, &m);
  for(int i = 0; i < m; ++i){
    scanf("%I64d %I64d", &a[i].l, &a[i].r);
    ++a[i].r;
    v.pb(a[i].l);  v.pb(a[i].r);
  }

  sort(a, a + m);
  sort(v.begin(), v.end());
  v.erase(unique(v.begin(), v.end()), v.end());
  for(int i = 0; i < v.sz; ++i)  mp[v[i]] = i;
  int idx = 0;
  LL ans = 0;

  for(int i = 0; i < v.sz; ++i){
    dp[i+1] = max(dp[i+1], dp[i]);
    while(idx < m && mp[a[idx].l] == i){
      int r = mp[a[idx].r];
      dp[r] = max(dp[r], dp[i] + a[idx].r - a[idx].l);
      ++idx;
    }
    ans = max(ans, dp[i]);
  }

  printf("%I64d\n", n - ans);
  return 0;
}