hdu Max Sum of Max-K-sub-sequence（单调队列）

Max Sum of Max-K-sub-sequence

Time Limit : 2000/1000ms (Java/Other)   Memory Limit : 32768/32768K (Java/Other)

Total Submission(s) : 6   Accepted Submission(s) : 4

Font: Times New Roman | Verdana | Georgia

Font Size: ← →

Problem Description

Given a circle sequence A[1],A[2],A[3]......A[n]. Circle sequence means the left neighbour of A[1] is A[n] , and the right neighbour of A[n] is A[1].
Now your job is to calculate the max sum of a Max-K-sub-sequence. Max-K-sub-sequence means a continuous non-empty sub-sequence which length not exceed K.

Input

The first line of the input contains an integer T(1<=T<=100) which means the number of test cases. 
Then T lines follow, each line starts with two integers N , K(1<=N<=100000 , 1<=K<=N), then N integers followed(all the integers are between -1000 and 1000).

Output

For each test case, you should output a line contains three integers, the Max Sum in the sequence, the start position of the sub-sequence, the end position of the sub-sequence. If there are more than one result, output the minimum start position, if still more than one , output the minimum length of them.

Sample Input

4
6 3
6 -1 2 -6 5 -5
6 4
6 -1 2 -6 5 -5
6 3
-1 2 -6 5 -5 6
6 6
-1 -1 -1 -1 -1 -1

Sample Output

7 1 3
7 1 3
7 6 2
-1 1 1

Author

shǎ崽@HDU

Source

HDOJ Monthly Contest – 2010.06.05

思路：朴素算法很容易想到，两个for循环，先遍历每个可能的终点，在每个终点中查找k范围的起点，

但这样时间复杂度太高，肯定不行。

注意到每次在k范围查找时，实际不用从头到尾查，因为终点的sum值是一定的，所以只需要起点的sum值最小

就可以了， 这样就将问题转化为求动态区间内的最小值，于是想到单调队列。

注意这题不能遍历起点进行查找，因为这样无法得到k区间内的最小值。

#include <stdio.h>
#include <string.h>
#include <deque>
#define Min -9999
using namespace std;

int a[200005];
int k;
struct Node{
    int num;
    int p;
}sum[200005];
deque <struct Node> d;


int main(){
    int T,n;
    int i;
    int max,start,end;

    for(i = 0;i < 200005;i++){
        sum[i].p = i;
    }
    scanf("%d",&T);
    while(T--){
        while(!d.empty()){
            d.pop_back();
        }
        scanf("%d%d",&n,&k);
        for(i = 1;i <= n;i++){
            scanf("%d",&a[i]);
            a[n+i] = a[i];
        }
        
        sum[0].num = 0;
        d.push_back(sum[0]);
        for(i = 1;i < 2*n;i++){
            sum[i].num = sum[i-1].num + a[i];
        }
        max = Min;//将max初始为负无穷
        //并没有先将sum[i]插入，因为在查找的时候，
        //区间的起点一定不能是终点，否则会导致max至少为0
        for(i = 1;i < 2*n;i++){
            while(!d.empty() && sum[i].p - d.front().p > k){//注意是>,而不是>=
                d.pop_front();
            }
            if(sum[i].num - d.front().num > max){
                start = (d.front().p + 1) > n ? (d.front().p + 1) % n: d.front().p + 1;
                end = (i > n )? i % n : i;
                max = sum[i].num - d.front().num;
            }
            while(!d.empty() && d.back().num >= sum[i].num){
                d.pop_back();
            }
            d.push_back(sum[i]);
        }
        printf("%d %d %d\n",max,start,end);
    }
    return 0;
}