HDU-5662 YJQQQAQ and the function （枚举&&单调栈）

YJQQQAQ and the function

http://acm.hdu.edu.cn/showproblem.php?pid=5662

Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)

Problem Description

YJQQQAQ has an array  A  of length  n . He defines a function  fl,r,k  where  l,r,k  are positive integers that satisfies  l≤r  and  r×k≤n , and the value of the function equals to  p×q×⌊k√⌋  where  p  equals to the sum value of  Al×k,A(l+1)×k,...,Ar×k  and  q  equals to the minimal value of them. YJQQQAQ wants to choose the positive integers  l,r,k  carefully to maximize the value of the function.

 

Input

The first line contains an integer  T(1≤T≤3) ——The number of the test cases. For each test case:
The first line contains an integers  n(1≤n≤300,000) .
The second line contains  n  integers describing the given array  A , the  i th integer is  Ai(1≤Ai≤1,000,000) . Between each two adjacent integers there is a white space separated.

 

Output

For each test case, the only line contains the only integer that is the maximum value of the function.

 

Sample Input

   
   
   
   

    
    
    
    1
3
2 3 1
   
   
   
   

 

Sample Output

   
   
   
   

    
    
    
    10


    
    
    
    
 
     
 
      Hint 
     
 When and only when l=1,r=2,k=1, the value of the function is the maximum. 
    
   
   
   
   

官方题解：

先枚举$k$，将所有A_{i\times k}A​i×k​​（$i$是正整数且$i\times k<=n$）取下来存到B_iB​i​​，于是将原问题转化成了下述问题：对于给定的正整数序列

B_1,B_2,...,B_{\lfloor\frac{n}{k}\rfloor}B​1​​,B​2​​,...,B​⌊​k​​n​​⌋​​，求出连续的一段，使得这段的和值乘以这段的最小值的结果最大。

我们可以枚举最小值，设其在第$i$位出现，此时我们只要和值最大就可以了。设B_iB​i​​向左第一个小于B_iB​i​​的数是$l$（若没有则$l=0$），向右第一个小于$Bi$的数是$r$（若没有则r=\lfloor\frac{n}{k}\rfloor+1r=⌊​k​​n​​⌋+1）。

则保证最小值不变的最大和值是B_{l+1},B_{l+2}...B_{r-1}B​l+1​​,B​l+2​​...B​r−1​​这段。可以使用单调栈这种数据结构来在O(\lfloor\frac{n}{k}\rfloor)O(⌊​k​​n​​⌋)的复杂度下计算对于每个$i$的$l$和$r$，枚举最小值出现位置及更新答案的复杂度也是

O(\lfloor\frac{n}{k}\rfloor)O(⌊​k​​n​​⌋)。

再考虑外层的枚举k这一部分，总复杂度为O\left(1+\frac{n} {2}+...+\frac{n}{n}\right)O(1+​2​​n​​+...+​n​​n​​)即O(n\times(1+\frac{1}{2}+...+\frac{1}{n}))O(n×(1+​2​​1​​+...+​n​​1​​))，由于调和级数1+\frac{1}{2}+...+\frac{1}{n}1+​2​​1​​+...+​n​​1​​为$logn$级别，因此时间复杂度为$O\left(nlogn\right)$。

做了这题，还学习了单调栈的使用及其用途

#include <cstdio>
#include <algorithm>

using namespace std;

struct Node {
    int index,sta;
}s[300005];

int a[300005],b[300005],sta[300005],des[300005],n,sqrtK,cnt,top;
long long sum[300005],ans;//sum[i]为b数组中区间[1,i]的和

int main() {
    int T;
    scanf("%d",&T);
    while(T-->0) {
        scanf("%d",&n);
        for(int i=1;i<=n;++i) {
            scanf("%d",a+i);
        }

        ans=0;
        for(int k=1;k<=n;++k) {//枚举k
            sum[0]=cnt=0;
            for(int i=k;i<=n;i+=k) {//找到所有的a[l*k]，l*k<=n
                b[++cnt]=a[i];
                sum[cnt]=sum[cnt-1]+b[cnt];
            }

            b[0]=b[++cnt]=-1;//令最后一个元素的下一个高度为-1，避免循环完毕后还要弹出栈中所有元素
            s[0].index=s[0].sta=0;
            top=0;
            for(int i=1;i<=cnt;++i) {
                if(b[i]>=b[s[top].index]) {//若当前元素大于等于栈顶元素
                    ++top;
                    s[top].index=s[top].sta=sta[i]=i;//其起始下标就是自己的下标
                }
                else {
                    while(b[i]<b[s[top].index]) {
                        des[s[top].index]=i-1;//获得以b[s[top].index]为最小值的区间结束的下标
                        --top;//弹出栈顶元素
                    }
                    s[++top].index=i;//其起始下标是弹出的最后一个元素的起始下标
                    sta[i]=s[top].sta;//获得以b[s[top].index]为最小值的区间开始的下标
                }
            }

            sqrtK=sqrt(k);
            for(int i=1;i<=cnt;++i)//枚举最小值
                ans=max(ans,1LL*(sum[des[i]]-sum[sta[i]-1])*b[i]*sqrtK);
        }
        printf("%I64d\n",ans);
    }
    return 0;
}