Problem:
ピザ

問題

JOI ピザでは,市の中心部を通る全長 d メートルの環状線の沿線上でピザの宅配販
売を行っている.

JOI ピザは,環状線上に n 個の店舗 S1, ... , Sn を持つ.本店は S1 である. S1 から Si まで,時計回りに環状線を移動したときの道のりを di メートルとおく. d2, ... , dn は 1 以上 d - 1 以下の整数である. d2 , ... , dn は全て異なる. ピザの注文を受けると, ピザが冷めないように, 宅配先までの移動距離がもっとも短い店舗でピザを焼き宅配する.

宅配先の位置は 0 以上 d - 1 以下の整数 k で表される.これは, 本店 S1 から宅配先までに時計回りで環状線を移動したときの道のりが k メートルであることを意味する. ピザの宅配は環状線に沿って行われ, それ以外の道を通ることは許されない. ただし, 環状線上は時計回りに移動しても反時計回りに移動してもよい.

例えば,店舗の位置と宅配先の位置が下図のようになっている場合 (この例は「入出力の例」の例 1 と対応している),

宅配先 1 にもっとも近い店舗は S2 なので, 店舗 S2 から宅配する.このとき, 店舗からの移動距離は 1 である.また, 宅配先 2 にもっとも近い店舗は S1 (本店) なので, 店舗 S1 (本店) から宅配する.このとき,店舗からの移動距離は 2 である.

環状線の全長 d, JOI ピザの店舗の個数 n, 注文の個数 m, 本店以外の位置を表す n - 1 個の整数 d2, ... , dn , 宅配先の場所を表す整数 k1, ... , km が与えられたとき, 各注文に対する宅配時の移動距離 (すなわち,最寄店舗から宅配先までの道のり) の全注文にわたる総和を求めるプログラムを作成せよ.

入力

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

1 行目には環状線の全長を表す正整数 d (2 ≤ d ≤ 1000000000 = 109 ), 2 行目には店舗の個数を表す正整数 n (2 ≤ n ≤ 100000), 3 行目には注文の個数を表す正整数 m (1 ≤ m ≤ 10000) が書かれている. 4 行目以降の n - 1 行には本店以外の店舗の位置を表す整数 d2, d3, ... , dn (1 ≤ di ≤ d - 1) がこの順に書かれており, n + 3 行目以降の m 行には宅配先の場所を表す整数 k1, k2, ... , km (0 ≤ ki ≤ d - 1) がこの順に書かれている.

採点用データのうち,配点の 40% 分については, n ≤ 10000 を満たす. また,配点の 40% 分については, 求める移動距離の総和と d の値はともに 1000000 以下である. さらに,全ての採点用データにおいて, 求める移動距離の総和は 1000000000 = 109以下である.

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

出力

データセットごとに,宅配時の移動距離の総和を表す 1 つの整数を1 行に出力する.

入出力例

入力例

8
3
2
3
1
4
6
20
4
4
12
8
16
7
7
11
8
0

出力例

3
3

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

Solution in Rust (judge verdict: Accepted)

