1
// mt19937：高质量 32 位随机数引擎
2
std::random_device rd;
3
std::mt19937 rng(rd()); // 或者直接在里面传入固定种子
4

5
int randint(int l, int r) {
6
    // 使用 uniform_int_distribution 保证生成的随机数在区间内均匀分布
7
    return std::uniform_int_distribution<int>(l, r)(rng);
8
}

1
using pii = std::pair<int, int>;
2
using vvi = std::vector<std::vector<int>>;
3

4
std::random_device rd;
5
std::mt19937 rng(rd());
6

7
int random(int l, int r) {
8
    return std::uniform_int_distribution<int>(l, r)(rng);
9
}
10

11
struct Node {
12
    int left = 0;
13
    int right = 0;
14
};
15

16
// 生成一颗随机二叉树
17
std::vector<Node> gen_random_binary_tree(int n) {
18
    std::vector<Node> tree(n + 1);
19
    std::vector<int> p(n + 1);
20
    std::iota(p.begin() + 1, p.end(), 1);
21
    std::shuffle(p.begin() + 2, p.end(), rng); // 保证 1 是根
22
    for (int i = 2; i <= n; i++) {
23
        int v = p[i];
24
        while (true) {
25
            int u = p[random(1, i - 1)]; // 随机父亲
26
            // 随机尝试左或右
27
            if (!tree[u].left && !tree[u].right) {
28
                if (random(0, 1)) tree[u].left = v;
29
                else tree[u].right = v;
30
                break;
31
            } else if (!tree[u].left) {
32
                tree[u].left = v;
33
                break;
34
            } else if (!tree[u].right) {
35
                tree[u].right = v;
36
                break;
37
            }
38
            // 如果两个孩子都有，重新选父亲
39
        }
40
    }
41
    return tree;
42
}
43

44
void print_binary_tree(std::vector<Node>& tree) {
45
    int n = tree.size() - 1;
46
    for (int u = 1; u <= n; u++) {
47
        if (tree[u].left) {
48
            std::cout << u << "->" << tree[u].left << " [label=\"L\"];\n";
49
            // std::cout << (char)(u + 'a' - 1) << "->" << (char)(tree[u].left + 'a' - 1) << " [label=\"L\"];\n";
50
        }
51
        if (tree[u].right) {
52
            std::cout << u << "->" << tree[u].right << " [label=\"R\"];\n";
53
            // std::cout << (char)(u + 'a' - 1) << "->" << (char)(tree[u].right + 'a' - 1) << " [label=\"R\"];\n";
54
        }
55

56
    }
57
}

1
using pii = std::pair<int, int>;
2
using vvi = std::vector<std::vector<int>>;
3

4
std::random_device rd;
5
std::mt19937 rng(rd());  // 或者直接在里面传入固定种子
6

7
int random(int l, int r) {
8
    return std::uniform_int_distribution<int>(l, r)(rng);
9
}
10

11
// 生成一颗随机树
12
vvi gen_random_tree(int n) {
13
    vvi g(n + 1);
14
    std::vector<int> p(n + 1);
15
    // [1, 2, ..., n]
16
    std::iota(p.begin() + 1, p.end(), 1);
17
    // 打乱（首位为根，这里保留 1 不变，所以根为 1）
18
    std::shuffle(p.begin() + 2, p.end(), rng);
19
    for (int i = 2; i <= n; i++) {
20
        int u = p[random(1, i - 1)];
21
        int v = p[i];
22
        g[u].push_back(v);
23
        // g[v].push_back(u);
24
    }
25
    return g;
26
}
27

28
void print_tree(vvi& g) {
29
    int n = g.size() - 1;
30
    std::set<pii> s;
31
    for (int u = 1; u <= n; u++) {
32
        for (int v : g[u]) {
33
            s.insert({u, v});
34
            // s.insert({std::min(u, v), std::max(u, v)});
35
        }
36
    }
37
    // for (auto [u, v] : s) std::cout << u << " " << v << '\n';
38
    for (auto [u, v] : s) std::cout << u << "->" << v << ";\n";
39
}

