给定一个数组arr，长度为N，arr中所有的值都在1~K范围上，你可以删除数字，目的是让arr的最长递增子序列长度小于K。返回至少删除几个数字能达到目的。-天翼云

给定一个数组arr，长度为N，arr中所有的值都在1~K范围上，你可以删除数字，目的是让arr的最长递增子序列长度小于K。返回至少删除几个数字能达到目的。

2024-05-09 09:22:03 阅读次数：42

给定一个数组arr，长度为N，arr中所有的值都在1~K范围上，
你可以删除数字，目的是让arr的最长递增子序列长度小于K。
返回至少删除几个数字能达到目的。
N <= 10^4，K <= 10^2。

动态规划。
时间复杂度：O(NK)。
额外空间复杂度：O(NK)。
rust和typescript的代码都有。

代码用rust编写。代码如下：

use rand::Rng;
fn main() {
    let nn: i32 = 15;
    let kk: i32 = 6;
    let test_time: i32 = 10000;
    println!("测试开始");
    for _ in 0..test_time {
        let len = rand::thread_rng().gen_range(0, nn) + 1;
        let k = rand::thread_rng().gen_range(0, kk) + 1;
        let mut arr = random_array(len, k);
        let ans1 = min_remove1(&mut arr, k);
        let ans2 = min_remove2(&mut arr, k);
        if ans1 != ans2 {
            println!("ans1 = {:?}", ans1);
            println!("ans2 = {:?}", ans2);
            println!("出错了!");
            break;
        }
    }
    println!("测试结束");
}

// 暴力方法
// 为了验证
fn min_remove1(arr: &mut Vec<i32>, k: i32) -> i32 {
    let mut path0: Vec<i32> = vec![];
    for _ in 0..arr.len() {
        path0.push(0);
    }
    return process1(arr, 0, &mut path0, 0, k);
}

const MAX_VALUE: i32 = 2 << 31 - 1;

fn process1(arr: &mut Vec<i32>, index: i32, path0: &mut Vec<i32>, size: i32, k: i32) -> i32 {
    if index == arr.len() as i32 {
        return if length_of_lis(path0, size) < k {
            arr.len() as i32 - size
        } else {
            MAX_VALUE
        };
    } else {
        let p1 = process1(arr, index + 1, path0, size, k);
        path0[size as usize] = arr[index as usize];
        let p2 = process1(arr, index + 1, path0, size + 1, k);
        return get_min(p1, p2);
    }
}

fn get_min<T: Clone + Copy + std::cmp::PartialOrd>(a: T, b: T) -> T {
    if a < b {
        a
    } else {
        b
    }
}

fn get_max<T: Clone + Copy + std::cmp::PartialOrd>(a: T, b: T) -> T {
    if a > b {
        a
    } else {
        b
    }
}

fn length_of_lis(arr: &mut Vec<i32>, size: i32) -> i32 {
    if size == 0 {
        return 0;
    }
    let mut ends: Vec<i32> = vec![];
    for _ in 0..size {
        ends.push(0);
    }
    ends[0] = arr[0];
    let mut right: i32 = 0;
    let mut l;
    let mut r;
    let mut m;
    let mut max = 1;
    for i in 1..size {
        l = 0;
        r = right;
        while l <= r {
            m = (l + r) / 2;
            if arr[i as usize] > ends[m as usize] {
                l = m + 1;
            } else {
                r = m - 1;
            }
        }
        right = get_max(right, l);
        ends[l as usize] = arr[i as usize];
        max = get_max(max, l + 1);
    }
    return max;
}

// arr[0...index-1]上，选择了一些数字，之前的决定！
// len长度了！len = 3 ： 1 2 3
// arr[index....]是能够决定的，之前的，已经不能再决定了
// 返回：让最终保留的数字，凑不足k长度的情况下，至少要删几个！
fn zuo(arr: &mut Vec<i32>, index: i32, len: i32, k: i32) -> i32 {
    if len == k {
        return MAX_VALUE;
    }
    // 凑的(1...len)还不到(1...k)
    if index == arr.len() as i32 {
        return 0;
    }
    // 没凑到 < k, 有数字!
    let cur = arr[index as usize];
    // 可能性1：保留
    // 可能性2：删除
    // 1...3 3
    if len >= cur || len + 1 < cur {
        return zuo(arr, index + 1, len, k);
    }
    // 1..3  4
    // len + 1  == cur
    // 可能性1：保留
    let p1 = zuo(arr, index + 1, len + 1, k);
    // 可能性2：删除
    let mut p2 = MAX_VALUE;
    let next2 = zuo(arr, index + 1, len, k);
    if next2 != MAX_VALUE {
        p2 = 1 + next2;
    }
    return get_min(p1, p2);
}

