2023-03-18:给定一个长度n的数组,每次可以选择一个数x, 让这个数组中所有的x都变成x+1,问你最少的操作次数, 使得这个数组变成一个非降数组。 n <= 3 * 10^5, 0 <= 数值

2023-03-18:给定一个长度n的数组,每次可以选择一个数x,
让这个数组中所有的x都变成x+1,问你最少的操作次数,
使得这个数组变成一个非降数组。
n <= 3 * 10^5,
0 <= 数值 <= 10^9。
来自阿里。

答案2023-03-18:

解题思路

本题可以用多种算法来解决,下面我们将介绍四种常见的做法,分别是暴力枚举、动态规划、单调栈和差分。

方法一:暴力枚举

如果直接对原数组进行修改,那么很容易会导致计算出错或者超时。因此我们可以考虑对数组进行复制,并生成一个布尔型数组op,表示对应位置的元素是否需要进行加1操作。最后,根据op数组来计算最少的加1操作次数。具体实现过程如下:

  • 首先找到数组中的最大值max。

  • 定义一个长度为max + 1的布尔型数组op,初值全部为false。

  • 定义一个递归函数process1,参数分别为op数组、原始数组arr、当前处理到的数字num和max值。该函数的作用是通过遍历op数组,计算经过若干次加1操作后,原始数组是否能够变成一个非降序列,并返回所需的最小操作次数。具体实现过程如下:

  • 如果num == max + 1,说明已经遍历完了op数组。此时需要对原数组进行操作,然后判断是否符合非降序列的条件。如果符合,则返回op数组中true值的个数cnt,否则返回std::i32::MAX。

  • 否则,在op[num] = true之后调用process1函数,表示将num加1,然后统计所需的操作次数p1。接着,在op[num] = false之后调用process1函数,表示不对num进行任何操作,然后统计所需的操作次数p2。最终返回p1和p2中的最小值。

  • 在主函数中,利用rand库生成随机数组,并调用process1函数计算最少的加1操作次数即可。具体实现过程如下:

  • 对于功能测试,重复执行test_time次随机实验,并检查计算结果是否正确。

  • 对于性能测试,生成长度为n、数值范围为v的随机数组,并重复执行test_time次计算过程,记录总运行时间,并输出平均每次计算的时间。

首先,我们可以通过枚举每一种可能的操作方式,然后依次进行模拟,最后统计最小的操作次数。

假设当前我们已经枚举到了数字x,那么有两种情况:要么对所有等于x的数字进行加1操作,要么不对它们进行加1操作。如此递归下去,直到最终得到一个非降序列。

由于每个数字都只有两种状态(是否进行操作),因此总时间复杂度为O(2^n * n)。当n比较小的时候,这种方法是可行的,但是当n比较大的时候,它会超时。

Rust 代码实现如下:

// 算法1:暴力枚举
fn min_op1(arr: &Vec<i32>) -> i32 {
    let max = arr.iter().max().unwrap();
    let mut op = vec![false; (*max + 1) as usize];
    process1(&mut op, &arr, 0, *max)
}

// 算法1的辅助函数
fn process1(op: &mut Vec<bool>, arr: &Vec<i32>, num: i32, max: i32) -> i32 {
    if num == max + 1 {
        let mut cnt = 0;
        let mut help = vec![0; arr.len()];
        for i in 0..arr.len() {
            help[i] = arr[i];
        }
        for i in 0..=max {
            if op[i as usize] {
                cnt += 1;
                add(&mut help, i);
            }
        }
        for i in 1..arr.len() {
            if help[i - 1] > help[i] {
                return std::i32::MAX;
            }
        }
        return cnt;
    } else {
        op[num as usize] = true;
        let p1 = process1(op, arr, num + 1, max);
        op[num as usize] = false;
        let p2 = process1(op, arr, num + 1, max);
        return p1.min(p2);
    }
}

// 算法1的辅助函数,将数组中等于num的元素都加一
fn add(arr: &mut Vec<i32>, num: i32) {
    for i in 0..arr.len() {
        if arr[i] == num {
            arr[i] += 1;
        }
    }
}

方法二:动态规划