1
int clear_bit(int num, int k) {
2
    return num & ~(1 << k);
3
}

1
int set_bit(int num, int k) {
2
    return num | (1 << k);
3
}

1
int toggle_bit(int num, int k) {
2
    return num ^ (1 << k);
3
}

1
bool check(int n) {
2
    return (n & (n - 1)) == 0;
3
}

1
void solve() {
2
    int n; std::cin >> n;
3
    for (int i = 31; i >= 0; i--) {
4
        if (n >> i & 1) std::cout << 1;
5
        else std::cout << 0;
6
    }
7
}

1
#include <bits/stdc++.h>
2
using namespace std;
3
#define int long long
4

5
void solve() {
6
    int n; cin >> n;
7
    vector<int> left(n + 1), right(n + 1);
8
    int min_r1 = LLONG_MAX, min_r2 = LLONG_MAX;
9
    int max_l1 = LLONG_MIN, max_l2 = LLONG_MIN;
10
    for (int i = 1; i <= n; i++) {
11
        int l, r; cin >> l >> r;
12
        left[i] = l; right[i] = r;
13
        // 更新最小和次小 r
14
        if (r < min_r1) {
15
            min_r2 = min_r1;
16
            min_r1 = r;
17
        } else if (r < min_r2) {
18
            min_r2 = r;
19
        }
20
        // 更新最大和次大 l
21
        if (l > max_l1) {
22
            max_l2 = max_l1;
23
            max_l1 = l;
24
        } else if (l > max_l2) {
25
            max_l2 = l;
26
        }
27
    }
28
    // [min_r - max_l]
29
    int cnt_max_l = 0, cnt_min_r = 0;
30
    for (int i = 1; i <= n; i++) {
31
        cnt_max_l += left[i] == max_l1;
32
        cnt_min_r += right[i] == min_r1;
33
    }
34
    int ans = 0;
35
    for (int i = 1; i <= n; i++) {
36
        int l = max_l1, r = min_r1;
37
        if (left[i] == max_l1 && cnt_max_l == 1) {
38
            l = max_l2;
39
        }
40
        if (right[i] == min_r1 && cnt_min_r == 1) {
41
            r = min_r2;
42
        }
43
        ans = max(ans, r - l);
44
    }
45
    cout << ans << '\n';
46
}
47

48
signed main() {
49
    ios::sync_with_stdio(0); cin.tie(0);
50
    int T = 1;
51
    // cin >> T;
52
    while (T--) solve();
53
    return 0;
54
}

1
std::vector<std::string> split(const std::string& s, char delim) {
2
    std::vector<std::string> res;
3
    std::stringstream ss(s);
4
    std::string token;
5
    while (std::getline(ss, token, delim)) {
6
        res.push_back(token);
7
    }
8
    return res;
9
}

1
std::vector<std::string> split_space(const std::string& s) {
2
    std::vector<std::string> res;
3
    std::stringstream ss(s);
4
    std::string token;
5
    while (ss >> token) {
6
        res.push_back(token);
7
    }
8
    return res;
9
}

1
std::string trim(const std::string& s) {
2
    size_t start = s.find_first_not_of(" \t\r\n");
3
    if (start == std::string::npos) return "";
4
    size_t end = s.find_last_not_of(" \t\r\n");
5
    return s.substr(start, end - start + 1);
6
}

1
void select_sort(std::vector<int>& arr) {
2
    int n = arr.size();
3
    for (int i = 0; i < n - 1; i++) {
4
        int min_pos = i;
5
        for (int j = i + 1; j < n; j++) {
6
            if (arr[j] < arr[min_pos]) {
7
                min_pos = j;
8
            }
9
        }
10
        std::swap(arr[i], arr[min_pos]);
11
    }
12
}

1
void bubble_sort(std::vector<int>& arr) {
2
    int n = arr.size();
3
    for (int i = 0; i < n - 1; i++) {
4
        for (int j = 0; j < n - i - 1; j++) {
5
            if (arr[j + 1] < arr[j]) {
6
                std::swap(arr[j + 1], arr[j]);
7
            }
8
        }
9
    }
10
}

