Submission #36684961

---

Source Code Expand

// -*- coding:utf-8-unix -*-

#![allow(unused_imports)]
use std::io::{BufRead, BufReader, BufWriter, Read, Write, stdin, stdout, stderr};
use std::collections::*;
use proconio::{input, marker::{Bytes, Chars, Isize1, Usize1}, source::{auto::AutoSource, line::LineSource, once::OnceSource}};
use bitset_fixed::BitSet;
use itertools::*;
use num::integer::*;
use petgraph::algo::*;
use petgraph::graph::{DiGraph, Graph, NodeIndex, UnGraph};
use petgraph::unionfind::UnionFind;
use petgraph::visit::{Bfs, Dfs, EdgeRef, NodeCount, NodeIndexable, IntoEdges, Visitable, VisitMap};
use rand::{distributions::WeightedIndex, rngs::ThreadRng, seq::SliceRandom, Rng};
use regex::Regex;
use superslice::Ext;

fn main() {
    //let out = stdout();
    //let mut out = BufWriter::new(out.lock());
    //let err = stderr();
    //let mut err = BufWriter::new(err.lock());
    //let mut source = LineSource::new(BufReader::new(stdin()));
    /*
    input! {
        //from &mut source,
        n: usize,
        mut a: [u32; n],  // Vec<u32>
    }
    */
    let ibuf = getibuf();
    let mut it = ibuf.iter().cloned();
    let (n, l) = (it.parse_u32(), it.parse_u32());

    let l1 = l - 1;
    let mut space = 0;
    let mut f = true;

    for _ in 0..n {
        let ai = it.parse_u32();
        if space < l1 {
            space += ai + 1;
        } else if ai > 1 {
            f = false;
            break;
        }
    }

    let mut out = stdout();
    if f {
        out.write_all(b"Yes\n").unwrap();
    } else {
        out.write_all(b"No\n").unwrap();
    }
    //writeln!(&mut out, "{}", count).unwrap();
    //writeln!(&mut err, "{}", count).unwrap();
    //out.flush().unwrap();
    //err.flush().unwrap();
}

