DS HW2

#include<stdio.h>
#include<stdbool.h>
#include<stdlib.h>
#include<string.h>
int poknum;
int max(int _,int __){
    return _>__? _:__;
}
typedef struct poke{
    int id,hp,at,lv;
    struct poke *pre,*nxt;
}pok;
pok* Insert(pok *head){
    poknum++;
    int id,at,hp;
    char cmd[20];
    scanf("%d%d%d%s",&id,&at,&hp,cmd);
    if(poknum==1){
        pok* newpok=(pok*)malloc(sizeof(pok));
        newpok->at=at;
        newpok->id=id;
        newpok->hp=hp;
        newpok->lv=1;
        newpok->pre=newpok;
        newpok->nxt=newpok;
        return newpok;
    }
    if(cmd[0]=='A'){
        if(poknum>2){
            head->pre->hp-=at;
            if(head->pre->hp<=0){
                poknum--;
                pok *trash=head->pre;
                head->pre=trash->pre;
                head->pre->nxt=head;
                free(trash);
            }
        }
        if(poknum>1){
            head->hp-=at;
            if(head->hp<=0){
                poknum--;
                head->at=at;
                head->id=id;
                head->hp=hp;
                head->lv=1;
            }else{
                pok* newpok=(pok*)malloc(sizeof(pok));
                newpok->at=at;
                newpok->id=id;
                newpok->hp=hp;
                newpok->lv=1;
                newpok->pre=head->pre;
                newpok->pre->nxt=newpok;
                newpok->nxt=head;
                head->pre=newpok;
            }
            return head;
        }
    }else if(cmd[0]=='E'){
        if(poknum>2&&head->id==id&&head->pre->id==id&&head->pre->lv<3&&head->lv<3){
            poknum-=2;
            head->at=max(at,max(head->pre->at,head->at));
            head->hp=max(hp,max(head->pre->hp,head->hp));
            head->lv=max(head->pre->lv,head->lv);
            head->lv++;
            pok *trash=head->pre;
            head->pre=trash->pre;
            trash->pre->nxt=head;
            free(trash);
        }else{
            pok* newpok=(pok*)malloc(sizeof(pok));
            newpok->at=at;
            newpok->id=id;
            newpok->hp=hp;
            newpok->lv=1;
            newpok->pre=head->pre;
            newpok->pre->nxt=newpok;
            newpok->nxt=head;
            head->pre=newpok;
        }
        return head;
    }else{
        pok* newpok=(pok*)malloc(sizeof(pok));
        newpok->at=at;
        newpok->id=id;
        newpok->hp=hp;
        newpok->lv=1;
        newpok->pre=head->pre;
        newpok->pre->nxt=newpok;
        newpok->nxt=head;
        head->pre=newpok;
        return head;
    }
}
pok* Delete(pok *head){
    if(poknum==0) return NULL;
    poknum--;
    pok *trash=head;
    head=head->nxt;
    head->pre=trash->pre;
    trash->pre->nxt=head;
    free(trash);
    return (poknum==0? NULL:head);
}
pok* Shuffle(pok *head){
    char dir[5];
    int n,id,lv,at,hp;
    scanf("%s%d",dir,&n);
    n%=poknum;
    if(n==0) return head;
    pok *aim=head;
    if(dir[0]=='c') while(n--) aim=aim->nxt; else while(n--) aim=aim->pre;
    hp=head->hp;
    at=head->at;
    id=head->id;
    lv=head->lv;
    head->hp=aim->hp;
    head->at=aim->at;
    head->id=aim->id;
    head->lv=aim->lv;
    aim->hp=hp;
    aim->at=at;
    aim->id=id;
    aim->lv=lv;
    return aim;
}
pok* Check(pok *head){
    int x;
    scanf("%d",&x);
    if(x>poknum) x=poknum;
    int num[101],i;
    pok* addr[101][10001];
    memset(num,0,101*sizeof(int));
    pok* now=head;
    while(x--){
        i=now->id;
        addr[i][num[i]++]=now;
        now=now->nxt;
    }
    for(int j=0;j<101;j++) if(num[j]>1){
        for(int k=0;k<num[j];k++){
            if(addr[j][k]==head){
                head=Delete(addr[j][k]);
            }else{
                Delete(addr[j][k]);
            }
        }
    }
    return head;
}
void Reverse(pok *head){
    int n;
    scanf("%d",&n);
    if(n<=1) return;
    else if(n>poknum) n=poknum;
    int data[n][4],rem=poknum;
    pok *now=head,*temp;
    while(rem>=n){
        rem-=n;
        temp=now;
        for(int i=0;i<n;i++){
            data[i][0]=now->at;
            data[i][1]=now->hp;
            data[i][2]=now->id;
            data[i][3]=now->lv;
            now=now->nxt;
        }
        now=temp;
        for(int j=n-1;j>=0;j--){
            now->at=data[j][0];
            now->hp=data[j][1];
            now->id=data[j][2];
            now->lv=data[j][3];
            now=now->nxt;
        }
    }
    while(rem>1){
        temp=now;
        for(int i=0;i<rem;i++){
            data[i][0]=now->at;
            data[i][1]=now->hp;
            data[i][2]=now->id;
            data[i][3]=now->lv;
            now=now->nxt;
        }
        now=temp;
        for(int j=rem-1;j>=0;j--){
            now->at=data[j][0];
            now->hp=data[j][1];
            now->id=data[j][2];
            now->lv=data[j][3];
            now=now->nxt;
        }
        rem=0;
    }
}
void solve(){
    int t;
    char cmd[20];
    scanf("%d",&t);
    pok *head=NULL;
    while(t--){
        scanf("%s",cmd);
        switch(cmd[0]){
        case 'I':
            head=Insert(head);
            break;
        case 'D':
            head=Delete(head);
            break;
        case 'S':
            head=Shuffle(head);
            break;
        case 'C':
            head=Check(head);
            break;
        case 'R':
            Reverse(head);
            break;
        default:
            break;
        }
    }
    if(poknum==0){
        puts("no Poke Poke ;-;");
    }else{
        pok *now=head;
        for(int i=0;i<poknum;i++){
            printf("ID: %d HP: %d LVL: %d\n",now->id,now->hp,now->lv);
            now=now->nxt;
        }
    }
}
int main(){
    poknum=0;
    solve();
    return 0;
}
/*
CS2351_DS_24Spring_HW2
https://acm.cs.nthu.edu.tw/contest/2977/
NTHU OJ 14272 - A Trainer's Final Battle
AC code
2024 April 7
*/