Problem:
シャッフル

問題

1 から n までの番号が書かれた n 枚のカードがある．まず，一番上が番号 1 のカード，上から2枚目が番号 2 のカード，…，一番下が番号 n のカードとなるように順番に重ねて，カードの山を作る．

カードの山に対して，「シャッフル(x,y)」と呼ばれる次のような操作を行うことで，カードを並び替える（x, y は 1 ≤ x < y < n をみたす整数）．

シャッフル(x,y)

n 枚のカードを，一番上から x 枚目までのカードからなる山A， x+1 枚目から y 枚目のカードからなる山B， y+1 枚目から n 枚目のカードからなる山C の3つの山に分ける．そして，山Aの上に山Bを重ね，さらにその上に山Cを重ねる．

例えば，順番に並んでいる9枚のカードに対して「シャッフル(3,5)」を行うと， 9 枚のカードに書かれた番号は, 上から順番に 6, 7, 8, 9, 4, 5, 1, 2, 3 となる．

最初の山の状態から m 回のシャッフル「シャッフル(x1, y1)」「シャッフル(x2, y2)」 … 「シャッフル(xm, ym)」を順番に行った後のカードの山において，上から数えて p 枚目から q 枚目のカードの中に番号が r 以下のカードが何枚含まれているかを求めるプログラムを作成せよ．

入力

入力は複数のデータセットからなる．各データセットは以下の形式で与えられる．

入力は m+3 行からなる． 1 行目にはカードの枚数 n が書かれている（3 ≤ n ≤ 1000000000 = 109）． 2 行目にはシャッフルの回数を表す整数 m が書かれている（1 ≤ m ≤ 5000）． 3 行目には整数 p, q, r が書かれている（1 ≤ p ≤ q ≤ n, 1 ≤ r ≤ n）． i + 3 行目（1 ≤ i ≤ m）には2つの整数 xi, yi (1 ≤ xi < yi < n) が空白を区切りとして書かれている．

n が 0 のとき入力の終了を示す. データセットの数は 5 を超えない．

出力

データセットごとに, m 回のシャッフル後のカードの山において，上から数えて p 枚目から q 枚目のカードの中に含まれている番号が r 以下のカードの枚数を１行に出力せよ．

入出力例

入力例

9
1
3 7 4
3 5
12
3
3 8 5
3 8
2 5
6 10
0

出力例

2
3

1つ目の入力例の山に対して, 「シャッフル(3,5)」を行うと，カードは上から順番に 6, 7, 8, 9, 4, 5, 1, 2, 3 となる．上から数えて 3 枚目から 7 枚目に含まれる番号が 4 以下のカードは，番号 4 と番号 1 の 2 枚である．

また，2つ目の入力例の山に対して, 「シャッフル(3,8)」「シャッフル(2,5)」「シャッフル(6,10)」を順番に行うと，カードは上から順番に 9, 10, 3, 11, 12, 4, 5, 6, 7, 8, 1, 2 となる．上から数えて 3 枚目から 8 枚目に含まれる番号が 5 以下のカードは 3 枚である．

上記問題文と自動審判に使われるデータは、情報オリンピック日本委員会が作成し公開している問題文と採点用テストデータです。

Solution in Rust (judge verdict: Accepted)

#[allow(unused_imports)]
use std::io::{stdin, Read, StdinLock};
#[allow(unused_imports)]
use std::cmp::{max, min, Ordering};
#[allow(unused_imports)]
use std::str::FromStr;
#[allow(unused_imports)]
use std::collections::{HashSet, HashMap, BinaryHeap, VecDeque};
#[allow(unused_imports)]
use std::vec::Vec;

#[allow(dead_code)]
const INF: i32 = 1000_000_000;
#[allow(dead_code)]
const INFLL: i64 = 1000_000_000_000_000_000;
#[allow(dead_code)]
const EPS: f64 = 1.0e-10;
#[allow(dead_code)]
const MOD: i32 = 1000_000_007;
#[allow(dead_code)]
const MODLL: i64 = 1000_000_007;

struct Scanner<'a> {
    cin: StdinLock<'a>,
}

#[allow(dead_code)]
impl<'a> Scanner<'a> {
    fn new(cin: StdinLock<'a>) -> Scanner<'a> {
        Scanner {cin: cin}
    }
    fn read1<T: FromStr>(&mut self) -> Option<T> {
        let token = self.cin.by_ref().bytes().map(|c| c.unwrap() as char)
                    .skip_while(|c| c.is_whitespace())
                    .take_while(|c| !c.is_whitespace())
                    .collect::<String>();
        token.parse::<T>().ok()
    }
    fn read<T: FromStr>(&mut self) -> T {
        self.read1().unwrap()
    }
}


fn main() {
    let cin = stdin();
    let cin = cin.lock();
    let mut sc = Scanner::new(cin);

    loop {
        let n: usize = sc.read();
        if n == 0 {
            break;
        }
        let m: usize = sc.read();
        let (p, q, r): (i32, i32, i32) = (sc.read(), sc.read(), sc.read());
        let mut x: Vec<i32> = vec![0; m];
        let mut y: Vec<i32> = vec![0; m];
        for i in 0..m {
            x[i] = sc.read();
            y[i] = sc.read();
        }
        let x = x; let y = y;

        let mut v: Vec<(i32, i32)> = vec![(1, n as i32)]; // [l, r]

        for i in 0..m {
            let (x, y) = (x[i], y[i]);
            let mut front: Vec<(i32, i32)> = Vec::new();
            let mut mid: Vec<(i32, i32)> = Vec::new();
            let mut back: Vec<(i32, i32)> = Vec::new();
            let mut sum = 0;
            let mut j = 0;
            while j < v.len() { // front
                let (l, r) = v[j];
                if sum + r - l + 1 >= x {
                    front.push((l, l + x - sum - 1));
                    if l + x - sum - 1 == r {
                        sum += r - l + 1;
                        j += 1;
                    }
                    break;
                }
                front.push((l, r));
                j += 1;
                sum += r - l + 1;
            }
            while j < v.len() { // mid
                let (l, r) = v[j];
                let add = max(0, min(x - sum, r - l)); // performed only first
                if sum + r - l + 1 >= y {
                    mid.push((l + add, l + y - sum - 1));
                    if l + y - sum - 1 == r {
                        sum += r - l + 1;
                        j += 1;
                    }
                    break;
                }
                sum += r - l + 1;
                let l = l + add;
                mid.push((l, r));
                j += 1;
            }
            while j < v.len() { // back
                let (l, r) = v[j];
                let add = max(0, min(y - sum, r - l));
                sum += r - l + 1;
                let l = l + add;
                back.push((l, r));
                j += 1;
            }
            v.clear();
            v.append(&mut back);
            v.append(&mut mid);
            v.append(&mut front);
        }

        let mut ans = 0;
        let mut sum = 0;
        for (l, u) in v {
            if sum + u - l + 1 >= p {
                let lv = l + max(p - sum - 1, 0);
                let lr = min(u, l + (q - sum - 1));
                let lr = min(lr, r);
                if lv <= lr {
                    ans += lr - lv + 1;
                }
            }
            sum += u - l + 1;
        }

        println!("{}", ans);
    }
}