Question

2834. 找出美丽数组的最小和

English Version

题目描述

给你两个正整数：n 和 target 。

如果数组 nums 满足下述条件，则称其为 美丽数组 。

• nums.length == n.
• nums 由两两互不相同的正整数组成。
• 在范围 [0, n-1] 内，不存在 两个 不同 下标 i 和 j ，使得 nums[i] + nums[j] == target 。

返回符合条件的美丽数组所可能具备的 最小 和，并对结果进行取模 109 + 7。

 

示例 1：

输入：n = 2, target = 3
输出：4
解释：nums = [1,3] 是美丽数组。
- nums 的长度为 n = 2 。
- nums 由两两互不相同的正整数组成。
- 不存在两个不同下标 i 和 j ，使得 nums[i] + nums[j] == 3 。
可以证明 4 是符合条件的美丽数组所可能具备的最小和。

示例 2：

输入：n = 3, target = 3
输出：8
解释：
nums = [1,3,4] 是美丽数组。 
- nums 的长度为 n = 3 。 
- nums 由两两互不相同的正整数组成。 
- 不存在两个不同下标 i 和 j ，使得 nums[i] + nums[j] == 3 。
可以证明 8 是符合条件的美丽数组所可能具备的最小和。

示例 3：

输入：n = 1, target = 1
输出：1
解释：nums = [1] 是美丽数组。

 

提示：

• 1 <= n <= 109
• 1 <= target <= 109

解法

方法一：贪心 + 数学

我们可以贪心地从 $x = 1$ 开始构造数组 $nums$，每次选择 $x$，并且排除 $target - x$。

我们不妨记 $m = \left\lfloor \frac{target}{2} \right\rfloor$。

如果 $x <= m$，那么我们可以选择的数有 $1, 2, \cdots, n$，所以数组的和为 $\left\lfloor \frac{(1+n)n}{2} \right\rfloor$。

如果 $x > m$，那么我们可以选择的数有 $1, 2, \cdots, m$，共 $m$ 个数，以及 $n - m$ 个从 $target$ 开始的数，所以数组的和为 $\left\lfloor \frac{(1+m)m}{2} \right\rfloor + \left\lfloor \frac{(target + target + n - m - 1)(n-m)}{2} \right\rfloor$。

注意，我们需要对结果取模 $10^9 + 7$。

时间复杂度 $O(1)$，空间复杂度 $O(1)$。

class Solution:
  def minimumPossibleSum(self, n: int, target: int) -> int:
    mod = 10**9 + 7
    m = target // 2
    if n <= m:
      return ((1 + n) * n // 2) % mod
    return ((1 + m) * m // 2 + (target + target + n - m - 1) * (n - m) // 2) % mod

class Solution {
  public int minimumPossibleSum(int n, int target) {
    final int mod = (int) 1e9 + 7;
    int m = target / 2;
    if (n <= m) {
      return (int) ((1L + n) * n / 2 % mod);
    }
    long a = (1L + m) * m / 2 % mod;
    long b = ((1L * target + target + n - m - 1) * (n - m) / 2) % mod;
    return (int) ((a + b) % mod);
  }
}

class Solution {
public:
  int minimumPossibleSum(int n, int target) {
    const int mod = 1e9 + 7;
    int m = target / 2;
    if (n <= m) {
      return (1LL + n) * n / 2 % mod;
    }
    long long a = (1LL + m) * m / 2 % mod;
    long long b = (1LL * target + target + n - m - 1) * (n - m) / 2 % mod;
    return (a + b) % mod;
  }
};

func minimumPossibleSum(n int, target int) int {
  const mod int = 1e9 + 7
  m := target / 2
  if n <= m {
    return (n + 1) * n / 2 % mod
  }
  a := (m + 1) * m / 2 % mod
  b := (target + target + n - m - 1) * (n - m) / 2 % mod
  return (a + b) % mod
}

function minimumPossibleSum(n: number, target: number): number {
  const mod = 10 ** 9 + 7;
  const m = target >> 1;
  if (n <= m) {
    return (((1 + n) * n) / 2) % mod;
  }
  return (((1 + m) * m) / 2 + ((target + target + n - m - 1) * (n - m)) / 2) % mod;
}

public class Solution {
  public int MinimumPossibleSum(int n, int target) {
    const int mod = (int) 1e9 + 7;
    int m = target / 2;
    if (n <= m) {
      return (int) ((1L + n) * n / 2 % mod);
    }
    long a = (1L + m) * m / 2 % mod;
    long b = ((1L * target + target + n - m - 1) * (n - m) / 2) % mod;
    return (int) ((a + b) % mod);
  }
}