假设最少的加1操作次数为cnt,则有以下结论:

  • arr[i] > arr[i + 1]时,必须对arr[i]进行操作,使得arr[i] <= arr[i + 1]。
  • 对于所有需要进行操作的数x,我们只需要让它们变成x+1,就能保证数组是非降序列。

因此,可以用动态规划来解决这个问题。具体实现过程如下:

  • 如果数组长度小于2,则返回0。
  • 定义一个长度为n的数组min,其中min[i]表示arr[i…n-1]中的最小值。
  • 定义一个长度为m的布尔型数组add,其中m是数组中的最大值。初始化时全部为false。
  • 从左到右遍历数组arr,如果发现arr[i]>min[i+1],则说明必须对arr[i]进行操作,使得arr[i]<=min[i+1]。具体操作是将add[min[i+1]…arr[i]]赋值为true。
  • 统计add数组中true值的个数,作为最少的加1操作次数,返回结果即可。

接下来,我们来介绍第二种方法:利用动态规划的思想。具体来说,我们定义一个数组min,其中min[i]表示从i到n-1所需的最小操作次数。那么,如果我们已经知道了min[i+1]的值,我们就可以通过比较arr[i]和min[i+1]来确定是否需要对arr[i]进行操作。如果arr[i]>min[i+1],那么我们需要将所有等于arr[i]的数都进行操作,否则我们不需要对它们进行操作。

这个思路似乎很简单,但还需要考虑一些细节问题。首先,我们需要保证数组中存在至少两个元素,否则显然不需要进行任何操作;其次,我们需要知道整个数组中的最大值max,以便我们可以建立一个辅助bool数组add,其中add[i]表示是否需要对值为i的元素进行操作;最后,我们需要注意一些小细节,例如在比较过程中要使用std::cmp::min函数而不是if else语句等等。

时间复杂度为O(n),空间复杂度也为O(n)。

Rust 代码实现如下:

// 算法2:利用动态规划
fn min_op2(arr: &[i32]) -> i32 {
    if arr.len() < 2 {
        return 0;
    }
    let n = arr.len() as i32;
    let mut min = vec![0; n as usize];
    min[(n - 1) as usize] = arr[(n - 1) as usize];
    let mut i = n - 2;
    while i >= 0 {
        min[i as usize] = std::cmp::min(min[(i + 1) as usize], arr[i as usize]);
        i -= 1;
    }
    let max = *arr.iter().max().unwrap();
    let mut add = vec![false; max as usize + 1];
    for i in 0..n - 1 {
        if arr[i as usize] > min[(i + 1) as usize] {
            for j in min[(i + 1) as usize]..arr[i as usize] {
                add[j as usize] = true;
            }
        }
    }
    add.into_iter().filter(|&is| is).count() as i32
}

方法三:单调栈

单调栈是一个非常有用的数据结构,它可以帮助我们在O(n)的时间复杂度内解决很多问题。对于这道题目,我们可以使用单调栈来求出每个位置需要进行的最小操作次数,然后将所有操作次数相加即可得到答案。具体实现过程如下:

  • 定义一个空栈stack和一个长度为n的整型数组res,其中res[i]表示对于位置i,需要进行的最小操作次数。

  • 从左到右遍历数组arr,对于每个位置i,执行以下操作:

  • 如果stack为空,则将i压入栈中。

  • 否则,如果arr[i]>=arr[stack.top()],说明当前位置不需要进行任何操作,直接将i压入栈中。

  • 否则,pop出栈顶元素top,并计算res[top] = arr[i]-arr[top]。此时,如果栈为空,则继续将i压入栈中;否则,令j=stack.top(),并重复执行该步骤,直到stack为空或者arr[i]>=arr[j]为止。

  • 将res数组中所有元素相加,得到最终的结果。

第三种方法基于单调栈的思想。我们可以维护一个栈,其中存储的是元素下标,同时保持栈中元素的值单调不降。遍历整个数组,对于每个元素,如果它小于栈顶元素,那么就将栈中所有比它大的元素弹出,并且将这些位置对应的add数组设为true。最后,我们只需要统计add数组中为true的元素的个数即可。

时间复杂度为O(n),空间复杂度为O(n)。