/**
*  _           _                 __                            _   _ _   _                                 _                    _                  _
* | |         | |               / /                           | | (_) | (_)                               | |                  (_)                | |
* | |__   __ _| |_ ___   ___   / /__ ___  _ __ ___  _ __   ___| |_ _| |_ ___   _____ ______ _ __ _   _ ___| |_ ______ ___ _ __  _ _ __  _ __   ___| |_ ___
* | '_ \ / _` | __/ _ \ / _ \ / / __/ _ \| '_ ` _ \| '_ \ / _ \ __| | __| \ \ / / _ \______| '__| | | / __| __|______/ __| '_ \| | '_ \| '_ \ / _ \ __/ __|
* | | | | (_| | || (_) | (_) / / (_| (_) | | | | | | |_) |  __/ |_| | |_| |\ V /  __/      | |  | |_| \__ \ |_       \__ \ | | | | |_) | |_) |  __/ |_\__ \
* |_| |_|\__,_|\__\___/ \___/_/ \___\___/|_| |_| |_| .__/ \___|\__|_|\__|_| \_/ \___|      |_|   \__,_|___/\__|      |___/_| |_|_| .__/| .__/ \___|\__|___/
*                                                  | |                                                                           | |   | |
*                                                  |_|                                                                           |_|   |_|
*
* https://github.com/hatoo/competitive-rust-snippets
*/
#[allow(unused_imports)]
use std::cmp::{max, min, Ordering};
#[allow(unused_imports)]
use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque};
#[allow(unused_imports)]
use std::io::{stdin, stdout, BufWriter, Write};
#[allow(unused_imports)]
use std::iter::FromIterator;
mod util {
    use std::fmt::Debug;
    use std::io::{stdin, stdout, BufWriter, StdoutLock};
    use std::str::FromStr;
    #[allow(dead_code)]
    pub fn line() -> String {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        line.trim().to_string()
    }
    #[allow(dead_code)]
    pub fn chars() -> Vec<char> {
        line().chars().collect()
    }
    #[allow(dead_code)]
    pub fn gets<T: FromStr>() -> Vec<T>
    where
        <T as FromStr>::Err: Debug,
    {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        line.split_whitespace()
            .map(|t| t.parse().unwrap())
            .collect()
    }
    #[allow(dead_code)]
    pub fn with_bufwriter<F: FnOnce(BufWriter<StdoutLock>) -> ()>(f: F) {
        let out = stdout();
        let writer = BufWriter::new(out.lock());
        f(writer)
    }
}
#[allow(unused_macros)]
macro_rules ! get { ( $ t : ty ) => { { let mut line : String = String :: new ( ) ; stdin ( ) . read_line ( & mut line ) . unwrap ( ) ; line . trim ( ) . parse ::<$ t > ( ) . unwrap ( ) } } ; ( $ ( $ t : ty ) ,* ) => { { let mut line : String = String :: new ( ) ; stdin ( ) . read_line ( & mut line ) . unwrap ( ) ; let mut iter = line . split_whitespace ( ) ; ( $ ( iter . next ( ) . unwrap ( ) . parse ::<$ t > ( ) . unwrap ( ) , ) * ) } } ; ( $ t : ty ; $ n : expr ) => { ( 0 ..$ n ) . map ( | _ | get ! ( $ t ) ) . collect ::< Vec < _ >> ( ) } ; ( $ ( $ t : ty ) ,*; $ n : expr ) => { ( 0 ..$ n ) . map ( | _ | get ! ( $ ( $ t ) ,* ) ) . collect ::< Vec < _ >> ( ) } ; ( $ t : ty ;; ) => { { let mut line : String = String :: new ( ) ; stdin ( ) . read_line ( & mut line ) . unwrap ( ) ; line . split_whitespace ( ) . map ( | t | t . parse ::<$ t > ( ) . unwrap ( ) ) . collect ::< Vec < _ >> ( ) } } ; ( $ t : ty ;; $ n : expr ) => { ( 0 ..$ n ) . map ( | _ | get ! ( $ t ;; ) ) . collect ::< Vec < _ >> ( ) } ; }
#[allow(unused_macros)]
macro_rules ! debug { ( $ ( $ a : expr ) ,* ) => { eprintln ! ( concat ! ( $ ( stringify ! ( $ a ) , " = {:?}, " ) ,* ) , $ ( $ a ) ,* ) ; } }
const BIG_STACK_SIZE: bool = true;
#[allow(dead_code)]
fn main() {
    use std::thread;
    if BIG_STACK_SIZE {
        thread::Builder::new()
            .stack_size(32 * 1024 * 1024)
            .name("solve".into())
            .spawn(solve)
            .unwrap()
            .join()
            .unwrap();
    } else {
        solve();
    }
}

/// Equivalent to std::lowerbound and std::upperbound in c++
pub trait BinarySearch<T> {
    fn lower_bound(&self, &T) -> usize;
    fn upper_bound(&self, &T) -> usize;
}
impl<T: Ord> BinarySearch<T> for [T] {
    fn lower_bound(&self, x: &T) -> usize {
        let mut low = 0;
        let mut high = self.len();
        while low != high {
            let mid = (low + high) / 2;
            match self[mid].cmp(x) {
                Ordering::Less => {
                    low = mid + 1;
                }
                Ordering::Equal | Ordering::Greater => {
                    high = mid;
                }
            }
        }
        low
    }
    fn upper_bound(&self, x: &T) -> usize {
        let mut low = 0;
        let mut high = self.len();
        while low != high {
            let mid = (low + high) / 2;
            match self[mid].cmp(x) {
                Ordering::Less | Ordering::Equal => {
                    low = mid + 1;
                }
                Ordering::Greater => {
                    high = mid;
                }
            }
        }
        low
    }
}

fn solve() {
    loop {
        let d = get!(i64);
        if d == 0 {
            break;
        }
        let n = get!(usize);
        let m = get!(usize);
        let mut ds = get!(i64; n-1);
        let ks = get!(i64; m);

        ds.push(0);
        ds.push(d);
        ds.sort();

        let ans = ks.into_iter()
            .map(|k| {
                let i = ds.lower_bound(&k);
                if i == 0 {
                    ds[i] - k
                } else {
                    min(k - ds[i - 1], ds[i] - k)
                }
            })
            .sum::<i64>();

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