2022-12-20：二狗买了一些小兵玩具，和大胖一起玩， 一共有n个小兵，这n个小兵拍成一列， 第i个小兵战斗力为hi，然后他们两个开始对小兵进行排列， 一共进行m次操作，二狗每次操作选择一个数k，

Posted 2022-12-21 福大大架构师每日一题

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;