COJ 2004 序列

传送门：http://oj.cnuschool.org.cn/oj/home/addSolution.htm?problemID=978

试题描述：

WZJ的数字游戏又开始了。他写了N个自然数Ai到黑板上，让你选取一个起点L和一个终点R使sum(L,R)*min(L,R)最大，请你输出这个最大值。

sum(L,R)表示AL一直加到AR之和，min(L,R)表示AL到AR的最小值。

输入：

第一行为一个正整数N。
接下来为N个自然数Ai。

输出：

输出最大值。

输入示例：

7
1 5 2 0 5 5 7

输出示例：

85

其他说明：

1<=N<=100000
0<=Ai<=1000000

题解：

思路1：枚举所有的最小值，用单调栈或二分RMQ维护一下往前到哪里往后到哪里，然后乱搞答案。

单调栈32ms最快：

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;

inline void read(int& x)
{
    x = 0;
    int sig = 1;
    char ch = getchar();
    while(!isdigit(ch))
    {
          if(ch == '-') sig = -1;
        ch = getchar();
    }
    while(isdigit(ch))
    {
        x = x * 10 + ch - '0';
        ch = getchar();
    }
    x *= sig;
    return ;
}

const int maxn = 100000 + 10;

int A[maxn];
int L[maxn], R[maxn];

int S[maxn];

long long v[maxn], ans;

int main()
{
    int n;
    read(n);
    
    int top = 0;
    
    for(int i = 1; i <= n; i++)
    {
        read(A[i]);
        v[i] = v[i - 1] + A[i];
    }
    
    A[0] = A[n + 1] = -1;
    S[++top] = 0;
    
    for(int i = 1; i <= n; i++)
    {
        while(A[S[top]] >= A[i]) top--;
        L[i] = S[top] + 1;
        S[++top] = i;
    }
    
    S[top = 1] = n + 1;
    
    for(int i = n;i ; i--)
    {
        while(A[S[top]] >= A[i]) top--;
        R[i] = S[top] - 1;
        S[++top] = i;
        
        ans = max(ans, A[i] * (v[R[i]] - v[L[i] - 1]));
    }
    
    printf("%lld", ans);
    
    return 0;
}

由于每一个元素只进入单调栈一次，所以是o(n)的。

RMQ157ms最慢：

#include <iostream>
#include <cstdio>
using namespace std;

const int maxn = 100000 + 10;

int A[maxn];

int n;

int log[maxn], d[maxn][20];

long long ans, S[maxn];

int f1[maxn], f2[maxn];

void RMQ_init()
{
    log[0] = -1;                   //你大爷 
    for(int i = 1; i <= n; i++) 
    {
        d[i][0] = A[i];
        log[i] = log[i >> 1] + 1;
    }
    
    for(int j = 1; (1 << j) <= n; j++)
      for(int i = 1; i + (1 << j) - 1 <= n; i++)   //你大爷 
        d[i][j] = min(d[i][j - 1], d[i + (1 << (j - 1))][j - 1]);
        
    return ;
}

int query(int L, int R)
{
    int k = log[R - L + 1];
    return min(d[L][k], d[R - (1 << k) + 1][k]);
}

int main()
{
    int m, L, R, M;
    scanf("%d", &n);
    
    for(int i = 1; i <= n; i++)
    {
        scanf("%d", &A[i]);
        S[i] = S[i - 1] + A[i];
    }
      
    RMQ_init();
    
    for(int i = 1; i <= n; i++)
    {
        L = 1;
        R = i;
        
        while(L < R)
        {
            M = L + R >> 1;
            if(query(M, i) == A[i]) R = M;
            else L = M + 1; 
        }
        
        f1[i] = L;
    }
    
    for(int i = 1; i <= n; i++)
    {
        L = i;
        R = n + 1;
        
        while(L + 1 < R)
        {
            M = L + R >> 1;
            if(query(i, M) == A[i]) L = M;
            else R = M;
        }
        
        f2[i] = L;
    }
    
    for(int i = 1; i <= n; i++)
      ans = max(ans, (S[f2[i]] - S[f1[i] - 1]) * A[i]);
      
    printf("%lld
", ans);
    
    return 0;
}

RMQ初始化o(nlogn)，查询o(nlogn)。

思路2：将A[i]从大到小排，用并查集维护每个元素的集合，每次将该元素左右的不小于该元素本身的元素合并进来，更新答案。

正确性有待考察……以后补……

并查集47ms还可以：

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;

const int maxn = 100000 + 10;
int f[maxn], Min[maxn];
long long Sum[maxn], _max = 0;
int n, P[maxn];

struct Node{
    int v, id;
    bool operator < (const Node& ths) const{
        return v < ths.v;
    }
}A[maxn];

void read(int& x){
    x = 0;
    int sig = 1;
    char ch = getchar();
    while(!isdigit(ch)){
        if(ch == '-') sig = -1;
        ch = getchar();
    }
    while(isdigit(ch)){
        x = 10 * x + ch - '0';
        ch = getchar();
    }
    x *= sig;
    return ;
}
void input(){
    read(n);
    for(int i = 1; i <= n; i++) read(P[i]), A[i].id = f[i] = i, A[i].v = Min[i] = Sum[i] = P[i];
    return ;
}
int findset(int x){
    return f[x] == x ? x : f[x] = findset(f[x]);
}
void merge(int d1, int d2){
    int f1 = findset(d1);
    int f2 = findset(d2);
    if(f1 != f2){
        Sum[f1] += Sum[f2];
        Min[f1] = min(Min[f1], Min[f2]);
        f[f2] = f1;
        _max = max(_max, Sum[f1] * Min[f1]);
    }
    return ;
}
void work(){
    sort(A + 1, A + 1 + n);
    for(int i = n; i; i--){
        int x = A[i].id;
        if(x != 1 && P[x] <= P[x - 1]) merge(x, x - 1);
        if(x != n && P[x] <= P[x + 1]) merge(x, x + 1);
    }
    return ;
}
void output(){
    printf("%lld
", _max);
    return ;
}
int main(){
    input();
    work();
    output();
    return 0;
}

排序o(nlogn)，扫描o(n)，感觉很不错啊。