当前位置：首页 > news >正文

P7634 [COCI 2010/2011 #5] HONI 题解 DP模板题

news 来源：原创 2025/5/13 4:49:08

题目描述

COCI 的出题者必须从一堆题目中选择在下一轮中出现的题目。

题目的难度用 1 到 n 的整数来描述，但是对于某些题目来说，这并不容易准确地确定它们的难度。COCI 的出题者认为这些题目可以被视为有两个连续难度之一。例如，某些题目可以被视为难度为 3 或 4。

下一轮 COCI 将包含的 N 个题目。每一个难度，都会有且仅有一个题目。当然，没有题目会出现两次。

找出出题者为下一轮选择题目的不同方法的数量。我们认为两种方法是不同的仅当相同的任务分配给了不同的难度。

由于预期的结果可以非常大，输出的方案数 mod $10^9$ + 7。

输入格式

输入的第一行包含整数 N。

第二行包含 N 个整数 Ai，第 i 个数代表困难度恰好为 i 的题目的数量。

第三行输入包含 N−1 个整数 Bi，第 i 个数代表困难度为 i 或 i+1 的题目的数量。

输出格式

输出共一行，一个整数，表示方案数 mod $10^9$ + 7。

输入输出样例

输入 #1

3
3 0 1
0 1

输出 #1

输入 #2

4
1 5 3 0
0 2 1

输出 #2

说明/提示

【样例解释#1】

共 3 种方案：将难度为 2 或 3 的题目视为难度为 2 的，因为难度为 1 的题目有 3 道，所以共 3 种方案。

【数据范围】

对于 100% 的数据，2 ≤ N ≤ $10^5$ ，0 ≤ Ai,Bi ≤ $10^9$ 。

题目分析

问题描述：
- 每个难度 $i$ 有 $A_i$ 个题目，这些题目只能选择难度为 $i$ 。
- 每个难度 $i$ 或 $i+1$ 有 $B_i$ 个题目，这些题目可以选择难度为 $i$ 或 $i+1$ 。
- 要求每个难度 $i$ 恰好选择一个题目，且没有题目被重复选择。
目标：
- 计算满足条件的方案数，结果对 $10^9+7$ 取模。
动态规划状态定义：
- 设 $dp[i][0]$ 表示将难度 $[1,i]$ 分配完的方案数，且没有在难度 $i$ 处分配 $B_i$ 中的题目。
- 设 $dp[i][1]$ 表示将难度 $[1,i]$ 分配完的方案数，且在难度 $i$ 处分配了 $B_i$ 中的题目。
状态转移：
- 对于 $dp[i][1]$ ：
  - 如果选择 $B_i$ 中的题目，那么前 $i-1$ 个难度的方案数为 $dp[i-1][0]+dp[i-1][1]$ 。
  - 因此， $dp[i][1]=(dp[i-1][0]+dp[i-1][1] \times B_i)$ 。
- 对于 $dp[i][0]$ ：
  - 如果没有选择 $B_i$ 中的题目，那么当前难度 $i$ 只能选择 $A_i$ 或 $B_i - 1$ 中的题目。
  - 如果前 $i-1$ 个难度没有选择 $B_i-1$ 中的题目，那么当前难度 $i$ 有 $A_i+B_i-1$ 种选择。
  - 如果前 $i-1$ 个难度选择了 $B_i-1$ 中的题目，那么当前难度 $i$ 有 $A_i+B_i-1-1$ 种选择（因为 $B_i-1$ 中的一个题目已经被分配到难度 $i-1$ ）。
  - 因此， $dp[i][0]=(A_i+B_i-1) \times dp[i-1][0]+(A_i+B_i-1-1) \times dp[i-1][1]$ 。
初始条件：
- $dp[0][0]=1$ （没有难度时，方案数为 1）。
- $dp[0][1]=0$ （没有难度时，无法选择 $B_i$ 中的题目）。
结果：
- 最终结果为 $dp[n][0]$ ，因为不存在 $B_n$ ，不能考虑 $dp[n][1]$ 。

代码实现 :

#include <bits/stdc++.h>
#define int long long
using namespace std;

constexpr int MAXN = 1e5 + 4,modd = 1e9 + 7;
int n,a[MAXN],b[MAXN],dp[MAXN][2];
signed main() {
    cin >> n;
    for (int i = 1; i <= n; i ++) cin >> a[i];
    for (int i = 1; i < n; i ++) cin >> b[i];
    dp[0][0] = 1;
    dp[0][1] = 0;
    for (int i = 1; i <= n; i ++) {
        dp[i][0] = ((a[i] + (i > 1 ? b[i - 1] : 0)) * dp[i - 1][0] + (a[i] + (i > 1 ? b[i - 1] - 1 : 0)) * dp[i - 1][1]) % modd;
        dp[i][1] = (i < n) ? ((dp[i - 1][0] + dp[i - 1][1]) * b[i]) % modd : 0;
    }
    cout << dp[n][0];
    return 0;
}