1
const int N = 1e5 + 1;
2
int arr[N];
3
int help[N];
4

5
// 合并两个有序数组
6
// [l, mid], [mid + 1, r]
7
void merge(int l, int mid, int r) {
8
    int pos = l;
9
    int a = l;        // 左指针
10
    int b = mid + 1;  // 右指针
11
    while (a <= mid && b <= r) {
12
        // 哪个数小拷贝哪个数
13
        help[pos++] = arr[a] <= arr[b] ? arr[a++] : arr[b++];
14
    }
15
    // 拷贝剩下的数字，必有一个越界，一个不越界
16
    while (a <= mid) {
17
        help[pos++] = arr[a++];
18
    }
19
    while (b <= r) {
20
        help[pos++] = arr[b++];
21
    }
22
    for (int i = l; i <= r; i++) arr[i] = help[i];
23
}
24

25
// [l, r] 上面有序
26
void merge_sort(int l, int r) {
27
    if (l == r) return;
28
    int mid = l + r >> 1;
29
    merge_sort(l, mid);
30
    merge_sort(mid + 1, r);
31
    merge(l, mid, r);
32
}

1
std::mt19937 rmg(std::time(nullptr));
2

3
int random(int l, int r) {
4
    return std::uniform_int_distribution<int>(l, r)(rmg);
5
}
6

7
const int N = 1e5 + 1;
8
int arr[N];
9
int lt, gt;
10

11
void partition(int l, int r, int x) {
12
    // lt: < x, gt: > x
13
    lt = l, gt = r;
14
    int pos = l;
15
    while (pos <= gt) {
16
        // 相等继续
17
        if (arr[pos] == x) pos++;
18
        // 交换左指针和当前位置的值，左指针++，当前位置++
19
        else if (arr[pos] < x) std::swap(arr[lt++], arr[pos++]);
20
        // 交换右指针和当前位置的值，右指针--，当前位置不变（因为当前位置还没有判断大小）
21
        else std::swap(arr[gt--], arr[pos]);
22
    }
23
}
24

25
void quick_sort(int l, int r) {
26
    if (l >= r) return;
27
    int x = arr[random(l, r)];
28
    partition(l, r, x);
29
    // 这里一定要使用临时变量记住 lt 和 gt，因为之后递归的过程中可能值会发生变化
30
    int left = lt;
31
    int right = gt;
32
    quick_sort(l, left - 1);
33
    quick_sort(right + 1, r);
34
}

1
int find(vector<int>& arr, int key) {
2
    int l = 0, r = arr.size() - 1, pos = -1;
3
    while (l <= r) {
4
        int mid = l + r >> 1;
5
        if (arr[mid] == key) r = mid - 1, pos = mid;
6
        else if (arr[mid] > key) r = mid - 1;
7
        else l = mid + 1;
8
    }
9
    return pos;
10
}

1
int find(vector<int>& arr, int key) {
2
    int l = 0, r = arr.size() - 1, pos = -1;
3
    while (l <= r) {
4
        int mid = l + r >> 1;
5
        if (arr[mid] >= key) r = mid - 1, pos = mid;
6
        else l = mid + 1;
7
    }
8
    return pos;
9
}

1
int first_ge(vector<int>& arr, int key) {
2
    auto it = std::lower_bound(arr.begin(), arr.end(), key);
3
    return it == arr.end() ? -1 : it - arr.begin();
4
}

1
int first_gt(vector<int>& arr, int key) {
2
    auto it = std::upper_bound(arr.begin(), arr.end(), key);
3
    return it == arr.end() ? -1 : it - arr.begin();
4
}

1
int last_lt(vector<int>& arr, int key) {
2
    return std::lower_bound(arr.begin(), arr.end(), key) - arr.begin() - 1;
3
}

1
int last_le(vector<int>& arr, int key) {
2
    return std::upper_bound(arr.begin(), arr.end(), key) - arr.begin() - 1;
3
}

1
int first_ge(vector<int>& arr, int key) {
2
    auto it = std::lower_bound(arr.begin() + 1, arr.end(), key);
3
    if (it == arr.end()) return -1;
4
    return it - arr.begin();
5
}