一眼过去很像是：排序，然后从前向后扫，有这个区间时插到树里，过去以后再删除。然后事实也是这样做的……
具体起来：
1.如果考虑暴力的话，一种想法是枚举左端和右端要选取的区间（如果我们按长度排序的话），那么只要发现当前选取的这些从左到右的区间可以得到m及以上就可以了，没必要特地考虑具体选哪些，然后ans = min（ans， 右len - 左len）即可。
2.判断这些区间是否可行的方法是：出现一个区间就把区间内所有点+1，线段树维护最大值，所以segment[1].maxx >= m时该区间可行，然后1e9太大，把每个区间端点离散化一下。
3.复杂度太大，优化手法是发现如果当前的左端区间和右端区间都合法的话，因为我们是按照长度排序的，所以右端区间没理由往右移了，只会让答案更差。所以枚举左端即可，右端类似尺取的方法即可。然后就是常见手法，遇到一个新的r就插进树里+1，路过一个l就从树里-1。
#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <cctype>
#include <climits>
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <string>
#include <sstream>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <vector>
#include <list>
#include <fstream>
#include <bitset>
#define init(a, b) memset(a, b, sizeof(a))
#define rep(i, a, b) for (int i = a; i <= b; i++)
#define irep(i, a, b) for (int i = a; i >= b; i--)
#define ls(p) (p) << 1
#define rs(p) (p) << 1 | 1
using namespace std; typedef double db;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
const int inf = 0x3f3f3f3f;
const ll INF = 1e18; template <typename T> void read(T &x) {
x = ;
int s = , c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') s = -;
for (; isdigit(c); c = getchar())
x = x * + c - ;
x *= s;
} template <typename T> void write(T x) {
if (x < ) x = -x, putchar('-');
if (x > ) write(x / );
putchar(x % + '');
} template <typename T> void writeln(T x) {
write(x);
puts("");
} const int maxn = 1e6 + ; int n, m, c[maxn], tot, ans = inf;
struct Section {
int l, r, len; bool operator < (const Section y) const {
return len < y.len;
}
}a[maxn]; struct Node {
int l, r, maxx, tag;
}t[maxn << ]; void build(int l, int r, int p) {
t[p].l = l, t[p].r = r;
if (l == r) {
t[p].maxx = t[p].tag = ;
return;
}
int mid = (l + r) >> ;
build(l, mid, ls(p));
build(mid + , r, rs(p));
} void Push_down(int p) {
if (t[p].tag) {
t[ls(p)].maxx += t[p].tag;
t[rs(p)].maxx += t[p].tag;
t[ls(p)].tag += t[p].tag;
t[rs(p)].tag += t[p].tag;
t[p].tag = ;
}
} void Update(int l, int r, int p, int k) {
if (l <= t[p].l && t[p].r <= r) {
t[p].maxx += k;
t[p].tag += k;
return;
}
Push_down(p);
int mid = (t[p].l + t[p].r) >> ;
if (l <= mid) Update(l, r, ls(p), k);
if (mid < r) Update(l, r, rs(p), k);
t[p].maxx = max(t[ls(p)].maxx, t[rs(p)].maxx);
} int main() {
read(n), read(m);
rep(i, , n) {
read(a[i].l);
read(a[i].r);
a[i].len = a[i].r - a[i].l;
c[++tot] = a[i].l;
c[++tot] = a[i].r;
}
//离散化
sort(c + , c + + tot);
tot = unique(c + , c + + tot) - c - ;
rep(i, , n) {
a[i].l = lower_bound(c + , c + + tot, a[i].l) - c;
a[i].r = lower_bound(c + , c + + tot, a[i].r) - c;
}
sort(a + , a + + n);
//线段树维护
build(, tot, );
for (int l = , r = ; l <= n; l++) {
while (t[].maxx < m && r < n) {
++r;
Update(a[r].l, a[r].r, , );
}
if (t[].maxx == m) {
ans = min(ans, a[r].len - a[l].len);
} else break;
Update(a[l].l, a[l].r, , -);
} if (ans == inf) puts("-1");
else writeln(ans);
return ;
}