mirror of
https://github.com/InternLM/InternBootcamp.git
synced 2026-04-19 12:58:04 +00:00
447 lines
12 KiB
Python
Executable file
447 lines
12 KiB
Python
Executable file
"""#
|
||
|
||
### 谜题描述
|
||
This is the easy version of the problem. The only difference is that in this version q = 1. You can make hacks only if both versions of the problem are solved.
|
||
|
||
There is a process that takes place on arrays a and b of length n and length n-1 respectively.
|
||
|
||
The process is an infinite sequence of operations. Each operation is as follows:
|
||
|
||
* First, choose a random integer i (1 ≤ i ≤ n-1).
|
||
* Then, simultaneously set a_i = min\left(a_i, \frac{a_i+a_{i+1}-b_i}{2}\right) and a_{i+1} = max\left(a_{i+1}, \frac{a_i+a_{i+1}+b_i}{2}\right) without any rounding (so values may become non-integer).
|
||
|
||
See notes for an example of an operation.
|
||
|
||
It can be proven that array a converges, i. e. for each i there exists a limit a_i converges to. Let function F(a, b) return the value a_1 converges to after a process on a and b.
|
||
|
||
You are given array b, but not array a. However, you are given a third array c. Array a is good if it contains only integers and satisfies 0 ≤ a_i ≤ c_i for 1 ≤ i ≤ n.
|
||
|
||
Your task is to count the number of good arrays a where F(a, b) ≥ x for q values of x. Since the number of arrays can be very large, print it modulo 10^9+7.
|
||
|
||
Input
|
||
|
||
The first line contains a single integer n (2 ≤ n ≤ 100).
|
||
|
||
The second line contains n integers c_1, c_2 …, c_n (0 ≤ c_i ≤ 100).
|
||
|
||
The third line contains n-1 integers b_1, b_2, …, b_{n-1} (0 ≤ b_i ≤ 100).
|
||
|
||
The fourth line contains a single integer q (q=1).
|
||
|
||
The fifth line contains q space separated integers x_1, x_2, …, x_q (-10^5 ≤ x_i ≤ 10^5).
|
||
|
||
Output
|
||
|
||
Output q integers, where the i-th integer is the answer to the i-th query, i. e. the number of good arrays a where F(a, b) ≥ x_i modulo 10^9+7.
|
||
|
||
Example
|
||
|
||
Input
|
||
|
||
|
||
3
|
||
2 3 4
|
||
2 1
|
||
1
|
||
-1
|
||
|
||
|
||
Output
|
||
|
||
|
||
56
|
||
|
||
Note
|
||
|
||
The following explanation assumes b = [2, 1] and c=[2, 3, 4] (as in the sample).
|
||
|
||
Examples of arrays a that are not good:
|
||
|
||
* a = [3, 2, 3] is not good because a_1 > c_1;
|
||
* a = [0, -1, 3] is not good because a_2 < 0.
|
||
|
||
|
||
|
||
One possible good array a is [0, 2, 4]. We can show that no operation has any effect on this array, so F(a, b) = a_1 = 0.
|
||
|
||
Another possible good array a is [0, 1, 4]. In a single operation with i = 1, we set a_1 = min((0+1-2)/(2), 0) and a_2 = max((0+1+2)/(2), 1). So, after a single operation with i = 1, a becomes equal to [-1/2, 3/2, 4]. We can show that no operation has any effect on this array, so F(a, b) = -1/2.
|
||
|
||
Here is a reference code to solve this task. You can use this to help you genereate cases or validate the solution.
|
||
```python
|
||
#pragma GCC optimize(\"Ofast\")
|
||
#pragma GCC optimize(\"unroll-loops\")
|
||
#pragma GCC target(\"sse,sse2,sse3,ssse3,abm,mmx,tune=native\")
|
||
#include<vector>
|
||
#include<iostream>
|
||
#include<stack>
|
||
#include<cmath>
|
||
#include<algorithm>
|
||
#include<set>
|
||
#include<map>
|
||
#include<string>
|
||
#include<tuple>
|
||
#include<bitset>
|
||
#include<queue>
|
||
#include<unordered_map>
|
||
#include<random>
|
||
#include<ctime>
|
||
//#include<complex>
|
||
#include<numeric>
|
||
typedef long long ll;
|
||
typedef long double ld;
|
||
typedef unsigned short us;
|
||
typedef unsigned long long ull;
|
||
//typedef complex<double> base;
|
||
using namespace std;
|
||
ll gcd(ll i, ll j) {
|
||
if (j == 0)return i;
|
||
else return gcd(j, i % j);
|
||
}
|
||
#ifdef _DEBUG
|
||
int __builtin_popcount(int x) { return x ? (__builtin_popcount(x >> 1) + (x & 1)) : 0; }
|
||
#endif
|
||
template<typename T> inline T getint() {
|
||
T val = 0;
|
||
char c;
|
||
|
||
bool neg = false;
|
||
while ((c = getchar()) && !(c >= '0' && c <= '9')) {
|
||
neg |= c == '-';
|
||
}
|
||
|
||
do {
|
||
val = (val * 10) + c - '0';
|
||
} while ((c = getchar()) && (c >= '0' && c <= '9'));
|
||
|
||
return val * (neg ? -1 : 1);
|
||
}
|
||
//#define int long long
|
||
const ll INF = 1e9 + 100;
|
||
const int mod = 1000000007;
|
||
const ld eps = 1e-6, pi = acosl(-1);
|
||
const ll maxN = 10210, maxT = 10010, A = 179, mid = 150;
|
||
mt19937 mt_rand(time(0));
|
||
ll bp(ll et, ll b) {
|
||
b %= mod - 1;
|
||
ll res = 1;
|
||
for (int i = 30; i >= 0; --i) {
|
||
res = (res * res) % mod;
|
||
if ((b & (1 << i)) != 0)res = (res * et) % mod;
|
||
}
|
||
return res;
|
||
}
|
||
void panic() {
|
||
cout << \"-1\n\";
|
||
exit(0);
|
||
}
|
||
int pl(const int& a, const int& b) {
|
||
int r = a + b;
|
||
if (r >= mod)r -= mod;
|
||
return r;
|
||
}
|
||
vector<ll>c, b;
|
||
map<ll, ll>mp;
|
||
int n;
|
||
bool check_0(ll x) {
|
||
ll d = 0, s = 0;
|
||
bool ff = 1;
|
||
for (int i = 0; i < n; ++i) {
|
||
if (i) {
|
||
d += b[i - 1];
|
||
s += d;
|
||
}
|
||
ll vv = x * (i + 1) + s;
|
||
ff &= vv <= 0;
|
||
}
|
||
return ff;
|
||
}
|
||
bool check_1(ll x) {
|
||
ll d = 0, s = 0;
|
||
bool ff = 0;
|
||
ll sum_s = 0;
|
||
for (int i = 0; i < n; ++i) {
|
||
sum_s += c[i];
|
||
if (i) {
|
||
d += b[i - 1];
|
||
s += d;
|
||
}
|
||
ll vv = x * (i + 1) + s;
|
||
ff |= sum_s < vv;
|
||
}
|
||
return ff;
|
||
}
|
||
ll get_r(ll x) {
|
||
if (mp.count(x))
|
||
return mp[x];
|
||
if (check_0(x)) {
|
||
ll r = 1;
|
||
for (auto x : c) {
|
||
r = (r * (x + 1)) % mod;
|
||
}
|
||
return mp[x] = r;
|
||
}
|
||
if (check_1(x)) {
|
||
return mp[x] = 0;
|
||
}
|
||
ll d = 0, s = 0;
|
||
vector<vector<ll>>dp(n + 1, vector<ll>(maxN));
|
||
dp[0][0] = 1;
|
||
for (int i = 0; i < n; ++i) {
|
||
if (i) {
|
||
d += b[i - 1];
|
||
s += d;
|
||
}
|
||
ll vv = x * (i + 1) + s;
|
||
ll cc = c[i];
|
||
for (int j = maxN - cc - 1; j >= 0; --j) {
|
||
for (int k = j + cc; k >= j && k >= vv; --k) {
|
||
dp[i + 1][k] = pl(dp[i + 1][k], dp[i][j]);
|
||
}
|
||
}
|
||
}
|
||
ll ans = 0;
|
||
for (int i = 0; i < maxN; ++i)
|
||
ans = pl(ans, dp[n][i]);
|
||
return mp[x] = ans;
|
||
}
|
||
void solve() {
|
||
cin >> n;
|
||
c.assign(n, 0);
|
||
b.assign(n - 1, 0);
|
||
for (auto& x : c)
|
||
cin >> x;
|
||
for (auto& x : b)
|
||
cin >> x;
|
||
int q;
|
||
cin >> q;
|
||
while (q--) {
|
||
ll x;
|
||
cin >> x;
|
||
cout << get_r(x) << \"\n\";
|
||
}
|
||
}
|
||
int32_t main()
|
||
{
|
||
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
|
||
cout.precision(20);
|
||
//srand(time(0));
|
||
#ifdef _DEBUG
|
||
freopen(\"input.txt\", \"r\", stdin); freopen(\"output.txt\", \"w\", stdout);
|
||
#else
|
||
//freopen(\"gymnasts.in\", \"r\", stdin); freopen(\"gymnasts.out\", \"w\", stdout);
|
||
#endif
|
||
int t = 1;
|
||
//cin >> t;
|
||
while (t--) {
|
||
solve();
|
||
}
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
|
||
请完成上述谜题的训练场环境类实现，包括所有必要的方法。
|
||
"""
|
||
|
||
from bootcamp import Basebootcamp
|
||
import random
|
||
import re
|
||
from bootcamp import Basebootcamp
|
||
|
||
MOD = 10**9 + 7
|
||
|
||
class E1convergingarrayeasyversionbootcamp(Basebootcamp):
|
||
def __init__(self, **params):
|
||
self.n_min = params.get('n_min', 2)
|
||
self.n_max = params.get('n_max', 5)
|
||
self.c_min = params.get('c_min', 0)
|
||
self.c_max = params.get('c_max', 100)
|
||
self.b_min = params.get('b_min', 0)
|
||
self.b_max = params.get('b_max', 100)
|
||
self.x_min = params.get('x_min', -100000)
|
||
self.x_max = params.get('x_max', 100000)
|
||
|
||
def case_generator(self):
|
||
# 多策略生成有效案例
|
||
generation_strategies = [
|
||
self._generate_simple_case,
|
||
self._generate_zero_c_case,
|
||
self._generate_max_b_case,
|
||
self._generate_negative_x_case
|
||
]
|
||
|
||
for strategy in generation_strategies:
|
||
case = strategy()
|
||
if self._validate_case(case):
|
||
return case
|
||
|
||
return self._default_case()
|
||
|
||
def _generate_simple_case(self):
|
||
n = random.randint(2, 3)
|
||
c = [random.randint(5, 10) for _ in range(n)]
|
||
b = [random.randint(0, 2) for _ in range(n-1)]
|
||
x = random.randint(-10, 0)
|
||
return {'n':n, 'c':c, 'b':b, 'x':x}
|
||
|
||
def _generate_zero_c_case(self):
|
||
n = 3
|
||
c = [0] + [random.randint(0, 5) for _ in range(n-1)]
|
||
b = [random.randint(0, 5) for _ in range(n-1)]
|
||
x = random.randint(-5, 0)
|
||
return {'n':n, 'c':c, 'b':b, 'x':x}
|
||
|
||
def _generate_max_b_case(self):
|
||
n = random.randint(2, 4)
|
||
c = [random.randint(50, 100) for _ in range(n)]
|
||
b = [100] * (n-1)
|
||
x = random.randint(-100, 0)
|
||
return {'n':n, 'c':c, 'b':b, 'x':x}
|
||
|
||
def _generate_negative_x_case(self):
|
||
n = random.randint(2, 3)
|
||
c = [random.randint(10, 100) for _ in range(n)]
|
||
b = [random.randint(0, 10) for _ in range(n-1)]
|
||
x = random.randint(-1000, -100)
|
||
return {'n':n, 'c':c, 'b':b, 'x':x}
|
||
|
||
def _validate_case(self, case):
|
||
try:
|
||
result = self._get_r(case['x'], case['n'], case['c'], case['b'])
|
||
return result >= 0
|
||
except:
|
||
return False
|
||
|
||
def _default_case(self):
|
||
return {
|
||
'n': 3,
|
||
'c': [2, 3, 4],
|
||
'b': [2, 1],
|
||
'x': -1
|
||
}
|
||
|
||
@staticmethod
|
||
def prompt_func(question_case) -> str:
|
||
# ...保持原有prompt结构，优化问题描述...
|
||
problem_desc = f"""
|
||
Calculate the number of valid arrays for given parameters. Put the final answer within [answer] tags.
|
||
|
||
Problem Parameters:
|
||
n = {question_case['n']}
|
||
c = {' '.join(map(str, question_case['c']))}
|
||
b = {' '.join(map(str, question_case['b']))}
|
||
x = {question_case['x']}
|
||
|
||
Constraints:
|
||
- Array a must satisfy 0 ≤ a_i ≤ c_i for all i
|
||
- The answer should be modulo {MOD}
|
||
- Format answer as: [answer]N[/answer] where N is the computed value
|
||
|
||
Example Valid Response:
|
||
[answer]56[/answer]
|
||
"""
|
||
return problem_desc
|
||
|
||
@staticmethod
|
||
def extract_output(output):
|
||
# 增强模式匹配鲁棒性
|
||
matches = re.findall(r'\[answer\s*\][\n\s]*(-?\d+)[\n\s]*\[/answer\s*\]', output, re.IGNORECASE)
|
||
if not matches:
|
||
return None
|
||
try:
|
||
return int(matches[-1].strip()) % MOD
|
||
except:
|
||
return None
|
||
|
||
@classmethod
|
||
def _verify_correction(cls, solution, identity):
|
||
try:
|
||
expected = cls._get_r(
|
||
identity['x'],
|
||
identity['n'],
|
||
identity['c'],
|
||
identity['b']
|
||
) % MOD
|
||
return solution == expected
|
||
except:
|
||
return False
|
||
|
||
# 保持核心算法不变，增加防御性编程
|
||
@staticmethod
|
||
def _check_0(x, n, b):
|
||
d = s = 0
|
||
for i in range(n):
|
||
if i > 0:
|
||
d += b[i-1]
|
||
s += d
|
||
if x*(i+1) + s > 0:
|
||
return False
|
||
return True
|
||
|
||
@staticmethod
|
||
def _check_1(x, n, c, b):
|
||
sum_s = 0
|
||
d = s = 0
|
||
for i in range(n):
|
||
sum_s += c[i]
|
||
if i > 0:
|
||
d += b[i-1]
|
||
s += d
|
||
if sum_s < x*(i+1) + s:
|
||
return True
|
||
return False
|
||
|
||
@classmethod
|
||
def _compute_dp(cls, x, n, c, b):
|
||
maxN = 10210
|
||
dp = [[0]*maxN for _ in range(n+1)]
|
||
dp[0][0] = 1
|
||
d = s = 0
|
||
|
||
for i in range(n):
|
||
if i > 0:
|
||
d += b[i-1]
|
||
s += d
|
||
current_v = x*(i+1) + s
|
||
max_c = c[i]
|
||
|
||
# 动态规划优化
|
||
for j in range(maxN):
|
||
if dp[i][j] == 0:
|
||
continue
|
||
|
||
min_val = max(current_v, j)
|
||
max_val = min(j + max_c, maxN-1)
|
||
|
||
if min_val > max_val:
|
||
continue
|
||
|
||
# 批量更新区间
|
||
dp[i+1][min_val] = (dp[i+1][min_val] + dp[i][j]) % MOD
|
||
if max_val + 1 < maxN:
|
||
dp[i+1][max_val+1] = (dp[i+1][max_val+1] - dp[i][j]) % MOD
|
||
|
||
# 前缀和优化
|
||
prefix = 0
|
||
for j in range(maxN):
|
||
prefix = (prefix + dp[i+1][j]) % MOD
|
||
dp[i+1][j] = prefix
|
||
|
||
return sum(dp[n]) % MOD
|
||
|
||
@classmethod
|
||
def _get_r(cls, x, n, c, b):
|
||
# 添加输入验证
|
||
if any(ci < 0 for ci in c):
|
||
raise ValueError("Invalid c array")
|
||
if any(bi < 0 for bi in b):
|
||
raise ValueError("Invalid b array")
|
||
|
||
if cls._check_0(x, n, b):
|
||
product = 1
|
||
for ci in c:
|
||
product = (product * (ci + 1)) % MOD
|
||
return product
|
||
if cls._check_1(x, n, c, b):
|
||
return 0
|
||
return cls._compute_dp(x, n, c, b)
|