Question

2855. 使数组成为递增数组的最少右移次数

English Version

题目描述

给你一个长度为 n 下标从 0 开始的数组 nums ，数组中的元素为 互不相同 的正整数。请你返回让 nums 成为递增数组的 最少右移 次数，如果无法得到递增数组，返回 -1 。

一次 右移 指的是同时对所有下标进行操作，将下标为 i 的元素移动到下标 (i + 1) % n 处。

 

示例 1：

输入：nums = [3,4,5,1,2]
输出：2
解释：
第一次右移后，nums = [2,3,4,5,1] 。
第二次右移后，nums = [1,2,3,4,5] 。
现在 nums 是递增数组了，所以答案为 2 。

示例 2：

输入：nums = [1,3,5]
输出：0
解释：nums 已经是递增数组了，所以答案为 0 。

示例 3：

输入：nums = [2,1,4]
输出：-1
解释：无法将数组变为递增数组。

 

提示：

• 1 <= nums.length <= 100
• 1 <= nums[i] <= 100
• nums 中的整数互不相同。

解法

方法一：直接遍历

我们先用一个指针 $i$ 从左到右遍历数组 $nums$，找出一段连续的递增序列，直到 $i$ 到达数组末尾或者 $nums[i - 1] \gt nums[i]$。接下来我们用另一个指针 $k$ 从 $i + 1$ 开始遍历数组 $nums$，找出一段连续的递增序列，直到 $k$ 到达数组末尾或者 $nums[k - 1] \gt nums[k]$ 且 $nums[k] \gt nums[0]$。如果 $k$ 到达数组末尾，说明数组已经是递增的，返回 $n - i$；否则返回 $-1$。

时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 是数组 $nums$ 的长度。

class Solution:
  def minimumRightShifts(self, nums: List[int]) -> int:
    n = len(nums)
    i = 1
    while i < n and nums[i - 1] < nums[i]:
      i += 1
    k = i + 1
    while k < n and nums[k - 1] < nums[k] < nums[0]:
      k += 1
    return -1 if k < n else n - i

class Solution {
  public int minimumRightShifts(List<Integer> nums) {
    int n = nums.size();
    int i = 1;
    while (i < n && nums.get(i - 1) < nums.get(i)) {
      ++i;
    }
    int k = i + 1;
    while (k < n && nums.get(k - 1) < nums.get(k) && nums.get(k) < nums.get(0)) {
      ++k;
    }
    return k < n ? -1 : n - i;
  }
}

class Solution {
public:
  int minimumRightShifts(vector<int>& nums) {
    int n = nums.size();
    int i = 1;
    while (i < n && nums[i - 1] < nums[i]) {
      ++i;
    }
    int k = i + 1;
    while (k < n && nums[k - 1] < nums[k] && nums[k] < nums[0]) {
      ++k;
    }
    return k < n ? -1 : n - i;
  }
};

func minimumRightShifts(nums []int) int {
  n := len(nums)
  i := 1
  for i < n && nums[i-1] < nums[i] {
    i++
  }
  k := i + 1
  for k < n && nums[k-1] < nums[k] && nums[k] < nums[0] {
    k++
  }
  if k < n {
    return -1
  }
  return n - i
}

function minimumRightShifts(nums: number[]): number {
  const n = nums.length;
  let i = 1;
  while (i < n && nums[i - 1] < nums[i]) {
    ++i;
  }
  let k = i + 1;
  while (k < n && nums[k - 1] < nums[k] && nums[k] < nums[0]) {
    ++k;
  }
  return k < n ? -1 : n - i;
}