是题目数据水吗

#include<bits/stdc++.h>
#define rint register int
#define fu(i,a,b,d,c) for(rint i=a;i<=(b)&&(c);i+=d)
#define fd(i,a,b,d,c) for(rint i=a;i>=(b)&&(c);i-=d)
using namespace std;

#define P 1 //taozi
#define K 2 //sha
#define D 3 //shan
#define F 4 //juedou
#define N 5 //nanman
#define W 6 //wanjian
#define J 7 //wuxie
#define Z 8 //zhuge

#define BC 1
#define JC 2
#define ZC 3

#define MP 1
#define ZP 2
#define FP 3

#define GOOD 1
#define BAD 2
struct Pig;
void checkGameOver();
int fshown(int id);
int nxt(int k);
bool isMP(int id);
bool isDead(int id);
void hit(int to,int from);
struct Card;
struct Basic{};
struct Card:Basic{
	int type;
	int name;
	void act(int to,int from){}
};

void prtPig(int ind);
void prtAllPigs();


void NMact(int from_);
void WJact(int from_);
void JDact(int to,int from);
vector<Card> cardStack;int nowCard;
struct Pig:Basic{
	int type,id;
	int health;
	int shown;
	bool death,haveZG;
	vector<Card> cards;
	bool enemy[12],frd[12];
	bool thinkBad[12];
	void getCard(int k=2){
		fu(i,1,k,1,1)cards.push_back(cardStack[nowCard==cardStack.size()?cardStack.size()-1:nowCard++]);
	}
	void clearMyCard(){
		while(!cards.empty()){cards.pop_back();}
		haveZG=0;
	}
	void hurt(Pig&from){
		health--;
		if(health==0){
			if(IhaveCard(P)!=-1){
				delMyCard(IhaveCard(P));
				health++;
			}
			else {
				death=1;
				checkGameOver();
				if(type==ZP&&from.type==MP){
					from.clearMyCard();
				}
				if(type==FP){
					from.getCard(3);
				}
			}
		}
	}
	Pig(){
		health=4,death=false;
		memset(enemy,0,sizeof enemy);memset(frd,0,sizeof(frd));memset(thinkBad,0,sizeof(thinkBad));
	}
	void play(){
		int nc=0,shaguole=0;
		bool act=0;
		while(nc<cards.size()){
			if(death)break;
			act=0;
			switch (cards[nc].name){
				case P:{
					if(health!=4){
						delMyCard(nc),act=1;
						health++;
					}
					break;
				}
				case K:{
					if(!haveZG&&shaguole)break;
					if(enemy[nxt(id)]||thinkBad[nxt(id)]||(fshown(nxt(id)))&&fshown(nxt(id))!=max(1,type-1))
					{	
						delMyCard(nc);
						hit(nxt(id),id);
						shaguole=1;
						act=1;
						if(fshown(nxt(id))==GOOD)shown=BAD;
						if(fshown(nxt(id))==BAD)shown=GOOD;
					}
					break;
				}
				case D:{
					break;
				}
				case F:{
					if(type==FP){
						bool book[12]={0};
						for(int i=nxt(id);!book[i];i=nxt(i)){
							if(isMP(i)){
								delMyCard(nc);
								shown=BAD;
								JDact(i,id);
								act=1;
								break;
							}
						}
						break;
					}
					for(int i=nxt(id);i!=id;i=nxt(i)){
						if(enemy[i]||thinkBad[i]||(fshown(i))&&fshown(i)!=max(1,type-1)){
							delMyCard(nc);
							if(fshown(i)==GOOD)shown=BAD;
							if(fshown(i)==BAD)shown=GOOD;
							JDact(i,id);
							act=1;
							break;
						}
					}
					
					break;
				}
				case N:{
					delMyCard(nc);
					act=1;
					NMact(id);
					break;
				}
				case W:{
					delMyCard(nc);
					act=1;
					WJact(id);
					break;
				}
				case J:{
					break;
				}
				case Z:{
					delMyCard(nc);
					haveZG=1;
					act=1;
					break;
				}
			}
			if(act)nc=0;
			else nc++;
		}
	}
	