// 正式方法
// 时间复杂度O(N*K)
fn min_remove2(arr: &mut Vec<i32>, k: i32) -> i32 {
    let n = arr.len() as i32;
    let mut dp: Vec<Vec<i32>> = vec![];
    for i in 0..n {
        dp.push(vec![]);
        for _ in 0..k {
            dp[i as usize].push(0);
        }
    }
    for i in 0..n {
        for j in 0..k {
            dp[i as usize][j as usize] = -1;
        }
    }
    return process2(arr, k, 0, 0, &mut dp);
}

fn process2(arr: &mut Vec<i32>, k: i32, index: i32, range: i32, dp: &mut Vec<Vec<i32>>) -> i32 {
    if range == k {
        return MAX_VALUE;
    }
    if index == arr.len() as i32 {
        return 0;
    }
    if dp[index as usize][range as usize] != -1 {
        return dp[index as usize][range as usize];
    }
    let mut ans: i32;
    if arr[index as usize] == range + 1 {
        let mut p1 = process2(arr, k, index + 1, range, dp);
        p1 += if p1 != MAX_VALUE { 1 } else { 0 };
        let p2 = process2(arr, k, index + 1, range + 1, dp);
        ans = get_min(p1, p2);
    } else {
        ans = process2(arr, k, index + 1, range, dp);
    }
    dp[index as usize][range as usize] = ans;
    return ans;
}

// 为了测试
fn random_array(len: i32, k: i32) -> Vec<i32> {
    let mut arr: Vec<i32> = vec![];
    for _ in 0..len {
        arr.push(rand::thread_rng().gen_range(0, k) + 1);
    }
    return arr;
}

执行结果如下：

2022-08-06：给定一个数组arr，长度为N，arr中所有的值都在1~K范围上，你可以删除数字，目的是让arr的最长递增子序列长度小于K。返回至少删除几个数字能达到目的。 N ＜= 10^4

代码用typescript编写。代码如下：

// 暴力方法
// 为了验证
function minRemove1(arr: number[], k: number): number {
  return process1(arr, 0, new Array(arr.length), 0, k);
}

var MAX_VALUE: number = 2147483647;
function process1(
  arr: number[],
  index: number,
  path: number[],
  size: number,
  k: number
): number {
  if (index == arr.length) {
    return lengthOfLIS(path, size) < k ? arr.length - size : MAX_VALUE;
  } else {
    var p1: number = process1(arr, index + 1, path, size, k);
    path[size] = arr[index];
    var p2: number = process1(arr, index + 1, path, size + 1, k);
    return Math.min(p1, p2);
  }
}

function lengthOfLIS(arr: number[], size: number): number {
  if (size == 0) {
    return 0;
  }
  var ends: number[] = new Array(size);

  ends[0] = arr[0];
  var right: number = 0;
  var l: number = 0;
  var r: number = 0;
  var m: number = 0;
  var max: number = 1;
  for (var i: number = 1; i < size; i++) {
    l = 0;
    r = right;
    while (l <= r) {
      m = Math.floor((l + r) / 2);
      if (arr[i] > ends[m]) {
        l = m + 1;
      } else {
        r = m - 1;
      }
    }
    right = Math.max(right, l);
    ends[l] = arr[i];
    max = Math.max(max, l + 1);
  }
  return max;
}

// arr[0...index-1]上，选择了一些数字，之前的决定！
// len长度了！len = 3 ： 1 2 3
// arr[index....]是能够决定的，之前的，已经不能再决定了
// 返回：让最终保留的数字，凑不足k长度的情况下，至少要删几个！
function zuo(arr: number[], index: number, len: number, k: number): number {
  if (len == k) {
    return MAX_VALUE;
  }
  // 凑的(1...len)还不到(1...k)
  if (index == arr.length) {
    return 0;
  }
  // 没凑到 < k, 有数字!
  var cur: number = arr[index];
  // 可能性1：保留
  // 可能性2：删除
  // 1...3 3
  if (len >= cur || len + 1 < cur) {
    return zuo(arr, index + 1, len, k);
  }
  // 1..3  4
  // len + 1  == cur
  // 可能性1：保留
  var p1: number = zuo(arr, index + 1, len + 1, k);
  // 可能性2：删除
  var p2: number = MAX_VALUE;
  var next2: number = zuo(arr, index + 1, len, k);
  if (next2 != MAX_VALUE) {
    p2 = 1 + next2;
  }
  return Math.min(p1, p2);
}

// 正式方法
// 时间复杂度O(N*K)
function minRemove2(arr: number[], k: number): number {
  var n: number = arr.length;
  var dp: number[][] = new Array(n);
  for (var i: number = 0; i < n; i++) {
    dp[i] = new Array(k);
  }
  for (var i: number = 0; i < n; i++) {
    for (var j: number = 0; j < k; j++) {
      dp[i][j] = -1;
    }
  }
  return process2(arr, k, 0, 0, dp);
}

