void insert2(tnode_t2 **tree, void *data, int (*comp)(void *, void *)) {
if(*tree == NULL) {
//Allocate memory for the node
*tree = malloc(sizeof(tnode_t2));
if(*tree == NULL) {
printf("malloc failed\n");
exit(EXIT_FAILURE);
}
//Initialize node
(*tree)->data = data;
(*tree)->lchild = NULL;
(*tree)->rchild = NULL;
}
else {
//Traverse the tree to find an empty node at correct place
if((*comp)(data, (*tree)->data) < 1) {
insert2(&(*tree)->lchild, data, (*comp));
}
else {
insert2(&(*tree)->rchild, data, (*comp));
}
}
}
int main(int argc, char **argv) {
tnode_t2 *tree = NULL;
insert2(&tree, (void*) 5, &compare2);
insert2(&tree, (void*) 2, &compare2);
insert2(&tree, (void*) 7, &compare2);
insert2(&tree, (void*) 6, &compare2);
insert2(&tree, (void*) 5, &compare2);
print_inorder((tnode_t*) tree);
/* dlist_t *list;
dlist_t *cur;
list = tree2dlist((tnode_t*) tree);
cur = list;
printf("list: ");
do {
printf("%d, ", cur->data);
cur = cur->next;
} while(cur != list);
printf("\n");*/
return 0;
}
int main()
{
printf("\nTEST\n====\n\n");
struct tnode_t *p = NULL;
printf("Testing Insert:\n");
insert(&p, 9);
printf("%d\n", p->data);
insert(&p, 6);
printf("%d\n", p->lchild->data);
insert(&p, 11);
printf("%d\n", p->rchild->data);
insert(&p, 10);
printf("%d\n", p->rchild->lchild->data);
printf("Testing print_inorder:\n");
print_inorder(p);
printf("\n");
printf("Testing size:\n");
printf("%d\n", size(p));
printf("Testing to_array:\n");
int *t;
t = to_array(p);
printf("%d, %d, %d, %d\n", t[0], t[1], t[2], t[3]);
/* Testing dlist */
printf("Testing dlist\n");
struct dlist_t *lst;
lst = tree2dlist(p);
printf("%d, %d, %d, %d\n",
lst->data,
lst->next->data,
lst->next->next->data,
lst->next->next->next->data);
int int9 = 9, int6 = 6, int11 = 11, int10 = 10;
struct tnode_t2 *p2 = NULL;
printf("Testing Insert:\n");
insert2(&p2, &int9, &comp);
printf("%d\n", *(int*)(p2->data));
insert2(&p2, &int6, &comp);
printf("%d\n", *(int*)(p2->lchild->data));
insert2(&p2, &int11, &comp);
printf("%d\n", *(int*)(p2->rchild->data));
insert2(&p2, &int10, &comp);
printf("%d\n", *(int*)(p2->rchild->lchild->data));
return 0;
}
void insert2(tnode_t2 **tree, void *data, int (*comp)(void *, void *)) {
if (*tree == NULL) {
*tree = malloc(sizeof(tnode_t2));
verify_malloc(*tree);
(*tree)->data = data;
(*tree)->lchild = NULL;
(*tree)->rchild = NULL;
} else {
if (comp((*tree)->data, data) >= 0) {
insert2(&(*tree)->lchild, data, comp);
} else {
insert2(&(*tree)->rchild, data, comp);
}
}
}
void insert()
{
/* MemStat memStat("insert"); */
String s1("1234", 5), s2("1234");
String s3("1235", 4), s4("1232");
String s5;
insert2();
cout << "insert" << endl;
s1.insert(1, s1.cStr());
assert(s1.length() == 9);
s2.insert(1, s2);
assert(s2.length() == 8 && s2 == "11234234");
s5.insert(0, s3);
assert(s3 == s5);
s5.insert(2, "abcdef", 4);
assert(s5 == "12abcd35");
s3.insert(s3.length(), "abcd");
assert(s3 == ((String)("1235") + "abcd"));
s3 = "1234";
s3.insert(0, 'x', 5);
assert(s3 == "xxxxx1234");
s3 = "1234";
s3.insert(2, 'x', 5);
assert(s3 == "12xxxxx34");
s3 = "1234";
s3.insert(s3.length(), 'x', 5);
assert(s3 == "1234xxxxx");
}
/** insert2_dense_group -- not really implemented correctly */
int insert2_dense_group(const T& starting_index, int group_size)
{
for(int i=0; i<group_size; ++i) {
insert2(starting_index+i);
}
return(0);
}
int main()
{
//freopen("queries.in","r",stdin);
//freopen("queries.out","w",stdout);
clock_t beg,end;
beg = clock();
scanf("%d",&brt);
int i;
while(brt--)
{
scanf("%d",&n);
hc = 1;
/// test ///
cnt = 0;
for(i=0;i<n;i++)
{
int com;
scanf("%d",&com);
if(com==1)
{
int num;
scanf("%d",&num);
//insert(num);
insert2(num);
}
else
{
//int res = pop();
int res2 = pop2();
//printf("%d\n",res);
printf("%d\n",res2);
}
}
if(brt!=0)
printf("\n");
}
end = clock();
printf("%lf\n",(end-beg)/(double)CLOCKS_PER_SEC);
return 0;
}
auto moveto(const CFDAStar::NODE& node, T insert2, Y check_pass, U hn) {
CFDAStar::NODE tmp;
// 计算节点位置
tmp.x = node.x + xplus; tmp.y = node.y + yplus;
// 可以通行
if (!check_pass(tmp.x, tmp.y)) return;
// 记录父节点位置
tmp.px = -xplus; tmp.py = -yplus;
// 计算g(n)
tmp.gn = node.gn + gplus;
// f(n) = g(n) + h(n)
tmp.fn = tmp.gn + hn(tmp.x, tmp.y);
// 插入
insert2(tmp);
};
void merge_sort(buf *buf, int low, int high) {
int mid = low + (high - low) / 2 + 1;
if (high <= low) { return; }
merge_sort(buf, low, mid-1);
merge_sort(buf, mid, high);
while (low <= mid && mid <= high) {
if (compare(buf, low, mid)) {
low++;
} else {
insert2(buf, low, mid);
mid++;
}
}
}
inline void insert(int town, int w)
{
int place = cnt[town];
setW(town, place, w);
cnt[town]++;
int set = place / sizes[town];
if (min[ws_start[town] + set] > w)
{
min[ws_start[town] + set] = w;
min_indices[ws_start[town] + set] = place;
if (min_total[town] > w)
{
min_total[town] = w;
min_total_index[town] = place;
if (cnt[town] == 1)
insert2(w, town);
else
update2(w, town);
}
}
}
inline int remove2()
{
int result = max2_total;
int town_from = towns2[max2_total_index];
int set1 = max2_total_index / size2, set2 = (cnt2 - 1) / size2;
ws2[max2_total_index] = ws2[cnt2 - 1];
towns2[max2_total_index] = towns2[cnt2 - 1];
town_index[towns2[max2_total_index]] = max2_total_index;
town_index[town_from] = -1;
cnt2--;
updateSet2(set1);
if (set2 != set1)
updateSet2(set2);
updateTotal2();
remove(town_from);
if (cnt[town_from] > 0)
insert2(min_total[town_from], town_from);
return result;
}
int hamming_search_test(const char* filename)
{
long result = errors_counter();
typedef containers::ternary_tree<std::string, const char*> Tst;
Tst names;
names["ABCD"] = "ABCD";
names["Abcd"] = "Abcd";
names["ABcd"] = "ABcd";
names["aBCd"] = "aBCd";
names["abc"] = "abc";
names["abcde"] = "abcde";
names["bcd"] = "bcd";
names["abCD"] = "abCD";
names["abCd"] = "abCd";
names["AbcD"] = "AbcD";
names["ABcD"] = "ABcD";
names["aBCD"] = "aBCD";
names["abCDE"] = "abCDE";
names["abCDd"] = "abCDd";
names["abCcd"] = "abCcd";
names["bcdc"] = "bcdc";
names["aab"] = "aab";
// hamming_search(2): ABcd, AbcD, Abcd, aBCd, abCD, abCd, abc, abcde
// levenshtein_search(2): hamming + abCDd, abCcd bcd, bcdc
Tst::search_results_list matches = names.create_search_results();
typedef Tst::search_results_list::iterator ResultIter;
//names.levenshtein_search_count = 0;
names.levenshtein_search("abcd", std::back_inserter(matches), 2);
//std::cout << "l-count: " << names.levenshtein_search_count << "\n";
//names.levenshtein_search_count = 0;
BOOST_CHECK(matches.size() == 12);
if (matches.size() != 12)
{
// compare with DDJ
{
Tptr root = 0;
for (Tst::iterator it = names.begin(); it != names.end(); ++it) {
insertstr = (char*)*it;
root = insert2(root, insertstr);
}
nearsearch(root, "abcd", 2);
std::cout << "DDJ nearsearch abcd:\n";
for (int i = 0; i != srchtop; i++)
std::cout << srcharr[i] << "\n";
std::cout << "\n";
cleanup2(root);
}
int i = 0;
for (ResultIter rit = matches.begin(); rit != matches.end(); ++rit, ++i) {
std::cout << **rit << " = " << (*rit).key();
std::cout /*<< " = " << matches[i].key()*/ << "\n";
}
}
typedef std::vector<std::string> Dictionary;
extern size_t fill_dictionary(const char*, Dictionary&, size_t, size_t = 0);
Dictionary dictionary;
size_t longest_in_file = fill_dictionary(filename, dictionary, 300);
std::random_shuffle(dictionary.begin(), dictionary.end());
names.clear();
Dictionary wildnames;
// Add names with mini-variations
long zeroes = 0;
Dictionary::iterator dit;
for (dit = dictionary.begin(); dit != dictionary.end(); ++dit) {
const std::string& name(*dit);
std::string namecopy(*dit);
names[namecopy] = name.c_str();
std::string searchstr(name);
for (int i = 0; i < 5; ++i) {
int where = rand() % name.size();
// make string with ? at place of changed char
if (searchstr[where] == '?')
continue;
searchstr[where] = '?';
wildnames.push_back(searchstr);
char c = (char)rand();
if (!c) zeroes++;
namecopy[where] = c;
names[namecopy] = name.c_str();
}
}
for(dit = wildnames.begin(); dit != wildnames.end(); ++dit) {
const std::string& name(*dit);
for (int diff = 1; diff != 3; ++diff) {
Tst::search_results_list matchresults = names.create_search_results();
names.hamming_search(name, std::back_inserter(matchresults), diff);
//if (matchresults.size() == 0)
// std::cout << "couldn't find " << name << '\n';
//BOOST_CHECK(found == matchresults.size());
for (size_t i = 0; i != matchresults.size(); ++i)
BOOST_CHECK(check_hamming_match(matchresults[i].key(), name, diff));
}
}
return errors_counter() - result;
}
//进队
void enqueue(plink*head,link*p){
insert2(head,p);
}
main()
{
int n,m,i,j,k,l,o;
printf("enter no. of terms in 1st polynomial:");
scanf("%d",&n);
for(i=0;i<n;i++)
{
insert1();
}
printf("enter no. of terms in 2nd polynomial:");
scanf("%d",&n);
for(i=0;i<n;i++)
{
insert2();
}
q1=start1;
while(q1!=NULL)
{
printf("%d |",q1->coff);
printf("%d-->",q1->exp);
q1=q1->link;
}printf("NULL\n");
q2=start2;
while(q2!=NULL)
{
printf("%d |",q2->coff);
printf("%d-->",q2->exp);
q2=q2->link;
}printf("NULL\n");
q1=start1;
q2=start2;
while(q1!=NULL||q2!=NULL){
if(q1->exp>q2->exp){
while(q1->exp>q2->exp){
insert3(q1->coff,q1->exp);
q1=q1->link;
}
}
else if(q2->exp>q1->exp){
while(q2->exp > q1->exp){
insert3(q2->coff,q2->exp);
q2=q2->link;
}
}
else if(q1->exp==q2->exp){
while(q1->exp==q2->exp){
insert3((q2->coff+q1->coff),q1->exp);
q1=q1->link;
q2=q2->link;
} }
else
{
q1=q1->link;
q2=q2->link;
}
}
q3=start3;
while(q3!=NULL)
{
printf("%d |",q3->coff);
printf("%d-->",q3->exp);
q3=q3->link;
}printf("NULL\n");
return 0;
}
int main()
{
//Call the insert function whenever you want to and the deletetop() to remove the maximum element whenever needed.
long long int i,j,jj,kk,k,a,b,c,n,m,tempval,finval,temp1,temp2,temp3,state=0,finsum=0,median;
long long int tc;
scanf("%lld", &tc);
for(kk=0;kk<tc;kk++)
{
count=0;
count2=0;
state=0;
finsum=0;
long long int A[300000]={0};
long long int B[300000]={0};
scanf("%lld%lld%lld%lld", &a, &b, &c, &n);
finsum+=1;
insert(A,1);
median=1;
for(k=2;k<=n;k++)
{
//printf("%d ", median);
finsum+=funct(k,a,b,c,median);
finval=funct(k,a,b,c,median);
//printf("%lld %lld %lld %lld %lld %lld\n", k, a, b, c, median, finval);
/*if(k<=8)
{
for(jj=1;jj<=count;jj++)
printf("%lld ", A[jj]);
printf("\n");
for(jj=1;jj<=count2;jj++)
printf("%lld ", B[jj]);
printf("\n");
}*/
if(state==2)
{
if(finval>median)
{
state=1;
insert2(B,finval);
}
else
{
state=0;
insert(A,finval);
}
}
else if(state==1)
{
if(finval>median)
{
state=2;
temp1=B[1];
deletetop2(B);
insert(A,temp1);
insert2(B,finval);
}
else
{
state=2;
insert(A,finval);
}
}
else if(state==0)
{
if(finval<median)
{
state=2;
temp1=A[1];
deletetop(A);
insert2(B,temp1);
insert(A,finval);
}
else
{
state=2;
insert2(B,finval);
}
}
if(state==2)
median=A[1];
else if(state==1)
median=B[1];
else if(state==0)
median=A[1];
}
printf("%lld\n", finsum);
}
/*
long long int B[100000]={100000000};
long long int i,a,b,c;
scanf("%lld%lld%lld%lld", &a, &b, &c, &i);
insert2(B,5);
insert2(B,9);
insert2(B,10);
printf("%lld %lld %lld %lld\n", B[1], B[2], B[3], B[4]);
deletetop2(B);
printf("%lld %lld %lld %lld\n", B[1], B[2], B[3], B[4]);
insert2(B,12);
printf("%lld %lld %lld %lld\n", B[1], B[2], B[3], B[4]);*/
return 0;
}
