Question

2407. 最长递增子序列 II

English Version

题目描述

给你一个整数数组 nums 和一个整数 k 。

找到 nums 中满足以下要求的最长子序列：

• 子序列 严格递增
• 子序列中相邻元素的差值 不超过 k 。

请你返回满足上述要求的 最长子序列 的长度。

子序列 是从一个数组中删除部分元素后，剩余元素不改变顺序得到的数组。

 

示例 1：

输入：nums = [4,2,1,4,3,4,5,8,15], k = 3
输出：5
解释：
满足要求的最长子序列是 [1,3,4,5,8] 。
子序列长度为 5 ，所以我们返回 5 。
注意子序列 [1,3,4,5,8,15] 不满足要求，因为 15 - 8 = 7 大于 3 。

示例 2：

输入：nums = [7,4,5,1,8,12,4,7], k = 5
输出：4
解释：
满足要求的最长子序列是 [4,5,8,12] 。
子序列长度为 4 ，所以我们返回 4 。

示例 3：

输入：nums = [1,5], k = 1
输出：1
解释：
满足要求的最长子序列是 [1] 。
子序列长度为 1 ，所以我们返回 1 。

 

提示：

• 1 <= nums.length <= 105
• 1 <= nums[i], k <= 105

解法

方法一：线段树

我们假设 $f[v]$ 表示以数字 $v$ 结尾的最长递增子序列的长度。

我们遍历数组 $nums$ 中的每个元素 $v$，有状态转移方程：$f[v] = \max(f[v], f[x])$，其中 $x$ 的取值范围是 $[v-k, v-1]$。

因此，我们需要一个数据结构，来维护区间的最大值，不难想到使用线段树。

线段树将整个区间分割为多个不连续的子区间，子区间的数量不超过 $log(width)$。更新某个元素的值，只需要更新 $log(width)$ 个区间，并且这些区间都包含在一个包含该元素的大区间内。

• 线段树的每个节点代表一个区间；
• 线段树具有唯一的根节点，代表的区间是整个统计范围，如 $[1,N]$；
• 线段树的每个叶子节点代表一个长度为 $1$ 的元区间 $[x, x]$；
• 对于每个内部节点 $[l,r]$，它的左儿子是 $[l,mid]$，右儿子是 $[mid+1,r]$, 其中 $mid = \left \lfloor \frac{l+r}{2} \right \rfloor$。

对于本题，线段树节点维护的信息是区间范围内的最大值。

时间复杂度 $O(n \times \log n)$。其中 $n$ 是数组 $nums$ 的长度。

class Node:
  def __init__(self):
    self.l = 0
    self.r = 0
    self.v = 0


class SegmentTree:
  def __init__(self, n):
    self.tr = [Node() for _ in range(4 * n)]
    self.build(1, 1, n)

  def build(self, u, l, r):
    self.tr[u].l = l
    self.tr[u].r = r
    if l == r:
      return
    mid = (l + r) >> 1
    self.build(u << 1, l, mid)
    self.build(u << 1 | 1, mid + 1, r)

  def modify(self, u, x, v):
    if self.tr[u].l == x and self.tr[u].r == x:
      self.tr[u].v = v
      return
    mid = (self.tr[u].l + self.tr[u].r) >> 1
    if x <= mid:
      self.modify(u << 1, x, v)
    else:
      self.modify(u << 1 | 1, x, v)
    self.pushup(u)

  def pushup(self, u):
    self.tr[u].v = max(self.tr[u << 1].v, self.tr[u << 1 | 1].v)

  def query(self, u, l, r):
    if self.tr[u].l >= l and self.tr[u].r <= r:
      return self.tr[u].v
    mid = (self.tr[u].l + self.tr[u].r) >> 1
    v = 0
    if l <= mid:
      v = self.query(u << 1, l, r)
    if r > mid:
      v = max(v, self.query(u << 1 | 1, l, r))
    return v


class Solution:
  def lengthOfLIS(self, nums: List[int], k: int) -> int:
    tree = SegmentTree(max(nums))
    ans = 1
    for v in nums:
      t = tree.query(1, v - k, v - 1) + 1
      ans = max(ans, t)
      tree.modify(1, v, t)
    return ans

class Solution {
  public int lengthOfLIS(int[] nums, int k) {
    int mx = nums[0];
    for (int v : nums) {
      mx = Math.max(mx, v);
    }
    SegmentTree tree = new SegmentTree(mx);
    int ans = 0;
    for (int v : nums) {
      int t = tree.query(1, v - k, v - 1) + 1;
      ans = Math.max(ans, t);
      tree.modify(1, v, t);
    }
    return ans;
  }
}

class Node {
  int l;
  int r;
  int v;
}

class SegmentTree {
  private Node[] tr;

  public SegmentTree(int n) {
    tr = new Node[4 * n];
    for (int i = 0; i < tr.length; ++i) {
      tr[i] = new Node();
    }
    build(1, 1, n);
  }

