Time Limit: 150 ms Memory Limit: 8000 KiB

Problem Description

對於包含n（1<=n<=100000）個整數的序列，對於序列中的每一元素，在序列中查詢其位置之後第一個大於它的值，如果找到，輸出所找到的值，否則，輸出-1。

Input

 輸入有多組，第一行輸入t（1<=t<=10），表示輸入的組數；

以後是 t 組輸入：每組先輸入n，表示本組序列的元素個數，之後依次輸入本組的n個元素。

Output

 輸出有多組，每組之間輸出一個空行（最後一組之後沒有）；

每組輸出按照本序列元素的順序，依次逐行輸出當前元素及其查詢結果，兩者之間以-->間隔。

Sample Input

2
4 12 20 15 18
5 20 15 25 30 6 

Sample Output

12-->20
20-->-1
15-->18
18-->-1

20-->25
15-->25
25-->30
30-->-1
6-->-1

Hint

 本題資料量大、限時要求高，須藉助棧來完成。

#include <stdio.h>
#include <stdlib.h>
#define ERROR 0
#define OK 1
#define FALSE 0
#define TRUE 1
#define OVERFLOW -2
typedef int Status;
typedef int ElemType;
typedef struct SNode{
    ElemType data;
    int pos;
    struct SNode *next;
}SNode,*LinkStack;
typedef struct {
    ElemType data;
    int pos;
}StructArray;

Status InitStack(LinkStack *S){
    //構造一個空棧S
    *S=(LinkStack)malloc(sizeof(SNode));
    if(!*S)
        exit(OVERFLOW);
    (*S)->next=NULL;
    return OK;
}//InitStack

Status Push(LinkStack *S,ElemType e,int pos){
    //入棧
    LinkStack p;
    p=(LinkStack)malloc(sizeof(SNode));
    if(!p)
        exit(OVERFLOW);
    p->data=e;
    p->pos=pos;
    p->next=*S;
    *S=p;
    return OK;
}//Push

Status StackEmpty(LinkStack *S){
    //判斷棧是否為空
    if(!(*S)->next)
        return TRUE;
    return FALSE;
}//StackEmpty

Status Pop(LinkStack *S){
    //出棧
    LinkStack p;
    if(StackEmpty(S))
        return ERROR;
    p=*S;
    *S=(*S)->next;
    free(p);
    return OK;
}//Pop

void ClearStack(LinkStack *S){
    //清除棧S
    LinkStack p;
    while(!StackEmpty(S)){
        p=*S;
        *S=(*S)->next;
        free(p);
    }
}//ClearStack

void DestroyStack(LinkStack *S){
    //銷燬棧S
    ClearStack(S);
    free(*S);
}//DestroyStack

int main(){
    int i,t,n,cnt;
    int result[100000];
    StructArray elem[100000];
    LinkStack S;
    scanf("%d",&t);
    while(t--){
        cnt=0;
        InitStack(&S);
        scanf("%d",&n);
        for(i=0;i<n;i++){
            scanf("%d",&elem[i].data);
            elem[i].pos=i;
        }
        Push(&S,elem[0].data,elem[0].pos);
        while((++cnt)<n){
            while(elem[cnt].data > S->data){
                result[S->pos]=elem[cnt].data;
                Pop(&S);
                if(StackEmpty(&S))
                    break;
            }
            Push(&S,elem[cnt].data,elem[cnt].pos);
        }
        while(!StackEmpty(&S)){
            result[S->pos]=-1;
            Pop(&S);
        }
        for(i=0;i<n;i++)
            printf("%d-->%d\n",elem[i].data,result[i]);
        DestroyStack(&S);
        if(t)
            printf("\n");
    }
    return 0;
}