題目描述 Description

給定實直線L 上n 個開區間組成的集合I，和一個正整數k，試設計一個演算法，從開區
間集合I 中選取出開區間集合S屬於I，使得在實直線L 的任何一點x，S 中包含點x 的開區間
個數不超過k，且sum(| z |) z屬於S，達到最大。這樣的集合S稱為開區間集合I的最長k可重區間集。
sum(| z |) z屬於S稱為最長k可重區間集的長度。

對於給定的開區間集合I和正整數k，計算開區間集合I的最長k可重區間集的長度。

輸入描述 Input Description

第1 行有2 個正整數n和k，分別表示開區間的
個數和開區間的可重迭數。接下來的n行，每行有2個整數，表示開區間的左右端點座標。

輸出描述 Output Description

將計算出的最長k可重區間集的長度輸出

樣例輸入 Sample Input

4 2
1 7
6 8
7 10
9 13

樣例輸出 Sample Output

15

資料範圍及提示 Data Size & Hint

若把每個線段看做點，一組不相交的線段集合就可以看做路徑。這樣問題就轉化為選k條路徑使得權值和最大，並且路徑不能重疊（一個線段只能選一次）。

方法1

按左端點排序所有區間，把每個區間拆分看做兩個頂點<i.a><i.b>，建立附加源S匯T，以及附加頂點S’。

1、連線S到S’一條容量為K，費用為0的有向邊。
2、從S’到每個<

求最大費用最大流，最大費用流值就是最長k可重區間集的長度。

這種方法相對與方法2來說比較好想。拆點（計算選邊的價值），容量限制（k個，以及不相交）。

方法2

離散化所有區間的端點，把每個端點看做一個頂點，建立附加源S匯T。

1、從S到頂點1（最左邊頂點）連線一條容量為K，費用為0的有向邊。
2、從頂點2N（最右邊頂點）到T連線一條容量為K，費用為0的有向邊。
3、從頂點i到頂點i+1(i+1<=2N)，連線一條容量為無窮大，費用為0的有向邊。
4、對於每個區間[a,b]，從a對應的頂點i到b對應的頂點j連線一條容量為1，費用為區間長度的有向邊。

求最大費用最大流，最大費用流值就是最長k可重區間集的長度。

轉換思路：端點為點。同樣是限制流量。而這次目標針對了【每個點至多出現k次】，而區間則成了一段有價值的點，所以可以端點之間連邊來表示。並且這個做法邊數更少，更優。

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

const int INF = 1000000010;
const int SZ = 1000010;

int head[SZ],nxt[SZ],tot = 1;

struct edge{
    int f,t,d,c;
}l[SZ];

void build(int f,int t,int d,int c)
{
    l[++ tot].t = t;
    l[tot].d = d;
    l[tot].f = f;
    l[tot].c = c;
    nxt[tot] = head[f];
    head[f] = tot;
}

void insert(int f,int t,int d,int c)
{
    build(f,t,d,c); build(t,f,0,-c);
}

int dist[SZ];
deque<int> q;
bool use[SZ];
int pre[SZ];

bool spfa(int s,int e)
{
    use[s] = 1;
    q.push_front(s);
    for(int i = 0;i <= 100000;i ++)
        dist[i] = -INF;
    dist[s] = 0;
    while(q.size())
    {
        int u = q.front(); q.pop_front();
        use[u] = 0;
        for(int i = head[u];i;i = nxt[i])
        {
            int v = l[i].t;
            if(l[i].d && dist[v] < dist[u] + l[i].c)
            {
                dist[v] = dist[u] + l[i].c;
                pre[v] = i;
                if(!use[v])
                {
                    use[v] = 1;
                    if(q.empty()) q.push_front(v);
                    else if(dist[q.front()] > dist[v])
                        q.push_front(v);
                    else
                        q.push_back(v);
                }
            }
        }
    }
    if(dist[e] == -INF) return false;
    return true;
}

int dfs(int s,int e)
{
    int x = INF,ans = 0;
    for(int i = pre[e];i;i = pre[l[i].f])
        x = min(x,l[i].d);
    for(int i = pre[e];i;i = pre[l[i].f])
        ans += x * l[i].c,l[i].d -= x,l[i ^ 1].d += x;
    return ans;
}

