【888题竞赛篇】第三题，2016ICPC大连-Detachment

更多精彩内容

这里是带你游历编程世界的Dashcoding编程社，我是Dash/北航硕士/ICPC区域赛全国排名30+/给你呈现我们眼中的世界！

256题算法特训课，帮你斩获大厂60W年薪offer

原题

2016ICPC大连-Detachment

B站动画详解

问题分析

给定一条长度为 $x$ 的线段，要求将其分割成整数长度互不相同的若干小段，使得这些小段长度的乘积最大。需要输出这个最大乘积对 $10^9+7$ 取模后的结果。

思路分析

1. 预处理前缀和与前缀积

首先，我们从长度为 $2$ 开始进行分割，因为长度为 $1$ 的小段在乘积中没有贡献。我们需要预处理前缀和与前缀积，这样在后续查找分割点和计算乘积时可以高效完成。

2. 二分查找分割点

通过二分查找确定一个 $id$ 使得 $sum[id-1]<x<sum[id]$，其中 $sum$ 是前缀和数组。这个 $id$ 表示线段长度分割的上限，而 $x-sum[id-1]$ 就是剩余长度 $rest$。接下来，我们需要将 $rest$ 分配到分割后的某个小段中。

3. 分配剩余长度

为了使乘积最大化，$rest$ 应尽可能分配给较小的段。理想情况下，将 $rest$ 分配给 $id-rest$ 这一段。如果 $id-rest<2$，则应优先分配给 $2$。

4. 证明最佳分配策略

设初始乘积为 $tmp=2\times 3\times 4\times \cdots \times (id-1)$。假设可以将 $rest$ 分配给 $4$ 或 $5$，则有：

• 若分配给 $4$，设 $tmp=4\times t_1$，则新的乘积为 $(4+rest)\times t_1$。
• 若分配给 $5$，设 $tmp=5\times t_2$，则新的乘积为 $(5+rest)\times t_2$。

由于 $t_1>t_2$，因此 $(4+rest)\times t_1>(5+rest)\times t_2$，证明了分配给较小段更优。

5. 模运算与逆元

因为 $T\le 10^6$ 所以我们每次需要预处理出来相应的阶乘，然后再对于每次询问进行相关的操作，所以需要在计算过程中涉及取模运算，特别是除法取模需要用到逆元。当遇到 $(a/b)\mathrm{mod}MOD$ 这种情况时，我们将其转化为 $(a\times k)\mathrm{mod}MOD$，其中 $k$ 是 $b$ 在 $MOD$ 下的逆元。通过预处理逆元，我们可以高效完成计算。

算法实现

对于给定线段的分割问题，算法的关键在于利用前缀和、前缀积和模逆元进行优化处理，以确保计算复杂度足够低，从而能够处理大规模的数据。

1. 预处理前缀和、前缀积及模逆元

首先，为了加速查询与计算，我们通过预处理得到每个长度的前缀和（$ \text{prefixSum} $）、前缀积（$ \text{prefixProd} $）以及逆元（$ \text{invMod} $）。

• $\text{prefixSum}[i]=2+3+4+\cdots +i$
• $\text{prefixProd}[i]=2\times 3\times 4\times \cdots \times i\mathrm{mod}10^9+7$
• $\text{invMod}[i]$ 是模 $10^9+7$ 下 $i$ 的乘法逆元，通过欧几里得算法计算。

预处理的时间复杂度为 $O(\text{LIMIT})$，而查询部分通过二分查找将复杂度降低到 $O(\log (\text{LIMIT}))$。

2. 二分查找最优分割点

对于每个测试用例，给定线段长度 $x$，需要找到使 $\text{prefixSum}[i-1]<x\le \text{prefixSum}[i]$ 的最小 $i$，这可以通过二分查找实现。

• 如果 $x$ 刚好等于 $\text{prefixSum}[i]$，那么无需再分割，直接返回 $\text{prefixProd}[i]$。
• 否则，需要计算出剩余长度 $x-\text{prefixSum}[i-1]$ 并考虑将其分配到现有的数列中，使乘积最大。

3. 分配剩余长度

假设剩余长度为 $r$，在保证各段互不相同的前提下，将 $r$ 分配到某个段长度上使得整体乘积最大。

• 如果 $2+r>i$，说明 $r$ 可以分配到 $2$ 处然后没有重复。
• 否则，将 $r$ 分配到 $i-r$ 处。

