，练习题

//while (scanf("%d", n) != EOF && n != 0);
////{
////	getchar();
////	for (int i = 0; i < n; i++) {
////		char ch;
////		scanf("%c", &ch);
////		switch (ch) {
////			case 'P':
////				int x;
////				scanf("%d", &x);
////				pushStack(&s, x);
////				break;
////			case 'O':
////				pop(&s);
////				break;
////			case 'A':
////				if (empty(&s))
////					printf(E);
////				else
////					printf(n);
////				break;
////		}
////		getchar();
////	}
////	Free(&s);
////
////}
//#include <stdio.h>
//#include <stdlib.h>
//#include <string.h>
//#define maxsize 100
//#define stype int
//
//typedef struct {
//	stype *base;
//	stype *top;
//	int size;
//} data; //用结构体构造栈的数据类型
//
//int initstack(data *s) {
//	s->base = (stype *)malloc(sizeof(stype) * maxsize);
//
//	if (!s->base) {
//		exit(0);
//		return 0;
//	}
//
//	else {
//		s->top = s->base;
//		s->size = maxsize;
//	}
//}
//
//int getstack(data *s, stype *x) {
//	if (s->base == s->top)
//		return 0;
//
//	else {
//		*x = *(s->top - 1);
//		return 1;
//	}
//}
//
//int pop(data *s, stype *x) {
//	if (s->base == s->top)
//		return 0;
//
//	else {
//		*x = *--s->top;
//		return 1;
//	}
//
//}
//
//int push(data *s, stype x) {
//	if (s->top - s->base == maxsize)
//		return 0;
//
//	else {
//		*s->top++ = x;
//		return 1;
//	}
//}
//
//int main() {
//	int n, k, m, x, flag, i;
//	char ch[5];
//	data s;
//	initstack(&s);
//
//
//	while (scanf("%d", &n), n) {
//		k = 0;
//		while (k < n) {
//			scanf("%s", ch);
//
//			if (strcmp(ch, "P") == 0) {
//				scanf("%d", &m);
//				push(&s, m);
//			}
//
//			else if (strcmp(ch, "O") == 0) {
//				pop(&s, &x);
//			}
//
//			else if (strcmp(ch, "A") == 0) {
//				flag = getstack(&s, &x);
//
//				if (flag == 0)
//					printf("E\n");
//				else
//					printf("%d\n", x);
//			}
//
//			k++;
//		}
//
//		while (s.base != s.top)
//			pop(&s, &x);
//
//		putchar('\n');
//	}
//
//	return 0;
//}
//
//typedef struct Stack {
//	int *data;
//	int length;
//	int top;
//} *Stack, stack_s;
//void initStack(Stack s) {
//	S->top = -1;
//}
//void push(Stack s, int x) {
//	if (s->top + 1 >= s->length)
//		return ;
//	else
//		s->data[++s->top] = x;
//}
//void pop(Stack s) {
//	if (s->top == -1)
//		return ;
//	else
//		s->top--;
//}
//int gettop(Stack s) {
//	if (s->top == -1)
//		return ;
//	int x;
//	x = s->data[s->top];
//	return x;
//}
//int main() {
//	char c[2];
//	int n;
//	Stack s;
//	while (scanf("%d", &n) && n) {
//		getchar();
//		initStack(S);
//		s->length = n;
//		s->data = malloc...
//
//		for (int i = 0; i < n; i++) {
//			scanf("%s", c);
//			switch (c[0]) {
//					case...
//			}
//
//		}
//	}
//}//#include <stdio.h>

//Queue q;
//Queue q1;
//Queue q2;
//void manager()
//{
//	int i=0,j=0;
//	while(j<10){
//	if(!emptyQueue(q1)&&i<4)
//	{
//		deQueue(q1,x);
//		enQueue(q,x);
//		i++;
//		j++;
//	}
//	else if(i==4&&!emptyQueue(q1))
//	{
//		deQueue(q2,x);
//		enQueue(q,x);
//		j++;
//		i=0;
//	}
//	else
//	{
//		while(j<10&&i<4&&!emptyQueue(q2))
//		{
//			deQueue(q2,x);
//			enQueue(q,x);
//			j++;
//			i++;
//		}
//		i=0;
//	}
//		if(emptyQueue(&q1)&&emptyQueue(&q2))
//		{
//			break;
//		}
//   }
//}


#include <stdio.h>

#define MaxSize 11

typedef char ElemType;

typedef struct {
	ElemType data[MaxSize];
	int front, rear;
} SqQueue;

void InitQueue(SqQueue *Q);
void EnQueue(SqQueue *Q, ElemType x);
void DeQueue(SqQueue *Q, ElemType *x);
int IsEmpty(SqQueue *Q);
void Manager(SqQueue *Q, SqQueue *Qp, SqQueue *Qt);
void PrintQueue(SqQueue Q);

int main(int argc, char *argv[]) {
	SqQueue Q;
	SqQueue Qp;  // 客车队列
	SqQueue Qt;  // 货车队列

	InitQueue(&Q);
	InitQueue(&Qp);
	InitQueue(&Qt);

	ElemType x = 'P';
	for (int i = 0; i < 3; i++) {
		EnQueue(&Qp, x);
	}
	ElemType y = 'T';
	for (int i = 0; i < 6; i++) {
		EnQueue(&Qt, y);
	}

	Manager(&Q, &Qp, &Qt);

	PrintQueue(Q);

	return 0;
}

void InitQueue(SqQueue *Q) {
	Q->front = 0;
	Q->rear = 0;
}

void EnQueue(SqQueue *Q, ElemType x) {
	if (Q->rear == MaxSize - 1) {
		return;
	}
	Q->data[Q->rear++] = x;
}

void DeQueue(SqQueue *Q, ElemType *x) {
	if (Q->front == Q->rear) {
		return;
	}
	*x = Q->data[Q->front++];
}

int IsEmpty(SqQueue *Q) {
	if (Q->front == Q->rear) {
		return 1;
	} else {
		return 0;
	}
}

void Manager(SqQueue *Q, SqQueue *Qp, SqQueue *Qt) {// 客车队列Qp// 货车队列Qt
	int count = 0;
	int car = 0;
	ElemType e;

	// 渡口模拟
	while (count < MaxSize) {
		if (IsEmpty(Qp) && IsEmpty(Qt)) {
			break;
		}

		if (!IsEmpty(Qp) && car < 4) {
			DeQueue(Qp, &e);
			EnQueue(Q, e);
			car++;
			count++;
		} else if (car == 4 && !IsEmpty(Qt)) {
			DeQueue(Qt, &e);
			EnQueue(Q, e);
			count++;
			car = 0;
		} else if (IsEmpty(Qp) && !IsEmpty(Qt)) {
			while (count < MaxSize && !IsEmpty(Qt)) {
				DeQueue(Qt, &e);
				EnQueue(Q, e);
				count++;
			}
		} else {
			break;
		}
	}
}

void PrintQueue(SqQueue Q) {
	while (Q.front != Q.rear) {
		printf("%c", Q.data[Q.front++]);
	}
	printf("\n");
}