fork(1) download 
  1. #[allow(unused_imports)]
  2. use std::cmp::{min, max};
  3. use std::io::{BufWriter, stdout, stdin, Write, Read};
  4.  
  5. #[derive(Default)]
  6. struct Scanner {
  7.     buffer: Vec<String>,
  8. }
  9.  
  10. impl Scanner {
  11.     fn next<T: std::str::FromStr>(&mut self) -> T {
  12.         loop {
  13.             if let Some(token) = self.buffer.pop() {
  14.                 return token.parse::<T>().ok().expect("Failed parse");
  15.             }
  16.             let mut input = String::new();
  17.             stdin().read_line(&mut input).expect("Failed read");
  18.             self.buffer = input.split_whitespace()
  19.                                .rev()
  20.                                .map(String::from)
  21.                                .collect();
  22.         }
  23.     }
  24.     fn next_line(&mut self) -> String {
  25.         let mut input = String::new();
  26.         stdin().read_line(&mut input).expect("Failed read");
  27.         input.trim().to_string()
  28.     }
  29. }
  30.  
  31. #[allow(unused_variables)]
  32. macro_rules! io_init {
  33.     ($scan: ident, $out: ident) => {
  34.          let mut $scan: Scanner = Scanner::default();
  35.          let $out = &mut BufWriter::new(stdout());
  36.     };
  37. }
  38.  
  39. fn check(x: usize, f: &Vec<bool>, b: &Vec<bool>) -> bool {
  40.     !f[x] && !b[x] && b[x + 1]
  41. }
  42.  
  43. fn main() {
  44.     io_init!(scan, out);
  45.     let T: i32 = scan.next();
  46.     for _ in 0..T {
  47.         let n: usize = scan.next();
  48.         let q: usize = scan.next();
  49.         let mut cnt: i32 = 0;
  50.         let mut p = vec![0i32; n + 1];
  51.         let mut f_arr = vec![false; n + 1];
  52.         let mut b_arr = vec![false; n + 2];
  53.         let mut x_val = 0;
  54.         for i in 1..=n {
  55.             p[i] = scan.next();
  56.             x_val = max(x_val, p[i]);
  57.             f_arr[i] = (x_val == i as i32);
  58.         }
  59.         let s: String = scan.next();
  60.         let s_chars: Vec<char> = s.chars().collect();
  61.         for i in 0..n {
  62.             b_arr[i + 1] = s_chars[i] == 'R';
  63.         }
  64.         for i in 1..n {
  65.             if check(i, &f_arr, &b_arr) {
  66.                 cnt += 1;
  67.             }
  68.         }
  69.         for _ in 0..q {
  70.             let i: usize = scan.next();
  71.             if i >= 2 {
  72.                 if check(i - 1, &f_arr, &b_arr) {
  73.                     cnt -= 1;
  74.                 }
  75.             }
  76.             if i <= n - 1 {
  77.                 if check(i, &f_arr, &b_arr) {
  78.                     cnt -= 1;
  79.                 }
  80.             }
  81.             b_arr[i] = !b_arr[i];
  82.             if i >= 2 {
  83.                 if check(i - 1, &f_arr, &b_arr) {
  84.                     cnt += 1;
  85.                 }
  86.             }
  87.             if i <= n - 1 {
  88.                 if check(i, &f_arr, &b_arr) {
  89.                     cnt += 1;
  90.                 }
  91.             }
  92.             if cnt != 0 {
  93.                 writeln!(out, "NO").unwrap();
  94.             } else {
  95.                 writeln!(out, "YES").unwrap();
  96.             }
  97.         }
  98.     }
  99. }
  100.  
Success #stdin #stdout 0.01s 5296KB
comments ()
stdin 
3
5 3
1 4 2 5 3
RLRLL
2
4
3
8 5
1 5 2 4 8 3 6 7
RRLLRRRL
4
3
5
3
4
6 2
1 2 3 4 5 6
RLRLRL
4
5
stdout 
YES
YES
NO
NO
YES
NO
NO
NO
YES
YES
https://ideone.com/zytx9s
language:
Rust (rust 1.56)
created:
18 days ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!