这种分配策略确保了乘积尽可能大，并利用预处理的结果快速得到答案。

4. 模逆元的作用

在处理除法时，直接计算 $\frac{a}{b}\mathrm{mod}10^9+7$ 是不可行的，因此引入模逆元，将问题转换为乘法，即 $a\times b^{-1}\mathrm{mod}10^9+7$。

代码详解

标准代码程序

C++代码

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

typedef long long ll;
const ll MOD = 1e9 + 7;
const int LIMIT = 50000;

vector<ll> prefixSum(LIMIT, 0);  // 前缀和
vector<ll> prefixProd(LIMIT, 1); // 前缀积
vector<ll> invMod(LIMIT, 0);     // 模的逆元

// 预处理函数
void preprocess() {
    invMod[1] = 1;
    for (int i = 2; i < LIMIT; i++) {
        prefixSum[i] = prefixSum[i - 1] + i;
        prefixProd[i] = (prefixProd[i - 1] * i) % MOD;
        invMod[i] = (MOD - (MOD / i) * invMod[MOD % i] % MOD) % MOD;
    }
}

int main() {
    ll testCases;
    cin >> testCases;

    preprocess();  // 初始化

    while (testCases--) {
        ll x;
        cin >> x;

        if (x == 1) {
            cout << 1 << endl;
        } else {
            // 二分查找满足条件的索引 id
            ll id = lower_bound(prefixSum.begin() + 2, prefixSum.end(), x) - prefixSum.begin();

            if (x == prefixSum[id]) {
                cout << prefixProd[id] % MOD << endl;
            } else {
                id--;
                ll remainder = x - prefixSum[id];

                if (2 + remainder > id) {
                    ll result = (prefixProd[id] * invMod[2] % MOD * (2 + remainder)) % MOD;
                    cout << result << endl;
                } else {
                    ll result = (prefixProd[id] * invMod[id + 1 - remainder] % MOD * (id + 1)) % MOD;
                    cout << result << endl;
                }
            }
        }
    }

    return 0;
}

Java代码

import java.util.Scanner;

public class MaxSegmentProduct {
    private static final long MOD = 1000000007L;
    private static final int LIMIT = 50000;
    private static long[] prefixSum = new long[LIMIT];
    private static long[] prefixProd = new long[LIMIT];
    private static long[] invMod = new long[LIMIT];

