zzulioj-1917-E【思维】_zzuli.oj1152-优快云博客

本文链接：https://blog.youkuaiyun.com/wang907553141/article/details/52254435

本文介绍了一种解决特定算法问题的方法，该问题要求计算所有连续子序列的价值和，并判断其是否为素数来决定餐食。文章通过示例详细解释了如何使用C++实现这一算法，包括输入输出格式、数据结构设计等。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目链接：点击打开链接

1917: E

Time Limit: 1 Sec Memory Limit: 128 MB
Submit: 140 Solved: 32

Submit Status Web Board

Description

晴天有非常严重的选择恐惧症，每次吃饭前他都在纠结到底吃什么。。今天又到了吃饭的时候了。

重光：我给你一个包含n个不同整数的序列a，如果它所有连续子序列的价值和是素数咱们就吃米，不然就吃面。

定义一个序列的价值为序列中所有元素的最小值。

晴天：这不是分分钟给你算出来。

嗯...十分钟过去了，晴天选择死亡。

这个任务就交给你啦。

算出所有连续子序列的价值和。

Input

第一行输入一个整数t，代表有t组测试数据。
每组数据第一行包含一个整数n，表示序列a的元素个数。
接下来一行包含n个整数，表示序列a。
0<=n<=50000，1<=ai<=50000。

Output

对于每组数据输出一个整数，表示序列a的所有连续子序列的价值和。

Sample Input

1
3
1 2 3

Sample Output

我Y神的代码：

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int MAXN = 5e4 + 10;
vector<int> G;
vector<int> :: iterator it;
int pos[MAXN], b[MAXN];
int main()
{
    int t; scanf("%d", &t);
    while(t--) {
        int n; scanf("%d", &n);
        for(int i = 1; i <= n; i++) {
            scanf("%d", &b[i]);
            pos[b[i]] = i;
        }
        sort(b + 1, b + n + 1); LL ans = 0; G.clear();
        //G.begin ... G.end()
        for(int i = 1; i <= n; i++) {
            it = upper_bound(G.begin(), G.end(), pos[b[i]]);
            int L, R;
            if(it == G.end()) {//找不到比它大的
                if(G.size() == 0) { //找不到比它小的
                    L = pos[b[i]] - 1;
                    R = n - pos[b[i]];
                }
                else {
                    R = n - pos[b[i]];
                    int p = it - G.begin() - 1;
                    L = pos[b[i]] - G[p] - 1;
                }
            }
            else {
                if(it - G.begin() == 0) { //找不到比它小的
                    L = pos[b[i]] - 1;
                    //int p = it - G.begin();
                    //R = G[p] - pos[b[i]] - 1;
                    R=G[0]-pos[b[i]]-1;
                }
                else { //到比它小的
                    int p = it - G.begin();
                    R = G[p] - pos[b[i]] - 1;
                    L = pos[b[i]] - G[p-1] - 1;
                }
            }
			//cout << L << ' ' << R << endl;
            ans += 1LL * (L + 1) * (R + 1) * b[i]; // 1LL 是类型强制转换，转换为 LL 
            it = lower_bound(G.begin(), G.end(), pos[b[i]]);
            G.insert(it, pos[b[i]]);
        }
        printf("%lld\n", ans);
    }
    return 0;
}

//一、找不到比pos大，存在比它小的
//二、找到比pos大的，不存在比它小的
//三、都找不到
//四、都能找到


//L : b[i] 左边可以取几个
//R : b[i] 右边可以取几个

//2 6 10
//从小到大统计：
//b[i]: b[1] - b[i-1]
//统计每一个数作为序列最小值的贡献
//b[i]: 作为序列的最小值，这样的序列有多少个？
//
//2 6 10
//pos = 8
//L: 从左边开始离pos最近的已经出现的位置
//> 8 = 2 - 1 -> G[1] = 6;
//
//R: 从右边开始里pos最近的已经出现的位置
//> 8 = 2 -> G[2] = 10;
//
//1 (2) 3 4 5 (6) 7 8 9 (10)
//L: 6 + 1 = 7
//R: 10 - 1 = 9 [L, R]
//
//[7, 9] 8
//[L, R] 包含第i个元素的序列有多少个？
//L <= i <= R
//(i - L + 1) * (R - i + 1) * b[i]