	void delMyCard(int id){cards.erase(cards.begin()+id);}
	int IhaveCard(int type){if(cards.empty())return -1;fu(i,0,(signed)cards.size()-1,1,1)if(cards[i].name==type){return i;}return -1;}
}pigs[12];
int n,m,mp;
int fshown(int id){return pigs[id].shown;}
int nxt(int k){for(int i=k%n+1;i!=k;i=i%n+1)if(!pigs[i].death)return i;return k;}
int haveCard(Pig p,int type){if(p.cards.empty())return -1;fu(i,0,(signed)p.cards.size()-1,1,1)if(p.cards[i].name==type){return i;}return -1;}
bool isMP(int i){
	return pigs[i].type==MP;
}
void delCard(Pig& p,int id){p.cards.erase(p.cards.begin()+id);}
void hit(int to,int from){
	if(haveCard(pigs[to],D)==-1)pigs[to].hurt(pigs[from]);
	else {
		delCard(pigs[to],haveCard(pigs[to],D));
	}
	pigs[to].enemy[pigs[from].id]=1;
}
bool GOODAgainstBAD(Pig&from,Pig&to);
bool BADAgainstGOOD(Pig&from,Pig&to,bool fts);
bool GOODHelpGOOD(Pig&from,Pig&to);
bool BADHelpBAD(Pig&from,Pig&to,bool fts);
bool ZPHelpMP(Pig&from,Pig&to,bool lock){
	bool book[12]={0};
	for(int i=(from.id);!book[i];i=nxt(i)){
		if(pigs[i].type==ZP){
			if(haveCard(pigs[i],J)!=-1){
				to.frd[i]=1;
				pigs[i].frd[to.id]=1;
				if(lock)to.enemy[from.id]=pigs[i].enemy[from.id]=1;
				delCard(pigs[i],haveCard(pigs[i],J));
				pigs[i].shown=GOOD;
				bool flag=BADAgainstGOOD(pigs[i],to,1);
				if(flag)return false;
				return true;
			}
		}
		book[i]=true;
	}
	return false;
}
bool GOODAgainstBAD(Pig&from,Pig&to,bool fts){
	bool book[12]={0};
	for(int i=(from.id);!book[i];i=nxt(i)){
		if(pigs[i].type==ZP||pigs[i].type==MP){
			if(haveCard(pigs[i],J)!=-1){
				if(fts){
					to.enemy[i]=1;
					to.frd[from.id]=from.frd[to.id]=1;
					from.enemy[i]=1;
					pigs[i].enemy[to.id]=pigs[i].enemy[from.id]=1;
				}else{
					to.frd[i]=1;
					from.enemy[i]=1;
					to.enemy[from.id]=1;
					from.enemy[to.id]=1;
					pigs[i].frd[to.id]=pigs[i].enemy[from.id]=1;
				}
				delCard(pigs[i],haveCard(pigs[i],J));
				pigs[i].shown=GOOD;
				bool flag=BADAgainstGOOD(pigs[i],from,0);
				if(flag)return false;
				return true;
			}
		}
		book[i]=true;
	}
	return false;
}
bool BADAgainstGOOD(Pig&from,Pig&to,bool fts){
	bool book[12]={0};
	for(int i=(from.id);!book[i];i=nxt(i)){
		if(pigs[i].type==FP){
			if(haveCard(pigs[i],J)!=-1){
				if(fts){
					to.enemy[i]=1;
					to.frd[from.id]=from.frd[to.id]=1;
					from.enemy[i]=1;
					pigs[i].enemy[to.id]=pigs[i].enemy[from.id]=1;
				}else{
					to.frd[i]=1;
					from.enemy[i]=1;
					to.enemy[from.id]=1;
					from.enemy[to.id]=1;
					pigs[i].frd[to.id]=pigs[i].enemy[from.id]=1;
				}
				
				delCard(pigs[i],haveCard(pigs[i],J));
				pigs[i].shown=BAD;
				bool flag=GOODAgainstBAD(pigs[i],from,0);
				if(flag)return false;
				return true;
			}
		}
		book[i]=true;
	}
	return false;
}
bool BADHelpBAD(Pig&from,Pig&to,bool lock){
	bool book[12]={0};
	for(int i=(from.id);!book[i];i=nxt(i)){
		if(pigs[i].type==FP){
			if(haveCard(pigs[i],J)!=-1){
				to.frd[i]=1;
				pigs[i].frd[to.id]=1;
				if(lock)to.enemy[from.id]=1,pigs[i].enemy[from.id]=1,from.enemy[to.id]=from.enemy[i]=1;
				if(to.type==MP)to.thinkBad[i]=0;
				delCard(pigs[i],haveCard(pigs[i],J));
				pigs[i].shown=BAD;
				bool flag=GOODAgainstBAD(pigs[i],to,1);
				if(flag)return false;
				return true;
			}
		}
		book[i]=true;
	}
	return false;
}
bool GOODHelpGOOD(Pig&from,Pig&to,bool lock){
	bool book[12]={0};
	for(int i=(from.id);!book[i];i=nxt(i)){
		if(pigs[i].type==ZP||pigs[i].type==MP){
			if(haveCard(pigs[i],J)!=-1){
				to.frd[i]=1;
				pigs[i].frd[to.id]=1;
				if(lock)to.enemy[from.id]=1,pigs[i].enemy[from.id]=1,from.enemy[to.id]=from.enemy[i]=1;
				if(to.type==MP)to.thinkBad[i]=0;
				delCard(pigs[i],haveCard(pigs[i],J));
				pigs[i].shown=GOOD;
				bool flag=BADAgainstGOOD(pigs[i],to,1);
				if(flag)return false;
				return true;
			}
		}
		book[i]=true;
	}
	return false;
}
struct VD:Card{VD(){}};
struct TZ:Card{
TZ(){type=BC,name=P;}
};
struct SHA:Card{
SHA(){type=BC,name=K;}
};
struct SHAN:Card{SHAN(){type=BC,name=D;}void act(Pig&to,Pig&from){}};
struct JD:Card{
	JD(){type=JC,name=F;}
};
void JDact(int to_,int from_){
	
	pigs[from_].shown=pigs[to_].shown==GOOD?BAD:GOOD;
	int cur=to_;
	if(pigs[from_].type==MP&&pigs[to_].type==ZP){
		pigs[to_].hurt(pigs[from_]);
		return;
	}
	pigs[to_].enemy[pigs[from_].id]=1;
	if(pigs[to_].type==MP){
		bool flag=ZPHelpMP(pigs[from_],pigs[to_],1);
		if(!flag);
		else{
			pigs[from_].shown=BAD;
			return;
		}
		
	}
	else if(pigs[to_].shown==GOOD){
		bool flag=GOODHelpGOOD(pigs[from_],pigs[to_],1);
		if(flag)return;
	}
	if(pigs[to_].shown==BAD){
		bool flag=BADHelpBAD(pigs[from_],pigs[to_],1);
		if(flag)return;
	}
	if(pigs[to_].shown!=0&&haveCard(pigs[to_],J)!=-1){
		delCard(pigs[to_],haveCard(pigs[to_],J));
		bool flag;
		if(pigs[to_].shown==GOOD)flag=BADAgainstGOOD(pigs[to_],pigs[to_],1);
		else flag=GOODAgainstBAD(pigs[to_],pigs[to_],1);
		if(!flag)return;
	}
	while(haveCard(pigs[cur],K)!=-1){
		delCard(pigs[cur],haveCard(pigs[cur],K));
		if(cur==from_)cur=to_;
		else cur=from_;
	}
	pigs[cur].hurt(cur==from_?pigs[to_]:pigs[from_]);
}
void AOECard(int from_, int cardType){
	Pig *from=&pigs[from_];
	for(int i=nxt((*from).id);i!=(*from).id;i=nxt(i)){
		if(pigs[i].type==MP){
			bool flag=ZPHelpMP(*from,pigs[i],0);
			if(flag)continue;
		}
		else if(pigs[i].shown==GOOD){
			bool flag=GOODHelpGOOD(*from,pigs[i],0);
			if(flag)continue;
		}
		if(pigs[i].shown==BAD){
			bool flag=BADHelpBAD(*from,pigs[i],0);
			if(flag)continue;
		}
		
		if(pigs[i].shown!=0&&haveCard(pigs[i],J)!=-1){
			delCard(pigs[i],haveCard(pigs[i],J));
			bool flag;
			if(pigs[i].shown==GOOD)flag=BADAgainstGOOD(pigs[i],pigs[i],1);
			else flag=GOODAgainstBAD(pigs[i],pigs[i],1);
			if(!flag)continue;
		}
        if(haveCard(pigs[i],cardType)!=-1){
			delCard(pigs[i],haveCard(pigs[i],cardType));
			continue;
		}
		pigs[i].hurt(pigs[from_]);
		if(pigs[i].type==MP){
			if(!pigs[i].frd[from_]&&!pigs[i].enemy[from_]){
				pigs[i].thinkBad[from_]=1;
			}
		}
		
	}
}
bool isDead(int id){return pigs[id].death;}
struct NM:Card{
NM(){type=JC;name=N;}
};
void NMact(int from_){
	AOECard(from_,K);
}
struct WJ:Card{
WJ(){type=JC,name=W;}
};
void WJact(int from_){
	AOECard(from_,D);
}
struct WX:Card{
	WX(){type=JC,name=J;}
	void act(Pig&from,Pig&to){}
};
struct ZG:Card{
	ZG(){type=ZC,name=Z;}
};
Card charToCard(char c){
	switch(c){
		case 'P':return TZ();
		case 'K':return SHA();
		case 'D':return SHAN();
		case 'F':return JD();
		case 'N':return NM();
		case 'W':return WJ();
		case 'J':return WX();
		case 'Z':return ZG();
	};
	return VD();
}
char cardToChar(Card c){
	switch(c.name){
		case P:return 'P';
		case K:return 'K';
		case D:return 'D';
		case F:return 'F';
		case N:return 'N';
		case W:return 'W';
		case J:return 'J';
		case Z:return 'Z';
	}
	return ' ';
}
void prtAns(){
	fu(i,1,n,1,1){
		if(pigs[i].death)printf("DEAD\n");
		else {
			if(pigs[i].cards.empty());
			else {printf("%c",cardToChar(pigs[i].cards[0]));
			fu(j,1,pigs[i].cards.size()-1,1,1)printf(" %c",cardToChar(pigs[i].cards[j]));}
			putchar('\n');
		}
	}
}
void checkGameOver(){
	int haveBAD=0,haveMP=0;
	bool book[12];memset(book,0,sizeof(book));
	for(int i=1;!book[i];i=nxt(i)){
		book[i]=1;
		if(pigs[i].death)continue;
		if(pigs[i].type==FP)haveBAD=1;
		if(pigs[i].type==MP)haveMP=1;
	}
	if(!haveMP){
		printf("FP\n");
		prtAns();
		exit(0);
	}
	if(!haveBAD){
		printf("MP\n");
		prtAns();
		exit(0);
	}
}
int main(){
	freopen("pig.in","r",stdin);
	freopen("pig.out","w",stdout);
	scanf("%d %d\n",&n,&m);
	fu(i,1,n,1,1){
		char c,d;
		scanf("%c%c ",&c,&d);
		if(c=='M'){
			pigs[i].type=MP;
			pigs[i].shown=GOOD;
			mp=i;
		}else if(c=='Z'){
			pigs[i].type=ZP;
		}else if(c=='F'){
			pigs[i].type=FP;
		}
		pigs[i].id=i;
		fu(j,1,4,1,1){
			scanf("%c ",&c);
			pigs[i].cards.push_back(charToCard(c));
		}
		scanf("\n");
	}
	fu(i,1,n,1,1)if(pigs[i].type==ZP)pigs[i].frd[mp]=1;else if(pigs[i].type==FP)pigs[i].enemy[mp]=1;
	fu(i,1,m,1,1){
		char c;
		scanf("%c ",&c);
		cardStack.push_back(charToCard(c));
	}
	int nowPig=mp;nowCard=0;
	while(1){
		pigs[nowPig].getCard();
		pigs[nowPig].play();
		nowPig=nxt(nowPig);
	}
}