int ek(int s,int e)
{
    int ans = 0;
    while(spfa(s,e)) ans += dfs(s,e);
    return ans;
}

struct haha{
    int l,r;
}seg[SZ];

bool cmp(haha a,haha b)
{
    return a.l < b.l;
}


int main()
{
    freopen("interv.in","r",stdin);
    freopen("interv.out","w",stdout);   
    int n,k;
    scanf("%d%d",&n,&k);
    for(int i = 1;i <= n;i ++)
        scanf("%d%d",&seg[i].l,&seg[i].r);
    sort(seg + 1,seg + 1 + n,cmp);

    int S = n * 2 + 1,S1 = n * 2 + 2,T = n * 2 + 3;

    insert(S,S1,k,0);

    for(int i = 1;i <= n;i ++)
        insert(S1,i,1,0),insert(i + n,T,1,0),insert(i,i + n,1,seg[i].r - seg[i].l);

    for(int i = 1;i <= n;i ++)
    {
        for(int j = i + 1;j <= n;j ++)
        {
            if(seg[i].r <= seg[j].l)
            {
                insert(i + n,j,1,0);
            }
        }
    }


    printf("%d\n",ek(S,T));
    return 0;
}

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

const int INF = 1000000010;
const int SZ = 1000010;

int head[SZ],nxt[SZ],tot = 1;

struct edge{
    int f,t,d,c;
}l[SZ];

void build(int f,int t,int d,int c)
{
    l[++ tot].t = t;
    l[tot].d = d;
    l[tot].f = f;
    l[tot].c = c;
    nxt[tot] = head[f];
    head[f] = tot;
}

void insert(int f,int t,int d,int c)
{
    build(f,t,d,c); build(t,f,0,-c);
}

int dist[SZ];
deque<int> q;
bool use[SZ];
int pre[SZ];

bool spfa(int s,int e)
{
    use[s] = 1;
    q.push_front(s);
    for(int i = 0;i <= 100000;i ++)
        dist[i] = -INF;
    dist[s] = 0;
    while(q.size())
    {
        int u = q.front(); q.pop_front();
        use[u] = 0;
        for(int i = head[u];i;i = nxt[i])
        {
            int v = l[i].t;
            if(l[i].d && dist[v] < dist[u] + l[i].c)
            {
                dist[v] = dist[u] + l[i].c;
                pre[v] = i;
                if(!use[v])
                {
                    use[v] = 1;
                    if(q.empty()) q.push_front(v);
                    else if(dist[q.front()] > dist[v])
                        q.push_front(v);
                    else
                        q.push_back(v);
                }
            }
        }
    }
    if(dist[e] == -INF) return false;
    return true;
}

int dfs(int s,int e)
{
    int x = INF,ans = 0;
    for(int i = pre[e];i;i = pre[l[i].f])
        x = min(x,l[i].d);
    for(int i = pre[e];i;i = pre[l[i].f])
        ans += x * l[i].c,l[i].d -= x,l[i ^ 1].d += x;
    return ans;
}

int ek(int s,int e)
{
    int ans = 0;
    while(spfa(s,e)) ans += dfs(s,e);
    return ans;
}

struct haha{
    int l,r;
}seg[SZ];

int lsh[SZ];

int main()
{
    freopen("interv.in","r",stdin);
    freopen("interv.out","w",stdout);       
    int n,k;
    scanf("%d%d",&n,&k);
    for(int i = 1;i <= n;i ++)
    {
        scanf("%d%d",&seg[i].l,&seg[i].r);
        lsh[++ lsh[0]] = seg[i].l;
        lsh[++ lsh[0]] = seg[i].r;
    }
    sort(lsh + 1,lsh + 1 + lsh[0]);
    int m = unique(lsh + 1,lsh + 1 + lsh[0]) - lsh - 1;


    int S = m + 1,T = m + 2;

    insert(S,1,k,0); insert(m,T,k,0);

    for(int i = 1;i < m;i ++)
        insert(i,i + 1,INF,0);

    for(int i = 1;i <= n;i ++)
    {
        int x = lower_bound(lsh + 1,lsh + 1 + m,seg[i].l) - lsh;
        int y = lower_bound(lsh + 1,lsh + 1 + m,seg[i].r) - lsh;
        insert(x,y,1,seg[i].r - seg[i].l);
    }

    printf("%d\n",ek(S,T));
    return 0;
}