B - 排序

B - 排序
输入一行数字，如果我们把这行数字中的‘5’都看成空格，那么就得到一行用空格分割的若干非负整数（可能有些整数以‘0’开头，这些头部的‘0’应该被忽略掉，除非这个整数就是由若干个‘0’组成的，这时这个整数就是0）。

你的任务是：对这些分割得到的整数，依从小到大的顺序排序输出。

Input
输入包含多组测试用例，每组输入数据只有一行数字（数字之间没有空格），这行数字的长度不大于1000。

输入数据保证：分割得到的非负整数不会大于100000000；输入数据不可能全由‘5’组成。
Output
对于每个测试用例，输出分割得到的整数排序的结果，相邻的两个整数之间用一个空格分开，每组输出占一行。
Sample Input
0051231232050775
Sample Output
0 77 12312320

#include"bits/stdc++.h"
typedef long long ll;
using namespace std;

int main() {
	char s[5005];
	int a[5005];
	int i,len,k,n;
	while(scanf("%s",s)!=EOF) {
		n=0;
		k=0;
		len=strlen(s);
		s[len]='5';
		i=0;
		while(s[i++]=='5');  //跳过前缀5,防止多输出0
		for(i--; i<=len; ++i) {
			if(i>0&&s[i]=='5'&&s[i-1]=='5') //忽略连续的5，防止多输出0
				continue;
			if(s[i]!='5')
				k=k*10+s[i]-'0';
			else {          //遇到5就增加一个数
				a[n++]=k;
				k=0;
			}
		}
		sort(a,a+n);
		printf("%d",a[0]);
		for(i=1; i<n; ++i)
			printf(" %d",a[i]);
		printf("\n");
	}
	return 0;
}
/*
0051231232050775
*/

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<malloc.h>
#include<conio.h>
#include<ctype.h>
#include<windows.h>
#include<time.h>

#define TURE 1
#define FLASE 0
#define ERROR 0
#define OVERFLOW -2
#define OK 1
#define INFLASEBLE -1
#define MaxSize 2510
#define Size 50
typedef int ElemType;
typedef int Status;
typedef struct {
	ElemType i;
	ElemType j;
	ElemType pre;
} LNode;
typedef struct {
	LNode data[MaxSize];
	LNode *front,*rear;
} SqQueue;
Status InitQueue(SqQueue *Q) { //建立队列，使front，rear都指向基准
	Q->front=Q->data;
	Q->rear=Q->data;
	Q->front->pre=0;
	return OK;
}
Status EnQueue(SqQueue *Q,ElemType x,ElemType y) {//坐标进队列
	Q->rear->i=x;
	Q->rear->j=y;
	Q->rear++;
	Q->rear->pre=(Q->rear-1)->pre+1;
	return OK;
}
Status QueueEmpty(SqQueue Q) { //判断队列是否为空
	if(Q.front==Q.rear) return FLASE;
	else return TURE;
}
//以上为队列
typedef struct {
	ElemType data[Size];
	ElemType *top;
} SqStack;
Status InitStack(SqStack *S) {//使top的指针指向空
	S->top=NULL;
	return OK;
}
Status Push(SqStack *S,ElemType e) {//使栈顶的元素为e
	if(S->top==NULL)
		S->top=S->data;
	else S->top++;
	*(S->top)=e;
	return OK;
}
ElemType Pop(SqStack *S,ElemType *e) { //使栈顶的元素出栈，且返回值为e
	*e=*(S->top);
	S->top--;
	return *e;
}
//以上为栈
Status PrintMigong(ElemType (*MAZE)[Size],ElemType m,ElemType n) {//打印迷宫
	ElemType i,j;
	printf("迷宫如下:\n");
	for(j=0; j<n+2; j++) {
		for(i=0; i<m+2; i++) {
			if(j==0) printf("%d ",i);
			else if(i==0) printf("%d",-j);
			else if(MAZE[i][j]==0) printf("□",MAZE[i][j]);
			else printf("■",MAZE[i][j]);
		}
		printf("\n");
	}
	return OK;
}
Status CreatMigong(ElemType (*MAZE)[Size],ElemType (*MARK)[Size],ElemType m,ElemType n) { //构造迷宫
	srand(time(NULL));
	ElemType i,j;
	for(i=0; i<m+2; i++)
		for(j=0; j<n+2; j++) {
			if(i==0||i==m+1||j==0||j==n+1) MAZE[i][j]=1;//建立围墙
			else MAZE[i][j]=rand()%2;//给迷宫的内部赋予随机数0或1
		}
	MAZE[1][1]=0,MAZE[m][n]=0;
	MARK[1][1]=1;//标记第一个点已经走
	return OK;
}
Status PrintPath(SqStack S,SqQueue Q,ElemType n) {//打印最短路径
	ElemType l,e;
	for(l=0; l<n-1; l++) {
		Pop(&S,&e);
		printf("(%-2d,%-2d) -> ",Q.data[e].i,-Q.data[e].j);
	}
	Pop(&S,&e);
	printf("(%-2d,%-2d)",Q.data[e].i,-Q.data[e].j);
	return OK;
}
Status Sloution() {//找最短路径 
	ElemType k,flag=0;
	ElemType nexti=1,nextj=1;
	SqQueue Q;
	LNode *t;
	SqStack S;
	InitQueue(&Q);
	InitStack(&S);
	ElemType Direction[8][2]= {{1,1},{0,1},{1,0},{-1,1},{1,-1},{0,-1},{-1,0},{-1,-1}};
	//用二维数组Direction存放八个方向上的位置偏移量
	ElemType m,n;
	do{
		printf("请输入迷宫的行和列:");
	scanf("%d%d",&m,&n);//输入迷宫的行和列
	}while(m<1&&n<1||m>=50||n>=50);
	ElemType MAZE[Size][Size]= {0}; //建立一个数组用于容纳迷宫
	ElemType MARK[Size][Size]= {0}; //建立一个标记是否走过的数组
	CreatMigong(MAZE,MARK,m,n);
	PrintMigong(MAZE,m,n);
	EnQueue(&Q,1,1);
	while(QueueEmpty(Q)) {
		for(k=0; k<8; k++) {//判断八个方向是否有可以走的，有就压进队列
			nexti=Q.rear->i+Direction[k][0],nextj=Q.rear->j+Direction[k][1];
			if(MAZE[nexti][nextj]||MARK[nexti][nextj]);
			else {
				MARK[nexti][nextj]=1;
				EnQueue(&Q,nexti,nextj);
				//printf("%d ",Q.rear->pre);
				if(nexti==m&&nextj==n) { //一旦发现了出口，就退出循环
					flag=1;
					break;
				}
			}
		}
		if(flag==1) {//如果找到出口就压进栈中
			t=Q.rear;
			t--;
			while(t->pre) {
				//printf("%d ",t->pre);
				Push(&S,t->pre);
				t--;
			}
			break;
		}
	}
	printf("走出迷宫最短路经如下:\n");
	if(QueueEmpty(Q)) {//如果不是因为队列退出循环的，就把栈中的元素输出
		PrintPath(S,Q,(Q.rear-1)->pre);
	} else printf("No path!\n");
	return OK;
}
int main() {
	while(1) {
		Sloution();
	}
	return 0;
}