trait Change { fn chmax(&mut self, x: Self); fn chmin(&mut self, x: Self); }
impl<T: PartialOrd> Change for T {
    fn chmax(&mut self, x: T) { if *self < x { *self = x; } }
    fn chmin(&mut self, x: T) { if *self > x { *self = x; } }
}
/** get bytes from stdin */
fn getibuf() -> Vec<u8> {
    use std::io::Read;
    let stdin = std::io::stdin();
    let mut handle = stdin.lock();
    let mut ibuf = vec![];
    handle.read_to_end(&mut ibuf).unwrap();
    ibuf
}
/** input parser for program compete */
trait ProconParse {
    /** parse u32 value */
    fn parse_u32(&mut self) -> u32;
    /** parse u64 value */
    fn parse_u64(&mut self) -> u64;
    /** parse i32 value */
    fn parse_i32(&mut self) -> i32;
    /** parse i64 value */
    fn parse_i64(&mut self) -> i64;
    /** parse char (printable char) */
    fn parse_char(&mut self) -> char;
    /** parse chars (printable word) */
    fn parse_chars(&mut self) -> Vec<char>;
    /** parse String (printable word) */
    fn parse_string(&mut self) -> String { self.parse_chars().iter().collect() }
    /** get line chars (sp+printable ascii) */
    fn get_line_chars(&mut self) -> Vec<char>;
    /** get line String (sp+printable ascii) */
    fn get_line_string(&mut self) -> String { self.get_line_chars().iter().collect() }
    /** get line chars (trimed sp+printable ascii) */
    fn get_line_chars_trim(&mut self) -> Vec<char>;
    /** get line String (trimed sp+printable ascii) */
    fn get_line_string_trim(&mut self) -> String { self.get_line_chars_trim().iter().collect() }
    /** parse u32 (1 => 0-indexed) value */
    fn parse_u32_1(&mut self) -> u32 { self.parse_u32() - 1 }
    /** parse u64 (1 => 0-indexed) value */
    fn parse_u64_1(&mut self) -> u64 { self.parse_u64() - 1 }
    /** parse usize (32bit) value */
    fn parse_usize32(&mut self) -> usize { self.parse_u32() as usize }
    /** parse usize (1 => 0-indexed, 32bit) value */
    fn parse_usize32_1(&mut self) -> usize { self.parse_u32_1() as usize }
    /** parse usize (64bit) value */
    fn parse_usize64(&mut self) -> usize { self.parse_u64() as usize }
    /** parse usize (1 => 0-indexed, 64bit) value */
    fn parse_usize64_1(&mut self) -> usize { self.parse_u64_1() as usize }
}
impl<T: Iterator<Item = u8>> ProconParse for T {
    fn parse_u32(&mut self) -> u32 {
        let mut x = loop { match self.next() {
            Some(c @ b'0'..=b'9') => break (c & 0x0f) as u32,
            Some(_) => {},
            None => unreachable!(),
        }};
        while let Some(c @ b'0'..=b'9') = self.next() { x = x * 10 + (c & 0x0f) as u32; }
        x
    }
    fn parse_u64(&mut self) -> u64 {
        let mut x = loop { match self.next() {
            Some(c @ b'0'..=b'9') => break (c & 0x0f) as u64,
            Some(_) => {},
            None => unreachable!(),
        }};
        while let Some(c @ b'0'..=b'9') = self.next() { x = x * 10 + (c & 0x0f) as u64; }
        x
    }
    fn parse_i32(&mut self) -> i32 {
        let (f, mut x) = loop { match self.next() {
            Some(c @ b'0'..=b'9') => break (false, (c & 0x0f) as i32),
            Some(b'-') => break (true, match self.next() {
                Some(c @ b'0'..=b'9') => -((c & 0x0f) as i32),
                _ => unreachable!(),
            }),
            Some(_) => {},
            None => unreachable!(),
        }};
        match f {
            false => while let Some(c @ b'0'..=b'9') = self.next() { x = x * 10 + (c & 0x0f) as i32; },
            true => while let Some(c @ b'0'..=b'9') = self.next() { x = x * 10 - (c & 0x0f) as i32; },
        }
        x
    }
    fn parse_i64(&mut self) -> i64 {
        let (f, mut x) = loop { match self.next() {
            Some(c @ b'0'..=b'9') => break (false, (c & 0x0f) as i64),
            Some(b'-') => break (true, match self.next() {
                Some(c @ b'0'..=b'9') => -((c & 0x0f) as i64),
                _ => unreachable!(),
            }),
            Some(_) => {},
            None => unreachable!(),
        }};
        match f {
            false => while let Some(c @ b'0'..=b'9') = self.next() { x = x * 10 + (c & 0x0f) as i64; },
            true => while let Some(c @ b'0'..=b'9') = self.next() { x = x * 10 - (c & 0x0f) as i64; },
        }
        x
    }
    fn parse_char(&mut self) -> char {
        loop { match self.next() {
            Some(c @ b'!'..=b'~') => { break c as char },
            Some(_) => {},
            None => unreachable!(),
        }}
    }
    fn parse_chars(&mut self) -> Vec<char> {
        let mut v = loop { match self.next() {
            Some(c @ b'!'..=b'~') => break vec![c as char],
            Some(_) => {},
            None => unreachable!(),
        }};
        while let Some(c @ b'!'..=b'~') = self.next() { v.push(c as char); }
        v
    }
    fn get_line_chars(&mut self) -> Vec<char> {
        let mut v = loop { match self.next() {
            Some(c @ b' '..=b'~') => break vec![c as char],
            Some(_) => {},
            None => unreachable!(),
        }};
        while let Some(c @ b' '..=b'~') = self.next() { v.push(c as char); }
        v
    }
    fn get_line_chars_trim(&mut self) -> Vec<char> {
        let mut v = loop { match self.next() {
            Some(c @ b'!'..=b'~') => break vec![c as char],
            Some(_) => {},
            None => unreachable!(),
        }};
        while let Some(c @ b' '..=b'~') = self.next() { v.push(c as char); }
        while !('!'..='~').contains(v.last().unwrap()) { v.pop(); }
        v
    }
}

Submission Info

Judge Result