    static {
        invMod[1] = 1;
        for (int i = 2; i < LIMIT; i++) {
            prefixSum[i] = prefixSum[i - 1] + i;
            prefixProd[i] = (prefixProd[i - 1] * i) % MOD;
            invMod[i] = (MOD - MOD / i * invMod[(int) (MOD % i)] % MOD) % MOD;
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int testCases = scanner.nextInt();

        while (testCases-- > 0) {
            long x = scanner.nextLong();

            if (x == 1) {
                System.out.println(1);
            } else {
                int id = lowerBound(prefixSum, 2, LIMIT, x);

                if (x == prefixSum[id]) {
                    System.out.println(prefixProd[id] % MOD);
                } else {
                    id--;
                    long remainder = x - prefixSum[id];

                    if (2 + remainder > id) {
                        long result = (prefixProd[id] * invMod[2] % MOD * (2 + remainder)) % MOD;
                        System.out.println(result);
                    } else {
                        long result = (prefixProd[id] * invMod[(int) (id + 1 - remainder)] % MOD * (id + 1)) % MOD;
                        System.out.println(result);
                    }
                }
            }
        }

        scanner.close();
    }

    private static int lowerBound(long[] arr, int low, int high, long key) {
        while (low < high) {
            int mid = (low + high) / 2;
            if (arr[mid] < key) {
                low = mid + 1;
            } else {
                high = mid;
            }
        }
        return low;
    }
}

Python代码

MOD = 10**9 + 7
LIMIT = 50000

prefix_sum = [0] * LIMIT
prefix_prod = [1] * LIMIT
inv_mod = [0] * LIMIT
inv_mod[1] = 1

# 预处理前缀和、前缀积和逆元
for i in range(2, LIMIT):
    prefix_sum[i] = prefix_sum[i - 1] + i
    prefix_prod[i] = (prefix_prod[i - 1] * i) % MOD
    inv_mod[i] = (MOD - (MOD // i) * inv_mod[MOD % i] % MOD) % MOD

def lower_bound(arr, low, high, key):
    while low < high:
        mid = (low + high) // 2
        if arr[mid] < key:
            low = mid + 1
        else:
            high = mid
    return low

def main():
    t = int(input())
    for _ in range(t):
        x = int(input())
        if x == 1:
            print(1)
        else:
            id = lower_bound(prefix_sum, 2, LIMIT, x)
            if x == prefix_sum[id]:
                print(prefix_prod[id] % MOD)
            else:
                id -= 1
                remainder = x - prefix_sum[id]
                if 2 + remainder > id:
                    result = (prefix_prod[id] * inv_mod[2] % MOD * (2 + remainder)) % MOD
                    print(result)
                else:
                    result = (prefix_prod[id] * inv_mod[id + 1 - remainder] % MOD * (id + 1)) % MOD
                    print(result)

if __name__ == "__main__":
    main()

Javascript代码

const MOD = 1e9 + 7;
const LIMIT = 50000;

let prefixSum = Array(LIMIT).fill(0);
let prefixProd = Array(LIMIT).fill(1);
let invMod = Array(LIMIT).fill(0);
invMod[1] = 1;

// 预处理前缀和、前缀积和逆元
for (let i = 2; i < LIMIT; i++) {
  prefixSum[i] = prefixSum[i - 1] + i;
  prefixProd[i] = (prefixProd[i - 1] * i) % MOD;
  invMod[i] = (MOD - Math.floor(MOD / i) * invMod[MOD % i] % MOD) % MOD;
}

function lowerBound(arr, low, high, key) {
  while (low < high) {
    let mid = Math.floor((low + high) / 2);
    if (arr[mid] < key) {
      low = mid + 1;
    } else {
      high = mid;
    }
  }
  return low;
}

function main() {
  const t = parseInt(prompt("Enter number of test cases: "), 10);
  for (let i = 0; i < t; i++) {
    const x = parseInt(prompt("Enter value of x: "), 10);
    if (x === 1) {
      console.log(1);
    } else {
      let id = lowerBound(prefixSum, 2, LIMIT, x);
      if (x === prefixSum[id]) {
        console.log(prefixProd[id] % MOD);
      } else {
        id--;
        let remainder = x - prefixSum[id];
        if (2 + remainder > id) {
          let result = (prefixProd[id] * invMod[2] % MOD * (2 + remainder)) % MOD;
          console.log(result);
        } else {
          let result = (prefixProd[id] * invMod[id + 1 - remainder] % MOD * (id + 1)) % MOD;
          console.log(result);
        }
      }
    }
  }
}

main();

复杂度分析

时间复杂度

1. 预处理部分:

   • 预处理前缀和、前缀积和模逆元的操作，遍历至最大上限 $LIMIT$。
   • 时间复杂度为 $ O(LIMIT)$，其中 $LIMIT$ 是定义的常数（例如 $50000$）。

2. 二分查找部分:

   • 对于每个输入 $x$，通过二分查找定位合适的分割点，时间复杂度为 $O(logLIMIT)$。

3. 整体复杂度:

   • 总共 $T$ 个测试用例，每个测试用例进行一次二分查找和常数时间的计算，因此整体时间复杂度为 $O(T\cdot \log (\text{LIMIT}))$。

4. 极限情况:

   • 即使 $T$ 达到 $10^6$，算法也能够在合理时间内完成计算，确保高效处理大规模数据。

空间复杂度

1. 预处理空间:

   • 需要存储前缀和（$\text{prefixSum}$）、前缀积（$\text{prefixProd}$）以及模逆元（$\text{invMod}$）数组，每个数组的大小为 $\text{LIMIT}$。
   • 空间复杂度为 $O(\text{LIMIT})$。

2. 额外空间开销:

   • 二分查找和常数操作仅需少量临时变量，不会增加显著空间开销。

3. 整体空间复杂度:

   • 整体空间复杂度为 $O(\text{LIMIT})$，即 $O(50000)$，可视为常数级别。

总结

本算法通过预处理和二分查找巧妙地解决了大规模输入下的线段分割问题。预处理部分将复杂计算转化为查表操作，显著提高了查询效率；而二分查找则在给定长度下快速定位合适的分割点。通过引入模逆元解决除法问题，使得算法能够在模 $10^9+7$ 下进行精确计算。整体时间复杂度和空间复杂度都经过优化，适合处理多组大数据测试用例。