<think>我们正在解决一个关于成绩单起点选择的问题。根据问题描述，我们有一系列按时间顺序排列的成绩单，每张成绩单有两个属性：成绩和爸爸的心情变化值。我们需要选择一个起点，然后依次读取成绩单，直到爸爸的心情值变为负数为止。我们的目标是计算有多少个起点可以满足条件：从该起点开始读取成绩单，在读取过程中爸爸的心情值始终
不为负数（即心情值在变为负数之前停止读取）。
注意：题目要求我们修改C++代码以正确计算满足条件的起点数量。根据之前的讨论，我们可能已经尝试了暴力方法，但可能由于数据量较大而导致超时。因此，我们需要优化算法。
优化思路：
1. 问题可以转化为：给定一个长度为n的循环数组（成绩单是循环的，但题目要求按顺序读取，所以实际上可以视为两个数组拼接），每个元素有一个心情变化值（正或负），我们需要找到所有起点i，使得从i开始，累加心情变化值，直到累加和第一次出现负数之前停止，要求累加过程中任意时刻累加和
不为负。
2. 由于是循环数组，我们可以考虑将数组复制一份接在后面，形成长度为2n的数组，然后通过滑动窗口或双指针来避免重复计算。
3. 但是，直接暴力枚举每个起点然后模拟过程的时间复杂度是O(n^2)，对于大数据量会超时。
4. 另一种思路是使用单调队列优化，类似于解决滑动窗口最小值问题，但这里我们关心的是区间和。我们可以计算心情变化值数组的前缀和，然后问题转化为：对于每个起点i，在区间[i, i+n-1]内，前缀和数组（从i开始的前缀和）的任意时刻（即任意子区间起点到当前位置）都
不能为负。这实际上要求从i开始的最小前缀和（在区间[i, i+n-1]中）
不小于0（这里注意，我们考虑的是相对前缀和，即从i开始到j的和为S[j]-S[i-1]）。
5. 具体步骤：
a. 将心情变化值数组记为a，长度为n。
b. 构建一个长度为2n的数组b，其中b[i] = a[i % n]（即复制一次）。
c. 计算前缀和数组pref，长度为2n+1：pref[0]=0, pref[i]=pref[i-1]+b[i-1]（i从1到2n）。
d. 问题转化为：对于每个起点i（0<=i<n），我们需要判断在区间[i, i+n-1]内，最小的pref[j]（j从i+1到i+n）减去pref[i]是否大于等于0。即：min(pref[j]) - pref[i] >= 0 (j=i+1,...,i+n)。
6. 我们可以使用单调队列来快速求出每个长度为n的滑动窗口的最小值。具体地，我们维护一个单调递增的队列，队列中存放的是数组pref的下标。
7. 算法步骤：
a. 初始化一个双端队列deque。
b. 遍历j从1到2n（注意我们的pref数组下标从0到2n）：
- 首先，如果队列非空且队首元素对应的下标小于当前窗口的起始位置（即j-n），则弹出队首（因为窗口移动，队首已经
不在窗口内）。
- 然后，如果队列非空且pref[队列尾部]大于等于pref[j-1]（注意这里我们考虑的是pref数组，窗口范围是[j-n, j-1]？实际上我们需要的是窗口[i, i+n]的最小值，而i从0到n-1，所以窗口右端点为i+n，即j从n到2n），则弹出队尾直到队列为空或者队尾对应的pref小于当前值。
- 将当前下标j-1加入队尾（因为pref数组有2n+1个元素，下标0..2n，我们考虑的是下标0..2n-1？注意这里需要调整）。
- 当j>=n时，说明窗口已经覆盖了n个元素，此时队首就是窗口[j-n, j-1]中pref的最小值的下标。注意：我们的窗口应该覆盖从j-n到j-1，共n个元素。
c. 但是，我们要求的是从起点i开始，对应的窗口是[i, i+n]（i从0到n-1），即我们需要查询区间[i+1, i+n]的最小值（因为从i开始到j的和为pref[j]-pref[i]，所以需要最小化pref[j]）。因此，我们实际上需要查询的是pref在区间[i+1, i+n]的最小值，然后判断min_value - pref[i] >= 0。
8. 因此，我们可以使用单调队列求出每个长度为n的窗口（从下标1到2n，窗口为[i+1, i+n]）的最小值，然后判断最小值是否大于等于pref[i]（注意这里i从0到n-1）。
9. 注意：由于我们复制了数组，所以只需要考虑i从0到n-1。
10. 但是，还有一种特殊情况：如果整个心情数组都是非负的，那么任意起点都可以，结果就是n。
不过，我们的方法可以处理这种情况。
11. 代码步骤：
a. 读入n和数组a（长度为n）。
b. 构建数组b（长度为2*n）：b[i] = a[i % n]（i从0到2*n-1）。
c. 构建前缀和数组pref，长度为2*n+1：
pref[0] = 0;
for (int i=1; i<=2*n; i++) {
pref[i] = pref[i-1] + b[i-1];
}
d. 初始化双端队列deque<int> q。
e. 初始化结果变量ans=0。
f. 遍历j从1到2*n（j是pref的下标，从1到2*n）：
- 当队列非空且队首元素（下标）小于j-n（即窗口左边界为j-n，因为窗口大小为n，覆盖的下标从j-n到j-1）时，弹出队首。
- 当队列非空且pref[q.back()] >= pref[j-1]（注意：我们当前要加入的是j-1，因为pref[j-1]是当前考虑的位置）时，弹出队尾。
- 将j-1加入队尾。
- 当j>=n+1时（因为我们要考虑从i=0开始，窗口为[1, n]），此时窗口[j-n, j-1]的最小值就是pref[q.front()]。
- 然后，如果j>=n+1，那么对应的起点i = j-n-1（因为j从n+1开始，i从0开始），判断条件：pref[q.front()] - pref[i] >= 0，如果成立则ans++。
注意：这里窗口[j-n, j-1]对应的是pref的下标，而起点i=j-n-1，因为pref[i]对应的是起点i的前缀和（即从0到i-1的和？）。实际上，我们定义从起点i开始，到位置k（k>=i）的和为pref[k+1]-pref[i]（因为pref[i]是前i个元素的和，而b[i]对应第i+1个元素？）。这里需要明确。
12. 重新梳理前缀和定义：
我们定义：pref[0]=0
对于位置0（即第一个元素），pref[1] = b[0] = a[0]
所以，从起点i（0<=i<n）开始，到位置i+k（k从0到n-1）的和为：pref[i+k+1] - pref[i]
要求：对于任意k（0<=k<n），有pref[i+k+1]-pref[i]>=0，即pref[i+k+1]>=pref[i]。
等价于：在区间[i+1, i+n]内，pref的最小值大于等于pref[i]。
13. 因此，我们遍历起点i（0<=i<n）时，需要查询区间[i+1, i+n]中pref的最小值，然后判断是否>=pref[i]。
14. 使用单调队列求区间最小值：我们维护一个单调递增队列，队列中保存的是pref数组的下标，并且下标在窗口[i+1, i+n]内。注意：i从0到n-1，所以窗口区间是[i+1, i+n]（长度为n），而i+n最大为2*n-1（因为i最大为n-1，所以i+n=2*n-1）。
15. 具体步骤：
a. 初始化队列q。
b. 先预处理窗口[1, n]（即i=0对应的窗口）？我们可以从j=1开始，一直处理到j=2*n。
c. 遍历j从1到2*n：
- 如果队列非空且队首元素（下标）< j-n+1（因为窗口大小为n，当前窗口为[j-n, j-1]？
不对，我们想要的是窗口[j, j+n-1]？这里需要调整思路）
16. 实际上，我们要求的是固定长度的窗口（长度为n）的最小值，窗口的右端点从n到2*n，左端点从0到n（因为总区间是[0,2*n]）。我们可以在遍历右端点j（从0到2*n）时，维护窗口[j-n+1, j]的最小值。但是，我们需要的窗口是[i+1, i+n]（i从0到n-1），即窗口左端点从1到n，右端点从n到2*n-1。
17. 因此，我们可以这样：
a. 初始化队列q。
b. 遍历j从0到2*n（j是pref的下标，注意pref有2*n+1个元素，下标0..2*n）：
- 如果队列非空且队首元素（下标）小于j-n，则弹出队首（因为窗口大小为n+1？
不对，我们的窗口大小是n，但这里我们实际需要的是区间[i+1, i+n]的最小值，这个区间有n个元素，所以窗口大小为n，左边界为j-n+1？）
- 实际上，我们想要求的是以j为右端点，窗口为[j-n+1, j]的最小值。那么当j>=n时，窗口才有效（即j>=n，这样左边界j-n+1>=1，而我们需要的最小值是从1到2*n的）。
18. 修正：我们要求的是区间[i+1, i+n]的最小值，其中i从0到n-1。所以右端点为i+n，即从0+n到(n-1)+n = 2*n-1。因此，我们遍历右端点r（从1到2*n-1），但是注意我们的窗口大小是n，左端点l=r-n+1（从1到2*n-1-n+1= n）。
19. 因此，我们可以：
a. 初始化队列q。
b. 遍历r从0到2*n（遍历所有pref的下标）：
- 如果队列非空且队首元素（下标）< r-n+1，则弹出队首（因为窗口左边界为r-n+1）。
- 然后，当队列非空且pref[q.back()] >= pref[r]时，弹出队尾。
- 将r加入队尾。
- 当r>=n时（即r从n开始），此时窗口大小为n，左边界为r-n+1，而我们需要的是以r为右端点，窗口为[r-n+1, r]的最小值，这个最小值在队首。
- 但是，我们还需要注意：对于起点i，我们需要的是区间[i+1, i+n]的最小值，而i+1>=1，i+n<=2*n-1（当i=n-1时）。所以，当r>=n时，我们得到的最小值对应窗口[r-n+1, r]的最小值，而这个窗口的右端点r对应起点i=r-n？因为起点i满足i+1=r-n+1，所以i=r-n。所以，我们判断：如果r>=n且r<=2*n-1（因为起点i最大为n-1，所以r最大为n-1+n=2*n-1），那么起点i=r-n，然后判断pref[q.front()] >= pref[i]（即pref[r-n]）？
不对，注意：起点i对应的前缀和是pref[i]，而我们的窗口是[i+1, i+n]，所以最小值的位置在[i+1, i+n]内，这个最小值应该大于等于pref[i]。而这里i=r-n，所以需要判断最小值是否>=pref[r-n]。
20. 具体步骤：
a. 初始化ans=0。
b. 初始化双端队列q。
c. 遍历右端点r（从0到2*n）：
- 当队列非空且队首元素（下标）小于r-n+1时（即q.front() < r-n+1），弹出队首。
- 当队列非空且pref[q.back()] >= pref[r]时，弹出队尾。
- 将r加入队尾。
- 如果r>=n（此时窗口大小达到n）且r<=2*n-1（因为起点i=r-n必须满足i<n，所以r-n<=n-1，即r<=2*n-1）：
i = r - n;
此时，队列队首元素就是窗口[r-n+1, r]的最小值对应的下标，记为min_index = q.front()。
判断：如果pref[min_index] >= pref[i]，则ans++。
d. 输出ans。
21. 注意：这里我们使用r从0到2*n，但pref数组的下标范围是0..2*n。并且，在r<n时，我们
不需要判断，因为窗口还没达到n。
22. 但是，这里有一个问题：我们维护的窗口是[r-n+1, r]，而起点i=r-n，那么区间[i+1, i+n]正好是[r-n+1, r]吗？
i = r-n
i+1 = r-n+1
i+n = (r-n)+n = r
所以，区间[i+1, i+n]就是[r-n+1, r]。因此，正确。
23. 但是，我们还需要注意：在r从0开始，当r<n时，r-n+1可能为负数（比如r=0时，r-n+1=0-n+1<0），所以此时窗口
不完整，我们
不需要判断。而当r>=n时，窗口左边界r-n+1>=0（因为n>=1，所以r>=n时，r-n+1>=1?
不一定，当n=1时，r>=1，左边界=1-1+1=1，而我们的pref数组下标0..2*n，所以0<=左边界<=2*n，但要注意左边界
不能小于0，所以我们在队列中存储的下标是从0开始的，而左边界小于0时我们
不会使用（因为r>=n时，左边界=r-n+1>=0? 当n=1时，r>=1，左边界=1-1+1=1；当n=2，r=2时，左边界=2-2+1=1，所以左边界最小为1）？
不对，当r=n时，左边界= n-n+1=1，所以最小为1。因此，我们只需要在队列中存储下标>=0的元素。
24. 另外，注意pref[0]是0，我们也要考虑。但是，我们的窗口是从1开始的（因为i+1>=1），所以
不会包含0？
不对，起点i=0时，区间为[1, n]，所以
不包含0。所以我们的窗口左边界最小为1，因此我们只需要考虑下标1..2*n。
25. 但是，在遍历r时，r从0开始，我们也会将r=0加入队列。当r<n时，窗口大小
不足n，我们
不使用。当r>=n时，我们只考虑r<=2*n-1，所以r最大为2*n-1，此时左边界=2*n-1-n+1=n，所以窗口为[n, 2*n-1]，对应起点i=2*n-1-n=n-1（最后一个起点）。
26. 然而，我们还需要考虑起点i=0的情况：它对应r=n（因为i=0, r=i+n=n），此时窗口为[1, n]（因为左边界=r-n+1=n-n+1=1，右边界=n），所以正确。
27. 因此，代码实现如下：
步骤：
int n;
cin >> n;
vector<int> a(n);
for (int i=0; i<n; i++) cin >> a[i];
// 构建2n长度的数组b
vector<int> b(2*n);
for (int i=0; i<2*n; i++) {
b[i] = a[i % n];
}
// 构建前缀和数组pref，长度2*n+1
vector<long long> pref(2*n+1, 0);
for (int i=1; i<=2*n; i++) {
pref[i] = pref[i-1] + b[i-1];
}
deque<int> q;
int ans = 0;
// 遍历右端点r，从0到2*n（注意pref数组下标从0到2*n）
for (int r=0; r<=2*n; r++) {
// 维护队首：如果队首元素（下标）小于当前左边界（r-n），则弹出
// 注意：窗口为[r-n, r-1]？
不对，我们上面定义的窗口是[r-n+1, r]？这里需要调整。
// 实际上，我们想维护一个长度为n的窗口，左边界为r-n+1，右边界为r。所以当队首下标小于左边界（r-n+1）时，弹出。
while (!q.empty() && q.front() < r - n) {
q.pop_front();
}
// 维护队尾：保持单调递增
while (!q.empty() && pref[q.back()] >= pref[r]) {
q.pop_back();
}
q.push_back(r);
// 如果r>=n，说明窗口大小已经达到n（实际上，我们维护的窗口大小是n+1？因为左边界r-n+1到r，有r-(r-n+1)+1=n个元素？
不对，元素个数为r - (r-n+1) + 1 = n。所以当r>=n时，窗口大小正好为n。
// 但是，我们要求的是区间[i+1, i+n]的最小值，其中i=r-n，所以需要r>=n且i<n（即r-n<n => r<2n），所以r在[n, 2n-1]之间。
if (r >= n && r < 2*n) {
int i = r - n; // 起点i
// 当前窗口的最小值在队首
long long min_val = pref[q.front()];
// 注意：我们的窗口是[r-n+1, r]（即[i+1, i+n]），所以最小值min_val，要求min_val>=pref[i]（因为从i开始到任意位置j的和为pref[j]-pref[i]，所以要求最小值>=pref[i]）
if (min_val >= pref[i]) {
ans++;
}
}
}
cout << ans << endl;
28. 但是，注意：我们的窗口维护的是pref的下标，而pref数组的下标0..2*n，在r从0到2*n的遍历中，我们维护了一个单调队列。但是，在r>=n且r<2*n时，我们判断起点i=r-n，但是注意pref[i]中的i可能为负数吗？
不会，因为r>=n，所以i=r-n>=0，且r<2*n，所以i<2*n-n=n，即i在[0, n-1]内。
29. 然而，有一个边界问题：当r=n时，i=0，我们判断pref[q.front()] >= pref[0]（即0），而pref[q.front()]是窗口[1,n]的最小值，这个最小值大于等于0，则起点0满足条件。
30. 但是，我们还要注意：在队列中，我们存储了pref的下标，而pref[0]=0，在r=0时加入队列。当r=n时，队列中可能还包含0吗？有可能，因为0在窗口内吗？窗口左边界r-n+1 = n-n+1=1，所以下标0
不在窗口内（因为0<1），所以在r=n之前，0已经被弹出了（在r=0之后的某个r，当r>=n时，0已经被弹出，因为队首0<r-n+1？
不对，我们弹出的条件是q.front()<r-n，而r-n+1是左边界，我们弹出的是小于左边界的元素，而左边界是r-n+1，所以当r>=1时，我们检查队首是否小于r-n（注意：这里我们代码中写的是q.front()<r-n，但左边界应该是r-n+1，所以应该是q.front()<r-n+1？）
31. 修正：在代码中，我们维护队首的条件是：q.front() < r-n。但是，左边界应该是r-n+1，所以我们应该弹出小于r-n+1的元素。因此，应该改为：
while (!q.empty() && q.front() < r - n + 1) {
q.pop_front();
}
32. 这样，当r=n时，左边界= n-n+1=1，所以队首元素如果小于1（即0）就会被弹出。
33. 因此，修改代码中的弹出条件。
34. 另外，注意：在r=0时，我们加入0，然后r=0<n，
不判断。当r=1时，左边界=1-n+1=2-n，如果n>1，则2-n<=0，所以队首0小于2-n？
不一定，如果n=2，则2-2+1=1，所以0<1，弹出0。所以我们需要根据n的大小调整。
35. 但是，当r<n时，左边界r-n+1可能为负数（比如r=0，左边界=0-n+1<0），此时我们
不需要弹出队首，因为所有元素都在窗口内（因为窗口左边界为负数，但实际下标从0开始，所以0在窗口内）。所以，我们应该在左边界>=0时再弹出？或者，我们统一用：如果队首元素小于左边界，则弹出。而左边界可能是负数，但下标最小为0，所以当左边界为负数时，所有元素都
不小于左边界，所以
不会弹出。因此，条件可以保留。
36. 测试：n=2, a=[1, -2]（注意：心情变化值可能是负数）
构建b=[1,-2,1,-2]
pref=[0,1,-1,0,-2] 下标0:0,1:1,2:1-2=-1,3:1-2+1=0,4:0-2=-2
起点i=0：区间[1,2]（即下标1和2）对应的和：pref[1]-pref[0]=1>=0, pref[2]-pref[0]=-1<0 ->
不满足（所以起点0
不满足）
起点i=1：区间[2,3]（下标2和3）对应的和：pref[2]-pref[1]=-1-1=-2<0 ->
不满足，所以答案应该是0。
用我们的算法：
r从0到4（因为2*n=4）
r=0: 队列加入0 -> [0]
r=1: 左边界=1-2+1=0，队首0>=0，所以
不弹出队首；然后维护队尾：pref[0]=0, pref[1]=1，所以0<1，
不弹出，加入1 -> [0,1]（但队列应该是单调递增的，所以0在1前面没问题）。r=1<2，
不判断。
r=2: 左边界=2-2+1=1，队首0<1，弹出0，队列变为[1]；然后pref[1]=1, pref[2]=-1，所以1>-1，弹出1，加入2 -> [2]。此时r=2>=2，且r<4，所以i=2-2=0，判断min_val=pref[2]=-1，pref[0]=0，-1>=0？
不成立，所以
不计数。
r=3: 左边界=3-2+1=2，队首2>=2，
不弹出；然后pref[3]=0，pref[2]=-1<0，所以
不弹出，加入3 -> [2,3]；i=3-2=1，判断min_val=pref[2]=-1（队首是2），pref[1]=1，-1>=1？
不成立，
不计数。
r=4: 左边界=4-2+1=3，队首2<3，弹出2，队列变为[3]；然后pref[4]=-2，比pref[3]=0小，所以弹出3，加入4。r=4>=2，但r=4
不小于4（因为r<2*n=4，所以r<4
不成立，所以
不判断）。
所以ans=0。
37. 但是，在r=2时，我们判断起点i=0，然后min_val=pref[2]=-1，而pref[0]=0，-1<0，所以
不计数，正确。
38. 再测试n=1, a=[1]：
b=[1,1]
pref=[0,1,2]
r=0: 加入0 -> [0]
r=1: 左边界=1-1+1=1，队首0<1，弹出0，队列为空，然后加入1。此时r=1>=1且r<2（2*n=2），所以i=1-1=0，判断min_val=pref[1]=1，pref[0]=0，1>=0，计数1次。
r=2: 左边界=2-1+1=2，队首1<2，弹出1，队列为空，加入2。r=2>=1，但r<2
不成立（因为r=2
不小于2），所以
不判断。
输出ans=1，正确。
39. 再测试n=3, a=[2, -1, 2]：
期望：起点0：2-1+2=3（过程中：2>=0, 2-1=1>=0, 3>=0）-> 满足
起点1：-1+2=1（过程中：-1<0？所以
不满足，因为第一步心情就变为-1？
不对，题目要求：从起点开始读取，直到心情变为负数前停止。所以起点1：第一步读取成绩单后，心情变化-1，心情值变为-1（如果初始心情为0，则变为-1），所以
不满足。
起点2：2（满足）
所以答案应该是2（起点0和2）。
构建b=[2,-1,2,2,-1,2]
pref=[0,2,1,3,5,4,6] 下标0:0,1:2,2:2-1=1,3:1+2=3,4:3+2=5,5:5-1=4,6:4+2=6
用算法：
r=0: 加入0 -> [0]
r=1: 左边界=1-3+1=-1，
不弹出队首；加入1 -> [0,1]（因为pref[0]=0<2，所以
不弹出0，加入1后队列为[0,1]）。r=1<3，
不判断。
r=2: 左边界=2-3+1=0，队首0>=0，
不弹出；然后pref[2]=1，比pref[1]=2小，所以弹出1，加入2 -> [0,2]（单调递增：0,1->0,2？
不对，弹出1后队列为[0]，然后加入2->[0,2]）。r=2<3，
不判断。
r=3: 左边界=3-3+1=1，队首0<1，弹出0，队列变为[2]；然后pref[3]=3>pref[2]=1，所以
不弹出，加入3 -> [2,3]。此时r=3>=3且r<6，i=3-3=0，min_val=pref[2]=1，pref[0]=0，1>=0 -> 计数1（ans=1）。
r=4: 左边界=4-3+1=2，队首2>=2，
不弹出；然后pref[4]=5>pref[3]=3，加入4 -> [2,3,4]；i=4-3=1，min_val=pref[2]=1（因为队首是2，pref[2]=1），pref[1]=2，1>=2？
不成立，
不计数。
r=5: 左边界=5-3+1=3，队首2<3，弹出2，队列变为[3,4]；然后pref[5]=4<pref[4]=5，所以弹出4，然后pref[3]=3<4？
不弹出，加入5 -> [3,5]；i=5-3=2，min_val=pref[3]=3，pref[2]=1，3>=1 -> 计数1（ans=2）。
r=6: 左边界=6-3+1=4，队首3<4，弹出3，队列变为[5]；然后pref[6]=6>pref[5]=4，加入6 -> [5,6]；r=6<6
不成立（因为r<6，而6==6，所以
不判断）。
输出2。
40. 因此，代码实现如下：
注意：使用long long避免溢出。
41. 但是，题目中给出的代码框架是：
#include <iostream>
using namespace std;
// ... 然后需要补充代码
所以，我们按照题目要求，将上述算法代码补充进去。
42. 另外，题目要求：修改C++代码以解决成绩单起点选择问题，确保爸爸心情
不为负数。
43. 完整代码：
注意：我们假设输入格式：第一行是n，第二行是n个整数（表示心情变化值）。
代码：
#include <iostream>
#include <vector>
#include <deque>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i=0; i<n; i++) {
cin >> a[i];
}
// 构建2n长度的数组b
vector<int> b(2 * n);
for (int i=0; i<2*n; i++) {
b[i] = a[i % n];
}
// 构建前缀和数组，长度为2*n+1
vector<long long> pref(2*n+1, 0);
for (int i=1; i<=2*n; i++) {
pref[i] = pref[i-1] + b[i-1];
}
deque<int> q; // 单调队列，存储下标
int ans = 0;
// 遍历右端点r，从0到2*n（注意pref数组下标0..2*n）
for (int r=0; r<=2*n; r++) {
// 维护队首：如果队首元素（下标）小于左边界（左边界为r-n+1），则弹出
// 注意：左边界可能为负数，但下标最小为0，所以当左边界为负数时，所有元素都
不需要弹出。
while (!q.empty() && q.front() < r - n + 1) {
q.pop_front();
}
// 维护队尾：保持单调递增（队尾到队首递增）
while (!q.empty() && pref[q.back()] >= pref[r]) {
q.pop_back();
}
q.push_back(r);
// 当r>=n且r<2*n时，可以判断起点i=r-n
if (r >= n && r < 2*n) {
int i = r - n; // 起点i
long long min_val = pref[q.front()]; // 窗口[r-n+1, r]的最小值
if (min_val >= pref[i]) {
ans++;
}
}
}
cout << ans << endl;
return 0;
}
44. 注意：在循环结束后，输出ans。
45. 测试样例：n=1, a=[1] -> 输出1；n=2, a=[1,-2] -> 输出0；n=3, a=[2,-1,2] -> 输出2。
46. 提交代码。
47. 但是，注意题目中可能有心情变化值很大的情况，所以使用long long存储前缀和。
48. 另外，注意题目中成绩单是循环的，但我们的算法已经通过复制数组处理了循环。
49. 因此，我们按照上述代码修改。
50. 注意：题目没有说明数据范围，但n最大可能10^6，所以使用O(n)的单调队列是可行的。
51. 代码中，我们复制了数组，空间复杂度O(n)，可以接受。
52. 运行测试，确保正确。
53. 如果遇到大数据问题，可以进一步优化空间？这里我们复制了数组，但也可以
不复制，而是用取模的方式计算前缀和，但是这样在单调队列中需要处理循环，比较麻烦。复制数组简单且空间增加一倍，可以接受。
54. 因此，我们按照上述代码实现。
55. 最后，输出满足条件的起点数量。</think>根据问题要求，需要修改C++代码以计算满足条件的成绩单起点数量（从起点开始读取成绩单，过程中爸爸的心情值始终
不为负数）。以下是优化后的解决方案，使用单调队列算法在$O(n)$时间复杂度内高效解决问题：
```cpp
#include <iostream>
#include <vector>
#include <deque>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
// 构建2n长度的循环数组
vector<int> b(2 * n);
for (int i = 0; i < 2 * n; i++) {
b[i] = a[i % n];
}
// 计算前缀和数组（使用long long防止溢出）
vector<long long> pref(2 * n + 1, 0);
for (int i = 1; i <= 2 * n; i++) {
pref[i] = pref[i - 1] + b[i - 1];
}
deque<int> q; // 单调队列（存储下标）
int ans = 0;
// 遍历所有右端点r（0到2n）
for (int r = 0; r <= 2 * n; r++) {
// 移除超出窗口[n-r+1, r]的元素
while (!q.empty() && q.front() < r - n) {
q.pop_front();
}
// 维护单调递增队列
while (!q.empty() && pref[q.back()] >= pref[r]) {
q.pop_back();
}
q.push_back(r);
// 当窗口大小达到n时（r∈[n, 2n-1]）
if (r >= n && r < 2 * n) {
int i = r - n; // 起点i
long long min_val = pref[q.front()]; // 窗口内最小值
if (min_val >= pref[i]) {
ans++; // 满足条件：min(pref[j])≥pref[i]
}
}
}
cout << ans << endl;
return 0;
}
```
### 算法说明
1. **问题转化**
将循环数组扩展为$2n$长度（`b`数组），计算前缀和数组`pref`，其中$pref[i] = \sum_{k=0}^{i-1} b[k]$。起点$i$有效的条件是：在区间$[i+1, i+n]$内，所有$pref[j] \geq pref[i]$（即$\min_{j \in [i+1,i+n]} pref[j] \geq pref[i]$）[^1]。
2. **单调队列优化**
- 使用双端队列维护滑动窗口$[r-n+1, r]$内的最小值
- 当$r \in [n, 2n-1]$时，起点$i = r-n$
- 若$pref[\text{队首}] \geq pref[i]$，则起点$i$有效
3. **时间复杂度**
每个元素入队/出队各一次，时间复杂度$O(n)$，空间复杂度$O(n)$[^4]。
### 测试用例
1. **输入**
`3`
`2 -1 2`
**输出**：`2`（起点0和2有效）
2. **输入**
`1`
`5`
**输出**：`1`（唯一起点有效）
3. **输入**
`2`
`1 -2`
**输出**：`0`（无有效起点）
### 注意事项
1. 使用`long long`防止前缀和溢出
2. 窗口边界处理需精确：$r \in [n, 2n-1]$
3. 单调队列严格保持递增性质
### 相关问题
1. 如何证明单调队列算法在此问题中的正确性？
2. 如果心情值要求严格大于零（非负），代码需要如何修改？
3. 如何处理$n=10^6$级别的超大数据规模？[^4]
[^1]: 成绩单起点选择问题转化为前缀和区间最小值问题
[^4]: 单调队列实现$O(n)$时间复杂度滑动窗口最值计算
90/10法则揭示了生活中只有10%是由发生在我们身上的事情构成的，而剩下的90%取决于我们对这些事情的反应。通过正确应用这一原则，我们可以改善人际关系，减少不必要的压力。
扫一扫
245
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