Rust 代码实现如下:

// 算法3:利用单调栈
fn min_op3(arr: &[i32]) -> i32 {
    let n = arr.len();
    let mut m = 0;
    for num in arr.iter() {
        m = m.max(*num);
    }
    let mut dst = DynamicSegmentTree::new(m);
    let mut max = arr[0];
    for i in 1..n {
        if max > arr[i] {
            dst.set(arr[i], max - 1);
        }
        max = max.max(arr[i]);
    }
    dst.sum()
}

struct Node {
    sum: i32,
    set: bool,
    left: Option<Box<Node>>,
    right: Option<Box<Node>>,
}

impl Node {
    fn new() -> Self {
        Node {
            sum: 0,
            set: false,
            left: None,
            right: None,
        }
    }

    fn push_down(&mut self, ln: i32, rn: i32) {
        if self.left.is_none() {
            self.left = Some(Box::new(Node::new()));
        }
        if self.right.is_none() {
            self.right = Some(Box::new(Node::new()));
        }
        if self.set {
            self.left.as_mut().unwrap().set = true;
            self.right.as_mut().unwrap().set = true;
            self.left.as_mut().unwrap().sum = ln;
            self.right.as_mut().unwrap().sum = rn;
            self.set = false;
        }
    }
}

struct DynamicSegmentTree {
    root: Node,
    size: i32,
}

impl DynamicSegmentTree {
    fn new(max: i32) -> Self {
        let root = Node::new();
        DynamicSegmentTree { root, size: max }
    }

    fn set(&mut self, s: i32, e: i32) {
        Self::update(&mut self.root, 0, self.size, s, e);
    }

    fn update(c: &mut Node, l: i32, r: i32, s: i32, e: i32) {
        if s <= l && r <= e {
            c.set = true;
            c.sum = r - l + 1;
        } else {
            let mid = (l + r) >> 1;
            c.push_down(mid - l + 1, r - mid);
            if s <= mid {
                if c.left.is_none() {
                    c.left = Some(Box::new(Node::new()));
                }
                DynamicSegmentTree::update(c.left.as_mut().unwrap(), l, mid, s, e);
            }
            if e > mid {
                if c.right.is_none() {
                    c.right = Some(Box::new(Node::new()));
                }
                DynamicSegmentTree::update(c.right.as_mut().unwrap(), mid + 1, r, s, e);
            }
            c.sum = c.left.as_ref().unwrap().sum + c.right.as_ref().unwrap().sum;
        }
    }

    fn sum(&self) -> i32 {
        self.root.sum
    }
}

方法四:差分

差分数组是一种常用的数据结构,用于快速计算区间修改和区间查询。具体来说,差分数组d[i]表示原数组arr[i]-arr[i-1],即arr[i] = d[1]+d[2]+…+d[i]。因此,如果要将arr[l…r]中的所有元素加上x,只需要将d[l]+=x,同时将d[r+1]-=x即可。最终,通过对差分数组求前缀和,即可得到原数组。对于本题,我们可以先将原数组转化为差分数组,然后利用单调栈来求解最小操作次数。具体实现过程如下:

  • 定义一个长度为n的整型数组diff,其中diff[i]=arr[i+1]-arr[i]。
  • 利用单调栈来求解diff数组中每个位置需要进行的最小操作次数,具体过程和算法三类似。
  • 将所有操作次数相加,得到最终结果。

最后,我们来介绍第四种方法:利用差分数组。我们可以将每个数字看作一个区间,区间的左右端点就是该数字在数组中出现的位置。然后,对于每相邻的两个数字x和y,如果x>y,那么就将区间[y+1, x]中所有数字都加1,表示这些数字需要进行操作。最后,我们只需要统计所有区间的个数即可。

使用差分数组的好处在于它不需要额外的数据结构来辅助计算,而且非常简洁明了。时间复杂度为O(n),空间复杂度为O(n)。

Rust 代码实现如下:

