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

最新推荐文章于 2023-04-16 18:53:19 发布
最新推荐文章于 2023-04-16 18:53:19 发布
阅读量3.2k 收藏
点赞数 1
分类专栏： 福大大架构师每日一题 文章标签： rust 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48502062/article/details/129643546
版权

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
}

结果如下：

在这里插入图片描述

福大大架构师每日一题
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
group-array-elements：一个Javascript函数，给定一个长度> = 0的数组，并给出一个正整数N，该数组的内容返回分成N个大小相等的数组（组）的数组
02-08
描述 //function groupArrayElements(array, groupCount) groupArrayElements ( [ 1 , 2 , 3 , 4 , 5 ] , 3 ) ; // => [ [ 1, 2 ], [ 3, 4 ], [ 5 ] ] 一个给定长度> = 0的数组和一个正整数N的Javascript函数，该函数返回分为N个大小相等的数组（组）的数组内容。 如果数组未完全除以N，则最后一组将包含其余部分，并且在保持其他组均匀大小的同时，将其大小最小化。 如果数组长度为零或groupCount小于一，则返回一个空数组。 例子 const groupArrayElements = require ( './groupArrayElements' ) groupArrayElements ( [ 1 , 2 , 3 , 4 , 5 ] , 3 ) /
fill-array:通过重复其元素将数组填充到给定长度。 这是一个非常快的实现
06-28
填充数组 通过重复其元素将数组填充到给定长度。 这是一个非常快速的实现。 使用安装 npm i fill-array --save 用法 var fill = require ( 'fill-array' ) ; fill ( [ 'a' , 'b' , 'c' ] , 10 ) ; //=> ['a','b','c','a','b','c','a','b','c','a'] 运行测试 安装开发依赖： npm i -d && npm test 贡献 拉取请求和星星总是受欢迎的。 对于错误和功能请求， 作者 乔恩·施林克特 执照 版权所有 (c) 2015，乔恩·施林克特。 在 MIT 许可下发布 该文件由于 2015 年 1 月 26 日生成。
js代码-力扣53-给定一个数组，找到具有最大和的连续子数组
07-15
js代码-力扣53-给定一个数组，找到具有最大和的连续子数组
Latex Figure 输出：给定一个值、数组、方程或方程数组。 这个程序会输出一个想要的图-matlab开发
06-01
允许将值、数组、方程或方程数组的基本输出转换为用户定义大小的图形，以供用户保存。 可以输出符号值和数组。 输出的大小适合图形大小。 当前限制是由于 1300 个字符的最大乳胶输出长度。
最大子数组问题（延伸最大子矩阵问题）
weixin_45482816的博客
08-13 154
题目如标题，一个数组中求子数组和的最大值。 分析： （1）数组全为非负数，则解为数组所有值的和。 （2）数组全为负数，则解为数组中最大的成员的值。 （3）数组含有负数和非负数，最普遍的情况。 解法： 1.技巧型，通过假设。假如我们要找的子数组即是和最大的，也是长度最长的。 那么这个数组应该满足以下性质： （1）i至k（k<j）的任何一个数组，其和都应该不小于0。因为若小于零那就应该从k+1开始到j才能满足最大子数组的要求。 （2）以i-1为尾部的任一个数组，其和都应该小于0，同理。 所以我们运用一个
非连续递增子区间元素个数——使数组 K 递增的最少操作次数
qq_36822894的博客
12-28 443
题目描述 给你一个下标从 0开始包含 n个正整数的数组arr，和一个正整数k。 如果对于每个满足k <= i <= n-1的下标i，都有arr[i-k] <= arr[i]，那么我们称arr是 K递增 的。 比方说，arr = [4, 1, 5, 2, 6, 2]对于k = 2是 K 递增的，因为： arr[0] <= arr[2] (4 <= 5) arr[1] <= arr[3] (1 <= 2) arr[2] &lt...
C语言刷题之动态规划入门(三)
忆梦初心的博客
12-15 1255
C语言刷题之动态规划入门(三)
每日一练python22
qq_52669357的博客
11-29 797
题目：（最小操作次数使数组元素相等）给你一个长度为 n 的整数数组，每次操作将会使 n - 1 个元素增加 1 。返回让数组所有元素相等的最小操作次数。 示例 1： 输入：nums = [1,2,3] 输出：3 解释： 只需要3次操作（注意每次操作会增加两个元素的值）： [1,2,3] => [2,3,3] => [3,4,3] => [4,4,4] 示例 2： 输入：nums = [1,1,1] 输出：0 程序说明： 1、找到其规律，发现可以将其他数减去最小值的差相加便可得
2023-04-16：给定一个长度为N的数组，值一定在0~N-1范围，且每个值不重复 比如，arr = [4, 2, 0, 3, 1] 0 1 2 3 4 把0想象成洞
最新发布
福大大架构师每日一题
04-16 2912
2023-04-16：给定一个长度为N的数组，值一定在0~N-1范围，且每个值不重复比如，arr = [4, 2, 0, 3, 1]把0想象成洞，任何非0数字都可以来到这个洞里，然后在原本的位置留下洞比如4这个数字，来到0所代表的洞里，那么数组变成 :也就是原来的洞被4填满，4走后留下了洞任何数字只能搬家到洞里，并且走后留下洞通过搬家的方式，想变成有序的，有序有两种形式比如arr = [4, 2, 0, 3, 1]，变成。
求最长连续子数组问题
行者小朱的博客
09-17 3295
题意描述：题目意思是说给定一个数数组num[]和一个值key，求满足和为key最长的子数组的长度【与求连续子数组的最大和互为姊妹题】 解题思路：暴力解法肯定可以求解，如下所示： int getMaxLengthForce(int[] arr, int k) { int res = 0; for (int i = 0; i < arr.length; i++) { int sum...
leetcode209-LeetCode209_Minimum_Size_Subarray_Sum:给定一个整型数组和一个数字s,找到数组中最
07-06
leetcode209 ...给定一个整型数组和一个数字s,找到数组中最短的一个连续子数组， 使得连续子数组的数字和sum>=s,返回这个最短的连续子数组的长度值， 如：给定数组[2,3,1,2,4,3],s=7 答案为[4,3],返回2
连续子数组的最大和以及变形
qq_43430343的博客
10-15 278
题目一： 输入一个整形数组，数组里有正数也有负数。 数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。 求所有子数组的和的最大值 思路： 创建一个新数组B用于存放数组i之前的最大子数组的和，从前往后遍历原数组A，计算数组A当前i元素的值+B数组的i-1元素的值的和 与数组A当前元素的值比较大小，选择大的存放在数组B中。最后数组B中最大的元素就是连续子数组的最大和 题目二 输入一个整数数组，任意连续的两个或多个整数为一个子数组，求子数组的最大和。 思路： 这道题和上道题的不同在于这道题规定了子数
[树状数组] 基础
烟尘的博客
12-26 196
问题引入 我们先来看这样一道题： 现在有一个长度为n的数列a，我们要对数列进行m次操作，操作分为两种，对其中第k个元素进行修改，或者是计算出数列中一个区间[l，r]中所有元素的和 很容易想到用前缀和的思想，即用一个sum数组，sum[i]表示第1个元素到第i个元素的和，那么此时要求区间[l，r]中所有元素的值就可以写为sum[r]-sum[l-1] 但如果数据范围太大，岂不是就会超时了吗？...
Java代码题m个小朋友分糖果,巧解“博弈”型算法题：分糖果问题
weixin_35663032的博客
03-21 868
问题导入【题目：】 给定一个偶数长度的数组，其中不同的数字代表着不同种类的糖果，每一个数字代表一个糖果。你需要把这些糖果平均分给一个弟弟和一个妹妹。返回妹妹可以获得的最大糖果的种类数。示例 1:输入: candies = [1,1,2,2,3,3]输出: 3解析: 一共有三种种类的糖果，每一种都有两个。最优分配方案：妹妹获得[1,2,3],弟弟也获得[1,2,3]。这样使妹妹获得糖果的种类数最多。...
力扣453. 最小操作次数使数组元素相等（简单）
FG_future的博客
10-20 622
属实是了   给你一个长度为 n 的整数数组，每次操作将会使 n - 1 个元素增加 1 。返回让数组所有元素相等的最小操作次数。 示例 1： 输入：nums = [1,2,3] 输出：3 解释： 只需要3次操作（注意每次操作会增加两个元素的值）： [1,2,3] => [2,3,3] => [3,4,3] => [4,4,4] 示例 2： 输入：nums = [1,1,1] 输出：0 刚开始一看到，内心的想法是：嗯？这么简洁的题目嘛？ 仔细看后：
给定一个长度为n的数组，找出只有一个出现奇数次的数。
weixin_42557481的博客
07-30 1678
给定一个n长度的数组，数组中只有一个数出现奇数次。 直接用异或 public static int getNum (int[] nums) { int res = 0; for (int num : nums) { res ^= num; } return res; }
LeetCode高频题：最少经过几次操作可以使数组变为非降序状态
weixin_46838716的博客
07-23 3424
1）本题难就难在怎么想解法，你要将其变为非递减状态，原来那个数组排序后位置动过的最长递增那个子数组，是不需要动的，它的长度就是不动的长度 2）N-这个最长严格递增子序列长度就是我们要动的其他位置，难想但是见过，下次就明白了 3）另外，我们不求这个题，单独求最长递增子序列长度怎么求，那个题很经典，也很困难，要学学 3）笔试求AC，可以不考虑空间复杂度，但是面试既要考虑时间复杂度最优，也要考虑空间复杂度最优。...
【LeetCode 128】最长连续序列——Python解决
oyall520的博客
06-06 891
1. 题目描述 给定一个未排序的整数数组，找出最长连续序列的长度。 要求算法的时间复杂度为 O(n)。 示例: 输入: [100, 4, 200, 1, 3, 2] 输出: 4 解释: 最长连续序列是 [1, 2, 3, 4]。它的长度为 4。 2. 思路 （1）先去重，将数组转变成集合（可以直接使用set(nums)，或者遍历数组，将每一个元素添加到集合Set中） （2）遍历整个集合中的数x，若x-1不在集合里，说明x是一个新的序列起点，然后就看y = x+1, x+2, x+3……是否在集合里。当y不
2111. 使数组 K 递增的最少操作次数
Cauchy的博客
12-22 692
2111. 使数组 K 递增的最少操作次数 目录1. 题意2. 算法3. 思路代码 1. 题意 给定一个数组 arr ，给定一个数 k ，对数组任意位置任意元素进行修改，使得其满足： arr[i−k]<=arr[i]{arr[i - k] <= arr[i]}arr[i−k]<=arr[i] 求其最少修改次数 2. 算法 3. 思路 代码 ...
给定n个整数的数组a以及一个数x，用分治法求x在数组中出现的次数。
03-27
分治法的思想是将问题分解成若干个子问题，然后递归地解决这些子问题，最后将子问题的解合并起来得到原问题的解。对于这个问题，我们可以将数组分为两半，分别递归地处理左半部分和右半部分，最后将左半部分和右半部分的结果合并起来。 具体地，假设数组a的长度为n，我们可以将a分为两个长度分别为n/2的子数组a1和a2。然后递归地求解x在a1中出现的次数cnt1和x在a2中出现的次数cnt2。最后，x在a中出现的次数cnt等于cnt1加上cnt2。 递归基：当a的长度为1时，如果a[0]等于x，则cnt为1，否则cnt为0。 下面是代码实现： ```python def count_x_in_array(a, x): n = len(a) if n == 1: if a[0] == x: return 1 else: return 0 else: mid = n // 2 a1 = a[:mid] a2 = a[mid:] cnt1 = count_x_in_array(a1, x) cnt2 = count_x_in_array(a2, x) return cnt1 + cnt2 ``` 时间复杂度为O(nlogn)，空间复杂度为O(logn)。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

福大大架构师每日一题

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值