At first, I assumed this is a sorting question and spent much time on sorting the input record list(I've tried both BST and BBST(AVL)) and they can got AC but doesn't work well. After that I got some hints from my friend Mr Luan which gave the hashtable based approach which quite suit the problem here and it beat the time limit. Apparently that hashtable is the primary actor here and it gives O(N+k) time complexity:
Here are all the codes:
#use Binary Sort Tree
/**//* using Binary Sort Tree time: 0.375 memory: 4567 KB */ #include <cstdio> #include <iostream> #define MAXNUM 100000 #define MAXVAL 5000 #define MAXQRY 100 usingnamespace std; typedef struct BSTNode ...{ int value; struct BSTNode* lchild; struct BSTNode* rchild; } BSTNode; void InsertNode(BSTNode** root, int val); void Traverse(BSTNode* root); //global variables int records[MAXNUM+1]; BSTNode* sort_tree = NULL; int index =0; void main() ...{ int i=0; int rcount =0; int qcount =0; int curval =0; //read records and sort them through BST scanf("%d", &rcount); for(i=0;i<rcount;++i) ...{ scanf("%d", &curval); InsertNode(&sort_tree, curval); } i=0; index =0; //tranverse the tree to get the records in order Traverse(sort_tree); char str[4]; scanf("%s",str); //print out query results scanf("%d", &qcount); for(i =0;i<qcount;++i) ...{ scanf("%d", &curval); printf("%d ", records[curval]); } } void InsertNode(BSTNode** root, int val) ...{ if(*root == NULL) ...{ BSTNode* temp = (BSTNode*)malloc(sizeof(BSTNode)); temp->value = val; temp->lchild = NULL; temp->rchild = NULL; *root = temp; } elseif(val < (*root)->value) ...{ InsertNode(&((*root)->lchild), val); }else ...{ InsertNode(&((*root)->rchild), val); } } void Traverse(BSTNode* root) ...{ if(root->lchild != NULL) ...{ Traverse(root->lchild); } //store current value //printf("%d ", root->value); records[++index] = root->value; if(root->rchild != NULL) ...{ Traverse(root->rchild); } }
#use BBST(AVL TREE)
/**//* using Balanced(AVL) Binary Sort Tree time:0.406s memory: 4567 KB */ #include <cstdio> #include <iostream> #define MAXNUM 100000 #define MAXVAL 5000 #define MAXQRY 100 #define LH +1 #define EH 0 #define RH -1 usingnamespace std; typedef struct BSTNode ...{ int value; int bf;//balance factor struct BSTNode* lchild; struct BSTNode* rchild; } BSTNode; void InsertNode(BSTNode** root, int val, bool* taller); void L_Rotate(BSTNode** root); void R_Rotate(BSTNode** root); void Left_Balance(BSTNode** root); void Right_Balance(BSTNode** root); void Traverse(BSTNode* root); //global variables int records[MAXNUM+1]; BSTNode* sort_tree = NULL; int index =0; void main() ...{ int i=0; int rcount =0; int qcount =0; int curval =0; //read records and sort them through BST scanf("%d", &rcount); for(i=0;i<rcount;++i) ...{ scanf("%d", &curval); bool taller =false; InsertNode(&sort_tree, curval, &taller); } i=0; index =0; //tranverse the tree to get the records in order Traverse(sort_tree); char str[4]; scanf("%s",str); //print out query results scanf("%d", &qcount); for(i =0;i<qcount;++i) ...{ scanf("%d", &curval); printf("%d ", records[curval]); } } void InsertNode(BSTNode** root, int val, bool* taller) ...{ if(*root == NULL) ...{ BSTNode* temp = (BSTNode*)malloc(sizeof(BSTNode)); temp->value = val; temp->lchild = NULL; temp->rchild = NULL; *root = temp; *taller =true; } elseif(val < (*root)->value) ...{ InsertNode(&((*root)->lchild), val, taller); if(*taller) ...{ switch((*root)->bf) ...{ case LH: Left_Balance(root);; *taller =false; break; case EH: (*root)->bf = LH; *taller =true; break; case RH: (*root)->bf = EH; *taller =false; break; } } }else ...{ InsertNode(&((*root)->rchild), val,taller); if(*taller) ...{ switch((*root)->bf) ...{ case LH: (*root)->bf = EH; *taller =false; break; case EH: (*root)->bf = RH; *taller =true; break; case RH: Right_Balance(root); *taller =false; break; } } } } void L_Rotate(BSTNode** root) ...{ BSTNode* rc = (*root)->rchild; (*root)->rchild = rc->lchild; rc->lchild =*root; *root = rc; } void R_Rotate(BSTNode** root) ...{ BSTNode* lc = (*root)->lchild; (*root)->lchild = lc->rchild; lc->rchild =*root; *root = lc; } void Left_Balance(BSTNode** root) ...{ BSTNode* lc = (*root)->lchild; switch(lc->bf) ...{ case LH: (*root)->bf = lc->bf = EH; R_Rotate(root); break; case RH: BSTNode* rc = lc->rchild; switch(rc->bf) ...{ case LH: (*root)->bf = RH; lc->bf = EH; break; case EH: (*root)->bf = lc->bf = EH; break; case RH: (*root)->bf = EH; lc->bf = LH; break; } rc->bf = EH; L_Rotate(&((*root)->lchild)); R_Rotate(root); break; } } void Right_Balance(BSTNode** root) ...{ BSTNode* rc = (*root)->rchild; switch(rc->bf) ...{ case RH: (*root)->bf = rc->bf = EH; L_Rotate(root); break; case LH: BSTNode* lc = rc->lchild; switch(lc->bf) ...{ case LH: rc->bf = RH; (*root)->bf = EH; break; case EH: (*root)->bf = rc->bf = EH; break; case RH: rc->bf = EH; (*root)->bf = LH; break; } lc->bf = EH; R_Rotate(&((*root)->rchild)); L_Rotate(root); break; } } void Traverse(BSTNode* root) ...{ if(root->lchild != NULL) ...{ Traverse(root->lchild); } //store current value //printf("%d ", root->value); records[++index] = root->value; if(root->rchild != NULL) ...{ Traverse(root->rchild); } }
#using hashtable for sorting approach:
#include <cstdio> #include <iostream> usingnamespace std; #define MAXNUM 100000 #define MAXVAL 5000 #define MAXQRY 100 int hash[MAXVAL+1]; /**//* store number of each value within [1, 5000] */ int records[MAXNUM+1]; /**//*store the sorted number array*/ void main() ...{ int i =0, j=0,k=0; int curval =0; int count =0; memset(hash, 0, sizeof(int) * (MAXVAL+1)); scanf("%d", &count); for(i=0;i<count;++i) ...{ scanf("%d", &curval); hash[curval]++; } /**//*sort the records*/ for(i=1,j=0;i<= MAXVAL;++i) ...{ if(hash[i] ==0) continue; k=0; while(k++< hash[i]) ...{ records[++j] = i; } } char str[4]; scanf("%s", str); scanf("%d", &count); for(i=0;i<count;++i) ...{ scanf("%d", &curval); printf("%d ", records[curval]); } }
problem url: http://acm.timus.ru/problem.aspx?space=1&num=1026At first, I assumed this is a sorting question and spent much time on sorting the input record list(Ive tried both BST and BBST(AVL))