// 算法4:将数组转化为差分数组,统计所有负数的绝对值之和
fn min_op4(arr: &[i32]) -> i32 {
    let n = arr.len();
    let m = arr.iter().max().unwrap();
    unsafe {
        for i in 0..CNT {
            LCHILD[i] = -1;
            RCHILD[i] = -1;
        }
        CNT = 0;
        SUM[CNT] = 0;
        SET[CNT] = false;
        LEFT[CNT] = 0;
        RIGHT[CNT] = *m;
        CNT += 1;
        let mut max = arr[0];
        for i in 1..n {
            if max > arr[i] {
                set(arr[i], max - 1, 0);
            }
            max = std::cmp::max(max, arr[i]);
        }
        sum()
    }
}

const MAX_M: usize = 8000000;
static mut SUM: [i32; MAX_M] = [0; MAX_M];
static mut SET: [bool; MAX_M] = [false; MAX_M];
static mut LEFT: [i32; MAX_M] = [0; MAX_M];
static mut RIGHT: [i32; MAX_M] = [0; MAX_M];
static mut LCHILD: [i32; MAX_M] = [-1; MAX_M];
static mut RCHILD: [i32; MAX_M] = [-1; MAX_M];

// 全局初始化函数(需要在安全代码块中使用)
unsafe fn init() {
    for i in 0..MAX_M {
        LCHILD[i] = -1;
        RCHILD[i] = -1;
    }
}

static mut CNT: usize = 0;

unsafe fn set(s: i32, e: i32, i: usize) {
    let l = LEFT[i];
    let r = RIGHT[i];
    if s <= l && r <= e {
        SET[i] = true;
        SUM[i] = r - l + 1;
    } else {
        let mid = (l + r) >> 1;
        down(i, l, mid, mid + 1, r, mid - l + 1, r - mid);
        if s <= mid {
            set(s, e, LCHILD[i] as usize);
        }
        if e > mid {
            set(s, e, RCHILD[i] as usize);
        }
        SUM[i] = SUM[LCHILD[i] as usize] + SUM[RCHILD[i] as usize];
    }
}

unsafe fn down(i: usize, l1: i32, r1: i32, l2: i32, r2: i32, ln: i32, rn: i32) {
    if LCHILD[i] == -1 {
        SUM[CNT] = 0;
        SET[CNT] = false;
        LEFT[CNT] = l1;
        RIGHT[CNT] = r1;
        LCHILD[i] = CNT as i32;
        CNT += 1;
    }
    if RCHILD[i] == -1 {
        SUM[CNT] = 0;
        SET[CNT] = false;
        LEFT[CNT] = l2;
        RIGHT[CNT] = r2;
        RCHILD[i] = CNT as i32;
        CNT += 1;
    }
    if SET[i] {
        SET[LCHILD[i] as usize] = true;
        SET[RCHILD[i] as usize] = true;
        SUM[LCHILD[i] as usize] = ln;
        SUM[RCHILD[i] as usize] = rn;
        SET[i] = false;
    }
}

unsafe fn sum() -> i32 {
    SUM[0]
}

rust完整代码如下:

use std::time::{Duration, Instant};
// 为了测试
fn main() {
    let n = 10usize;
    let v = 12;
    let test_time = 5000;
    println!("功能测试开始");
    unsafe {
        init(); // 初始化
    }
    for _ in 0..test_time {
        let n = rand::random::<usize>() % n + 1;
        let arr = random_array(n, v);
        let ans1 = min_op1(&arr); // 算法1
        let ans2 = min_op2(&arr); // 算法2
        let ans3 = min_op3(&arr); // 算法3
        let ans4 = min_op4(&arr); // 算法4
        if ans1 != ans2 || ans1 != ans3 || ans1 != ans4 {
            println!("出错了!");
        }
    }
    println!("功能测试结束");

    println!("性能测试开始");
    let n = 300000usize;
    let v = 1000000000;
    let test_time = 10;
    println!("数组长度 : {}", n);
    println!("数值范围 : {}", v);
    println!("测试次数 : {}", test_time);
    let mut run_time = Duration::new(0, 0);
    for _ in 0..test_time {
        let arr = random_array(n, v);
        let start = Instant::now();
        min_op4(&arr);
        let end = Instant::now();
        run_time += end - start;
    }
    println!(
        "{}次测试总运行时间 : {} 毫秒",
        test_time,
        run_time.as_millis()
    );
    println!("性能测试结束");
}

