一、貪心算法
原文鏈接：https://blog.csdn.net/linyuxilu/article/details/51954030
先對所有區間按末端點排序
取第i個區間的最後兩個元素x和y
若第i+1個區間包含了這兩個元素，則跳到下一個區間所取的元素個數+0
若第i+1個區間只包含了這兩個元素中的一個（由於有序，所以必定是包含y），則取第i+1個區間的最後一個元素，所取的元素個數+1。爲了方便下一區間的比較，更新x和y的值，使他們爲當前V集合中最後的兩個元素。
若第i+1個區間沒有包含這兩個元素，則第i+1個區間的最後兩個元素，所取的元素個數+2。爲了方便下一區間的比較，更新x和y的值，使他們爲當前V集合中最後的兩個元素。
元素初值初始化爲2
x初始化爲第一個區間的最後倒數第2個元素
y初始化爲第一個區間的最後的元素
#include<stdio.h>
#include<algorithm>
using namespace std;
struct F
{
int a,b;
} s[10010];
int cmp(F x,F y)
{
return x.b<y.b;
}
int main()
{
int n,i,j,x,y;
scanf("%d",&n);
for(i=0; i<n; i++)
scanf("%d%d",&s[i].a,&s[i].b);
sort(s,s+n,cmp);
j=2;
x=s[0].b-1;
y=s[0].b;
for(i=1; i<n; i++)
{
if(s[i].a<=x&&s[i].b>=y)//如果此區間包含了這兩個元素，不用再取
continue;
if(s[i].a<=y&&s[i].a>x)//如果只包含一個，肯定是y
{
x=y;
y=s[i].b;//更新x和y
j+=1;//增加一個元素
}
if(s[i].a>y)//如果不包含任意一個元素，就需要增加後兩位元素
{
x=s[i].b-1;//更新元素的值
y=s[i].b;//因爲數據是從小到大排的額，所以保存後兩位
j+=2;//元素數量加2
}
}
printf("%d\n",j);
return 0;
}
2、差分約束
原文鏈接：https://blog.csdn.net/a15110103117/article/details/52513644
對這一道題，每個區間只需要保證2個不同元素即可，我們自然可以從左到右對每個區間貪心的選擇最後兩個，然後和下一個區間進行比較，可是如果每個區間需要有n個不同元素呢？此時貪心將很難實施，參考poj 1201，更多的使用的是差分約束系統。
我們設a[0]到a[10000]，表示從0到i一共有幾個整數，比如a[0]爲1個（其中有0），a[5]爲6個（其中有0,1,2,3,4,5）。
那麼利用它們之間的關係可以有這麼幾個不等式：
1.a[y]-a[x-1]>=2.(y>x，表示[x,y]閉區間的個數)
2.a[i]-a[i+1]>=-1.
3.a[i+1]-a[i]>=0.
差分約束系統中一個比較重要的問題是，如何建圖，如果我們希望求最短路徑的話，他的鬆弛條件是
if(d[u]>d[v]+w[v,u])
d[u]=d[v]+w[v,u]
也就是說在最短路徑中，我們執行完鬆弛之後，對每個點有以下條件成立，如果恰好是最短路徑上相鄰的兩點，那麼等號成立。
觀察我們上面的不等式，如果將常數項看作兩點之間的權重，那麼對
，從向連接一條權重爲的邊，以此類推就得到了我們的圖，然後求最左的端點到最右端點+1的最短路徑即可。相反如果是用最長路做，那麼鬆弛之後就滿足
那麼對於我們將從連接一條權重爲2的邊到。這是我個人對建圖的理解。
值得注意的一點是：建立的圖可能不聯通，我們只需要加入一個超級源點，比如說求取最長路時圖不聯通的話，我們只需要加入一個點S，對其他的每個點建立一條權值爲0的邊圖就聯通了，然後從S點開始進行spfa判環。最短路類似，不過原點到其他點的權值爲inf。
如果要判斷差分約束系統是否存在解，一般都是判斷環，選擇求最短路或者最長路求解都行，只是不等式標準化時候不同，判環地話，用spfa即可，n個點中如果同一個點入隊超過n次，那麼即存在環。
/**
* 差分約束：
* 剛接觸差分約束的確很糾結。。
* 差分約束系統的題其實是研究題目的約束條件，再根據最短路在鬆弛邊的時候的固有性質來理解的。
* 就如這題，由題目意思有如下約束條件：
* dis[u]表示u-1之前所取的關鍵點的數, 對於邊(i, i+1)有
* 1、dis[i+1] - dis[i] >= 0
* 2、dis[i+1] - dis[i] <= 2;
* 對於邊(u, v)
* 3、dis[v+1] - dis[u] >= 2 // 在[u, v]區間內必須取2個點以上
*
* 清楚了這些約束條件就可以依此建圖了。
* 一開始看了好多人的題解。有求最長路的，有求最短路的，有mn爲源點的，有mx爲源點的
* 其實，求最長也好最短也好。不過是要理解實質，根據構圖的不同，和起始點的不同，最短路最長路都可以的。
* 關鍵是，怎麼把約束條件映射的圖上，也就是如何建立這個圖，如何加邊！
* 首先，可以確定，如果是用最長路做：
* 那麼在鬆弛邊(u, v)的時候是根據 先判斷 d[v] < d[u] + w ，如果成立 d[u] = d[v] + w; // w 爲邊權。
* 這樣在鬆弛完畢後就有 d[v] > d[u] + w 再看看約束條件: dis[i+1] - dis[i] >= 0
* 所以可以這樣加邊： add_edge(i, i+1, w); // 函數原型 add_edge(int u, int v, int w)
* 再看看約束條件： dis[v+1] - dis[u] >= 2 要使得鬆弛後 d[v] > d[u] + w 那麼添邊方法：add_edge(u, v+1, 2);
*/
#include <cstdio>
#include <iostream>
#include <cstring>
#include <cmath>
#include <string>
#include <queue>
#include <map>
#include <vector>
#include <algorithm>
#define DEBUG 0
#define INF 0x1fffffff
#define MAXS 10005
typedef long long LL;
using namespace std;
int n, inq[MAXS], dis[MAXS];
struct Edge
{
int v, w;
Edge(){}
Edge(int vv, int ww) {v = vv; w = ww;}
};
vector<Edge> ver[MAXS];
void dijkstra(int mx, int mn)
{
for(int i = mn; i <= mx; i ++) {
inq[i] = 0;
dis[i] = -INF;
}
queue<int> q;
inq[mn] = 1;
q.push(mn);
dis[mn] = 0;
while(!q.empty())
{
int cur = q.front(); q.pop();
inq[cur] = 0;
for(int i = 0; i < ver[cur].size(); i ++)
{
int v = ver[cur][i].v, w = ver[cur][i].w;
if(dis[v] < dis[cur] + w) {
dis[v] = dis[cur] + w;
if(!inq[v]) {
inq[v] = 1;
q.push(v);
}
}
}
}
}
int main()
{
while(~scanf("%d", &n))
{
int u, v, mx = 0, mn = INF;
for(int i = 0; i <= MAXS; i ++)
ver[i].clear();
for(int i = 0; i < n ; i ++) {
scanf("%d%d", &u, &v);
if(v + 1 > mx) mx = v + 1;
if(u < mn) mn = u;
/** 約束條件 d[v+1] - d[u] >= 2 */
ver[u].push_back(Edge(v+1, 2));
}
/** 添加其他約束條件。 */
for(int i = 0; i <= mx; i ++) {
ver[i].push_back(Edge(i+1, 0));
ver[i+1].push_back(Edge(i, -1));
}
dijkstra(mx, mn);
printf("%d\n", dis[mx]);
}
return 0;
}