function process2(
  arr: number[],
  k: number,
  index: number,
  range: number,
  dp: number[][]
): number {
  if (range == k) {
    return MAX_VALUE;
  }
  if (index == arr.length) {
    return 0;
  }
  if (dp[index][range] != -1) {
    return dp[index][range];
  }
  var ans: number = 0;
  if (arr[index] == range + 1) {
    var p1: number = process2(arr, k, index + 1, range, dp);
    p1 += p1 != MAX_VALUE ? 1 : 0;
    var p2: number = process2(arr, k, index + 1, range + 1, dp);
    ans = Math.min(p1, p2);
  } else {
    ans = process2(arr, k, index + 1, range, dp);
  }
  dp[index][range] = ans;
  return ans;
}

// 为了验证
function randomArray(len: number, k: number): number[] {
  var arr: number[] = new Array(len);
  for (var i: number = 0; i < len; i++) {
    arr[i] = Math.floor(Math.random() * k) + 1;
  }
  return arr;
}

// 为了验证
function main() {
  var N: number = 15;
  var K: number = 6;
  var testTime: number = 10000;
  console.log("测试开始");
  for (var i: number = 0; i < testTime; i++) {
    var len: number = Math.floor(Math.random() * N) + 1;
    var k: number = Math.floor(Math.random() * K) + 1;
    var arr: number[] = randomArray(len, k);
    var ans1: number = minRemove1(arr, k);
    var ans2: number = minRemove2(arr, k);
    if (ans1 != ans2) {
      console.log("出错了！");
      arr.forEach(function (num) {
        console.log(num + " ");
      });

      console.log();
      console.log("k : " + k);
      console.log("ans1 : " + ans1);
      console.log("ans2 : " + ans2);
      break;
    }
  }
  console.log("测试结束");
}

main();

执行结果如下：

活动

智算服务

应用商城

合作伙伴

开发者

支持与服务

了解天翼云

给定一个数组arr，长度为N，arr中所有的值都在1~K范围上， 你可以删除数字，目的是让arr的最长递增子序列长度小于K。 返回至少删除几个数字能达到目的。

给定一个数组arr，长度为N，arr中所有的值都在1~K范围上， 你可以删除数字，目的是让arr的最长递增子序列长度小于K。 返回至少删除几个数字能达到目的。

相关文章

复杂度的OJ练习

背包问题——“0-1背包”，“完全背包”（这样讲，还能不会？）

《剑指Offer》二叉搜索树的第k个节点——真没你想象中那么难，一招教你秒杀它~

《剑指Offer》搜索算法题篇——更易理解的思路~

《剑指Offer》按之字形顺序打印二叉树——最容易理解的思路，两分钟学会~

【牛客网+LeetCode】链表 OJ强训题——高效解法

多源BFS问题(4)_地图分析

多源BFS问题(2)_飞地的数量

递归,搜索,回溯算法(3)之穷举,暴搜,深搜,回溯,剪枝

BFS解决最短路问题(4)_为高尔夫比赛砍树

作者介绍

最新文章

《剑指Offer》二叉搜索树的第k个节点——真没你想象中那么难，一招教你秒杀它~

《剑指Offer》按之字形顺序打印二叉树——最容易理解的思路，两分钟学会~

【牛客网+LeetCode】链表 OJ强训题——高效解法

【数据结构】第一章——绪论（2）

java实现3. 无重复字符的最长子串

DS初阶：顺序表的实现

热门文章

Pandas之:深入理解Pandas的数据结构

数据结构与算法之四 搜索算法

数据结构入门（第一天）

数据结构算法 简单的面试思考题

Pandas数据结构

数据结构这进制转换

热门标签

相关产品

弹性云主机

天翼云电脑（公众版）

对象存储

云硬盘

随机文章

【KMP】KMP算法的一些小理解&总结

数据结构与算法之五 链接列表

【数据结构】排序算法大总结

基于mysql索引的数据结构，索引类型，以及索引的使用

一个数组中只有两种字符‘G‘和‘B‘，可以让所有的G都放在左侧，所有的B都放在右侧。

看动画学算法之:栈stack

给定一个数组arr，长度为N，arr中所有的值都在1~K范围上，你可以删除数字，目的是让arr的最长递增子序列长度小于K。返回至少删除几个数字能达到目的。

给定一个数组arr，长度为N，arr中所有的值都在1~K范围上，你可以删除数字，目的是让arr的最长递增子序列长度小于K。返回至少删除几个数字能达到目的。

数据结构与算法之四搜索算法

数据结构算法简单的面试思考题

数据结构与算法之五链接列表