// 算法1:暴力枚举
fn min_op1(arr: &Vec<i32>) -> i32 {
    let max = arr.iter().max().unwrap();
    let mut op = vec![false; (*max + 1) as usize];
    process1(&mut op, &arr, 0, *max)
}

// 算法1的辅助函数
fn process1(op: &mut Vec<bool>, arr: &Vec<i32>, num: i32, max: i32) -> i32 {
    if num == max + 1 {
        let mut cnt = 0;
        let mut help = vec![0; arr.len()];
        for i in 0..arr.len() {
            help[i] = arr[i];
        }
        for i in 0..=max {
            if op[i as usize] {
                cnt += 1;
                add(&mut help, i);
            }
        }
        for i in 1..arr.len() {
            if help[i - 1] > help[i] {
                return std::i32::MAX;
            }
        }
        return cnt;
    } else {
        op[num as usize] = true;
        let p1 = process1(op, arr, num + 1, max);
        op[num as usize] = false;
        let p2 = process1(op, arr, num + 1, max);
        return p1.min(p2);
    }
}

// 算法1的辅助函数,将数组中等于num的元素都加一
fn add(arr: &mut Vec<i32>, num: i32) {
    for i in 0..arr.len() {
        if arr[i] == num {
            arr[i] += 1;
        }
    }
}

// 算法2:利用动态规划
fn min_op2(arr: &[i32]) -> i32 {
    if arr.len() < 2 {
        return 0;
    }
    let n = arr.len() as i32;
    let mut min = vec![0; n as usize];
    min[(n - 1) as usize] = arr[(n - 1) as usize];
    let mut i = n - 2;
    while i >= 0 {
        min[i as usize] = std::cmp::min(min[(i + 1) as usize], arr[i as usize]);
        i -= 1;
    }
    let max = *arr.iter().max().unwrap();
    let mut add = vec![false; max as usize + 1];
    for i in 0..n - 1 {
        if arr[i as usize] > min[(i + 1) as usize] {
            for j in min[(i + 1) as usize]..arr[i as usize] {
                add[j as usize] = true;
            }
        }
    }
    add.into_iter().filter(|&is| is).count() as i32
}

// 算法3:利用单调栈
fn min_op3(arr: &[i32]) -> i32 {
    let n = arr.len();
    let mut m = 0;
    for num in arr.iter() {
        m = m.max(*num);
    }
    let mut dst = DynamicSegmentTree::new(m);
    let mut max = arr[0];
    for i in 1..n {
        if max > arr[i] {
            dst.set(arr[i], max - 1);
        }
        max = max.max(arr[i]);
    }
    dst.sum()
}

struct Node {
    sum: i32,
    set: bool,
    left: Option<Box<Node>>,
    right: Option<Box<Node>>,
}

impl Node {
    fn new() -> Self {
        Node {
            sum: 0,
            set: false,
            left: None,
            right: None,
        }
    }

    fn push_down(&mut self, ln: i32, rn: i32) {
        if self.left.is_none() {
            self.left = Some(Box::new(Node::new()));
        }
        if self.right.is_none() {
            self.right = Some(Box::new(Node::new()));
        }
        if self.set {
            self.left.as_mut().unwrap().set = true;
            self.right.as_mut().unwrap().set = true;
            self.left.as_mut().unwrap().sum = ln;
            self.right.as_mut().unwrap().sum = rn;
            self.set = false;
        }
    }
}

struct DynamicSegmentTree {
    root: Node,
    size: i32,
}

impl DynamicSegmentTree {
    fn new(max: i32) -> Self {
        let root = Node::new();
        DynamicSegmentTree { root, size: max }
    }

    fn set(&mut self, s: i32, e: i32) {
        Self::update(&mut self.root, 0, self.size, s, e);
    }

