2022-12-20：二狗买了一些小兵玩具，和大胖一起玩，
一共有n个小兵，这n个小兵拍成一列，
第i个小兵战斗力为hi，然后他们两个开始对小兵进行排列，
一共进行m次操作，二狗每次操作选择一个数k，将前k个小兵战斗力从小到大排列，
大胖每次操作选择一个数k，将前k个小兵战斗力从大到小排列，
问所有操作结束后，排列顺序什么样，
给定一个长度为n的数组arr，表示每个小兵的战斗力，
给定一个长度为m的数组op,
op[i] = { k , 0 }, 表示对前k个士兵执行从小到大的操作，
op[i] = { k , 1 }, 表示对前k个士兵执行从大到小的操作。
返回数组ans，表示最终的排列。
1 <= n, m <= 2 * 10^5，
-10 ^ 9<= arr[i] <= + 10^9。
来自百度。
答案2022-12-20：
单调栈+有序表。
rust语言里结构体的有序表需要实现Ord的trait。
时间复杂度O(M) + O(N*logN)。
rust代码如下：
use rand::Rng;
use std::cmp::Ordering;
use std::collections::BTreeSet;
use std::iter::repeat;
fn main() {
let mut arr = vec![3, 2, 6, 7, 5, 1];
let mut op = vec![vec![3, 0], vec![4, 1], vec![2, 0]];
let ans2 = game2(&mut arr, &mut op);
println!("ans2 = {:?}", ans2);
let nn: i32 = 200;
let mm: i32 = 100;
let vv: i32 = 200;
let test_time: i32 = 5000;
println!("测试开始");
for i in 0..test_time {
let n: i32 = rand::thread_rng().gen_range(0, nn) + 1;
let m: i32 = rand::thread_rng().gen_range(0, mm) + 1;
let mut arr = random_array(n, vv);
let mut op = random_op(m, n);
let ans1 = game1(&mut arr, &mut op);
let ans2 = game2(&mut arr, &mut op);
if ans1 != ans2 {
println!("出错了!");
println!("i = {}", i);
println!("ans1 = {:?}", ans1);
println!("ans2 = {:?}", ans2);
break;
}
}
println!("测试结束");
}
// 暴力方法
// 为了验证
fn game1(arr: &mut Vec<i32>, op: &mut Vec<Vec<i32>>) -> Vec<i32> {
let n = arr.len() as i32;
let mut help: Vec<i32> = repeat(0).take(n as usize).collect();
for i in 0..n {
help[i as usize] = arr[i as usize];
}
for o in op.iter() {
if o[1] == 0 {
help[0..o[0] as usize].sort_by(|a, b| a.cmp(b));
} else {
help[0..o[0] as usize].sort_by(|a, b| b.cmp(a));
}
}
let mut ans: Vec<i32> = repeat(0).take(n as usize).collect();
for i in 0..n {
ans[i as usize] = help[i as usize];
}
return ans;
}
// 正式方法
// 时间复杂度O(M) + O(N*logN)
fn game2(arr: &mut Vec<i32>, op: &mut Vec<Vec<i32>>) -> Vec<i32> {
let n = arr.len() as i32;
let m = op.len() as i32;
let mut stack: Vec<i32> = repeat(0).take(m as usize).collect();
let mut r = 0;
for i in 0..m {
while r != 0 && op[stack[(r - 1) as usize] as usize][0] <= op[i as usize][0] {
r -= 1;
}
stack[r as usize] = i;
r += 1;
}
let mut ans: Vec<i32> = repeat(0).take(n as usize).collect();
let mut ansi = n - 1;
let mut l = 0;
while ansi >= op[stack[l as usize] as usize][0] {
ans[ansi as usize] = arr[ansi as usize];
ansi -= 1;
}
let mut sorted: BTreeSet<Number> = BTreeSet::new();
for i in 0..op[stack[l as usize] as usize][0] {
sorted.insert(Number::new(arr[i as usize], i));
}
while l != r {
// 当前处理的指令
let cur = &op[stack[l as usize] as usize];
l += 1;
if l != r {
let mut next = &op[stack[l as usize] as usize];
let num = cur[0] - next[0];
if cur[1] == 0 {
for i in 0..num {
ans[ansi as usize] = sorted.pop_last().unwrap().value;
ansi -= 1;
}
} else {
for i in 0..num {
ans[ansi as usize] = sorted.pop_first().unwrap().value;
ansi -= 1;
}
}
} else {
if cur[1] == 0 {
while sorted.len() > 0 {
ans[ansi as usize] = sorted.pop_last().unwrap().value;
ansi -= 1;
}
} else {
while sorted.len() > 0 {
ans[ansi as usize] = sorted.pop_first().unwrap().value;
ansi -= 1;
}
}
}
}
return ans;
}
struct Number {
value: i32,
index: i32,
}
impl Number {
fn new(v: i32, i: i32) -> Self {
Self { value: v, index: i }
}
}
impl Ord for Number {
fn cmp(&self, other: &Self) -> Ordering {
if self.value != other.value {
self.value.cmp(&other.value)
} else {
self.index.cmp(&other.index)
}
}
}
impl PartialOrd for Number {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(self.cmp(other))
}
}
impl PartialEq for Number {
fn eq(&self, other: &Self) -> bool {
(self.value, &self.index) == (other.value, &other.index)
}
}
impl Eq for Number {}
// 为了测试
fn random_array(n: i32, v: i32) -> Vec<i32> {
let mut ans: Vec<i32> = repeat(0).take(n as usize).collect();
for i in 0..n {
ans[i as usize] = rand::thread_rng().gen_range(0, v) + 1;
}
return ans;
}
// 为了测试
fn random_op(m: i32, n: i32) -> Vec<Vec<i32>> {
let mut ans: Vec<Vec<i32>> = repeat(repeat(0).take(2).collect())
.take(m as usize)
.collect();
for i in 0..m {
ans[i as usize][0] = rand::thread_rng().gen_range(0, n + 1);
ans[i as usize][1] = rand::thread_rng().gen_range(0, 2);
}
return ans;
}
// 为了测试
fn is_equal(arr1: &mut Vec<i32>, arr2: &mut Vec<i32>) -> bool {
if arr1.len() != arr2.len() {
return false;
}
for i in 0..arr1.len() {
if arr1[i as usize] != arr2[i as usize] {
return false;
}
}
return true;
}