  public void build(int u, int l, int r) {
    tr[u].l = l;
    tr[u].r = r;
    if (l == r) {
      return;
    }
    int mid = (l + r) >> 1;
    build(u << 1, l, mid);
    build(u << 1 | 1, mid + 1, r);
  }

  public void modify(int u, int x, int v) {
    if (tr[u].l == x && tr[u].r == x) {
      tr[u].v = v;
      return;
    }
    int mid = (tr[u].l + tr[u].r) >> 1;
    if (x <= mid) {
      modify(u << 1, x, v);
    } else {
      modify(u << 1 | 1, x, v);
    }
    pushup(u);
  }

  public void pushup(int u) {
    tr[u].v = Math.max(tr[u << 1].v, tr[u << 1 | 1].v);
  }

  public int query(int u, int l, int r) {
    if (tr[u].l >= l && tr[u].r <= r) {
      return tr[u].v;
    }
    int mid = (tr[u].l + tr[u].r) >> 1;
    int v = 0;
    if (l <= mid) {
      v = query(u << 1, l, r);
    }
    if (r > mid) {
      v = Math.max(v, query(u << 1 | 1, l, r));
    }
    return v;
  }
}

class Node {
public:
  int l;
  int r;
  int v;
};

class SegmentTree {
public:
  vector<Node*> tr;

  SegmentTree(int n) {
    tr.resize(4 * n);
    for (int i = 0; i < tr.size(); ++i) tr[i] = new Node();
    build(1, 1, n);
  }

  void build(int u, int l, int r) {
    tr[u]->l = l;
    tr[u]->r = r;
    if (l == r) return;
    int mid = (l + r) >> 1;
    build(u << 1, l, mid);
    build(u << 1 | 1, mid + 1, r);
  }

  void modify(int u, int x, int v) {
    if (tr[u]->l == x && tr[u]->r == x) {
      tr[u]->v = v;
      return;
    }
    int mid = (tr[u]->l + tr[u]->r) >> 1;
    if (x <= mid)
      modify(u << 1, x, v);
    else
      modify(u << 1 | 1, x, v);
    pushup(u);
  }

  void pushup(int u) {
    tr[u]->v = max(tr[u << 1]->v, tr[u << 1 | 1]->v);
  }

  int query(int u, int l, int r) {
    if (tr[u]->l >= l && tr[u]->r <= r) return tr[u]->v;
    int mid = (tr[u]->l + tr[u]->r) >> 1;
    int v = 0;
    if (l <= mid) v = query(u << 1, l, r);
    if (r > mid) v = max(v, query(u << 1 | 1, l, r));
    return v;
  }
};

class Solution {
public:
  int lengthOfLIS(vector<int>& nums, int k) {
    SegmentTree* tree = new SegmentTree(*max_element(nums.begin(), nums.end()));
    int ans = 1;
    for (int v : nums) {
      int t = tree->query(1, v - k, v - 1) + 1;
      ans = max(ans, t);
      tree->modify(1, v, t);
    }
    return ans;
  }
};

func lengthOfLIS(nums []int, k int) int {
  mx := slices.Max(nums)
  tree := newSegmentTree(mx)
  ans := 1
  for _, v := range nums {
    t := tree.query(1, v-k, v-1) + 1
    ans = max(ans, t)
    tree.modify(1, v, t)
  }
  return ans
}

type node struct {
  l int
  r int
  v int
}

type segmentTree struct {
  tr []*node
}

func newSegmentTree(n int) *segmentTree {
  tr := make([]*node, n<<2)
  for i := range tr {
    tr[i] = &node{}
  }
  t := &segmentTree{tr}
  t.build(1, 1, n)
  return t
}

func (t *segmentTree) build(u, l, r int) {
  t.tr[u].l, t.tr[u].r = l, r
  if l == r {
    return
  }
  mid := (l + r) >> 1
  t.build(u<<1, l, mid)
  t.build(u<<1|1, mid+1, r)
  t.pushup(u)
}

func (t *segmentTree) modify(u, x, v int) {
  if t.tr[u].l == x && t.tr[u].r == x {
    t.tr[u].v = v
    return
  }
  mid := (t.tr[u].l + t.tr[u].r) >> 1
  if x <= mid {
    t.modify(u<<1, x, v)
  } else {
    t.modify(u<<1|1, x, v)
  }
  t.pushup(u)
}

func (t *segmentTree) query(u, l, r int) int {
  if t.tr[u].l >= l && t.tr[u].r <= r {
    return t.tr[u].v
  }
  mid := (t.tr[u].l + t.tr[u].r) >> 1
  v := 0
  if l <= mid {
    v = t.query(u<<1, l, r)
  }
  if r > mid {
    v = max(v, t.query(u<<1|1, l, r))
  }
  return v
}

func (t *segmentTree) pushup(u int) {
  t.tr[u].v = max(t.tr[u<<1].v, t.tr[u<<1|1].v)
}