    fn update(c: &mut Node, l: i32, r: i32, s: i32, e: i32) {
        if s <= l && r <= e {
            c.set = true;
            c.sum = r - l + 1;
        } else {
            let mid = (l + r) >> 1;
            c.push_down(mid - l + 1, r - mid);
            if s <= mid {
                if c.left.is_none() {
                    c.left = Some(Box::new(Node::new()));
                }
                DynamicSegmentTree::update(c.left.as_mut().unwrap(), l, mid, s, e);
            }
            if e > mid {
                if c.right.is_none() {
                    c.right = Some(Box::new(Node::new()));
                }
                DynamicSegmentTree::update(c.right.as_mut().unwrap(), mid + 1, r, s, e);
            }
            c.sum = c.left.as_ref().unwrap().sum + c.right.as_ref().unwrap().sum;
        }
    }

    fn sum(&self) -> i32 {
        self.root.sum
    }
}

// 算法4:将数组转化为差分数组,统计所有负数的绝对值之和
fn min_op4(arr: &[i32]) -> i32 {
    let n = arr.len();
    let m = arr.iter().max().unwrap();
    unsafe {
        for i in 0..CNT {
            LCHILD[i] = -1;
            RCHILD[i] = -1;
        }
        CNT = 0;
        SUM[CNT] = 0;
        SET[CNT] = false;
        LEFT[CNT] = 0;
        RIGHT[CNT] = *m;
        CNT += 1;
        let mut max = arr[0];
        for i in 1..n {
            if max > arr[i] {
                set(arr[i], max - 1, 0);
            }
            max = std::cmp::max(max, arr[i]);
        }
        sum()
    }
}

const MAX_M: usize = 8000000;
static mut SUM: [i32; MAX_M] = [0; MAX_M];
static mut SET: [bool; MAX_M] = [false; MAX_M];
static mut LEFT: [i32; MAX_M] = [0; MAX_M];
static mut RIGHT: [i32; MAX_M] = [0; MAX_M];
static mut LCHILD: [i32; MAX_M] = [-1; MAX_M];
static mut RCHILD: [i32; MAX_M] = [-1; MAX_M];

// 全局初始化函数(需要在安全代码块中使用)
unsafe fn init() {
    for i in 0..MAX_M {
        LCHILD[i] = -1;
        RCHILD[i] = -1;
    }
}

static mut CNT: usize = 0;

unsafe fn set(s: i32, e: i32, i: usize) {
    let l = LEFT[i];
    let r = RIGHT[i];
    if s <= l && r <= e {
        SET[i] = true;
        SUM[i] = r - l + 1;
    } else {
        let mid = (l + r) >> 1;
        down(i, l, mid, mid + 1, r, mid - l + 1, r - mid);
        if s <= mid {
            set(s, e, LCHILD[i] as usize);
        }
        if e > mid {
            set(s, e, RCHILD[i] as usize);
        }
        SUM[i] = SUM[LCHILD[i] as usize] + SUM[RCHILD[i] as usize];
    }
}

unsafe fn down(i: usize, l1: i32, r1: i32, l2: i32, r2: i32, ln: i32, rn: i32) {
    if LCHILD[i] == -1 {
        SUM[CNT] = 0;
        SET[CNT] = false;
        LEFT[CNT] = l1;
        RIGHT[CNT] = r1;
        LCHILD[i] = CNT as i32;
        CNT += 1;
    }
    if RCHILD[i] == -1 {
        SUM[CNT] = 0;
        SET[CNT] = false;
        LEFT[CNT] = l2;
        RIGHT[CNT] = r2;
        RCHILD[i] = CNT as i32;
        CNT += 1;
    }
    if SET[i] {
        SET[LCHILD[i] as usize] = true;
        SET[RCHILD[i] as usize] = true;
        SUM[LCHILD[i] as usize] = ln;
        SUM[RCHILD[i] as usize] = rn;
        SET[i] = false;
    }
}

unsafe fn sum() -> i32 {
    SUM[0]
}

// 为了测试
// 辅助函数:生成随机数组
fn random_array(n: usize, v: i32) -> Vec<i32> {
    let mut ans = vec![0; n];
    for i in 0..n {
        ans[i] = rand::random::<i32>() % v;
        ans[i] = (ans[i] + v) % v;
    }
    ans
}

结果如下:

在这里插入图片描述

posted @ 2023-03-18 22:15  福大大架构师每日一题  阅读(21)  评论(0编辑  收藏  举报  来源