作业保存1

#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<time.h>
#include<windows.h>
using namespace std;
const int initial_lize=10000;
const int adding_size=2*initial_lize;
template<class T>
struct Queue{
T * base;
T * Qhead,*Qbegin,*Qend,*Qfront,*Qtail;
int front_pos,tail_pos;
int now_size,whole_size;
Queue(){
base=(T *)malloc(sizeof(T)*initial_lize);
Qhead=base;
Qbegin=base;Qend=base+(initial_lize-1);
Qfront=Qtail=base+1;
front_pos=tail_pos=1;
now_size=1;
whole_size=initial_lize;
}
bool Empty(){
if(Qfront==Qtail) return true;
else return false;
}
void push(const T x){
now_size++;
if(now_size<whole_size){
*Qtail=x;
Qtail++;
tail_pos++;
}
else{
base=(T *)realloc(base,(sizeof(T))*whole_size*2);//别忘了类型转换
whole_size*=2;
Qhead=base;Qend=base+(whole_size-1);
Qfront=base+front_pos;Qtail=base+tail_pos;
*Qtail=x;Qtail++;tail_pos++;
}
}
T Top(){
if(!Empty()) return (*Qfront);
else{
cerr<<"Queue is empty! can not return any elements"<<endl;
}
}
void pop(){
if(!Empty()){
Qfront++;
front_pos++;
}
else{
cerr<<"Queue is empty! can not pop any elements"<<endl;
}
}
void delete_Queue(){
free(base);
}
};
template<class T>
struct Stack{
T * base;
T * head,* tail;int tail_pos;
int now_size,whole_size;
Stack(){
base=(T*)malloc(sizeof(T)*initial_lize);
head=tail=base+1;tail_pos=1;
now_size=0;whole_size=initial_lize;
}
bool Empty(){
if(tail==head) return true;
else return false;
}
void push(const T x){
now_size++;
if(now_size<whole_size){
tail++;tail_pos++;
*tail=x;
}
else{
base=(T*)realloc(base,sizeof(T)*(whole_size*2));
whole_size*=2;
head=base+1;tail=base+tail_pos;
tail++;tail_pos++;*tail=x;
}
}
void pop(){
if(!Empty()) {tail--;}
else {cerr<<"the Stack is empty!can not pop any elements"<<endl;}
}
T Top(){
if(!Empty()) {return *tail;}
else {cerr<<"the Stack is empty!can not pop any elements"<<endl;}
}
void delete_Stack(){
free(base);
}
};
const int m_size=100;
int matrix[m_size][m_size],sx,sy,dx,dy,N;
bool vis[m_size][m_size];
struct node{
int x,y,step;
};
const int dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
bool check(int x,int y){
if(x<0||x>=N||y<0||y>=N) return false;
else return true;
}
void print(){
Sleep(1000);
system("CLS");
for(int i=0;i<N;i++){
for(int j=0;j<N;j++){
if(i==sx&&j==sy) printf(" S");
else if(vis[i][j]) printf(" N");
else printf(" %d",matrix[i][j]);
}
printf("\n");
}
}
int ans;
int bfs(int sx,int sy,int dx,int dy,int draw){
Queue<node> que;ans=0;
memset(vis,false,sizeof(vis));
que.push((node){sx,sy,0});
vis[sx][sy]=true;bool _find=false;
while(!que.Empty()){
node k=que.Top();
que.pop();
for(int i=0;i<4;i++){
int x=k.x+dir[i][0];
int y=k.y+dir[i][1];
int step=k.step+1;
if(check(x,y)&&!vis[x][y]&&matrix[x][y]!=0) {vis[x][y]=true;
if(x==dx&&y==dy){if(draw) print();_find=true;printf("find");ans=max(ans,step);break;}
que.push((node){x,y,step});
if(draw) print();ans=max(ans,step);
}
}
}
que.delete_Queue();
return _find;
}
bool havefind(int x,int y){
if(x==dx&&y==dy) return true;
else return false;
}
bool dvis[m_size][m_size][4];
int dfs(int sx,int sy,int dx,int dy,int draw){
memset(dvis,false,sizeof(dvis));
Stack<node> s;memset(vis,false,sizeof(vis));
s.push((node){sx,sy,0});vis[sx][sy]=true;
bool _find=false;
while(!s.Empty()){
node p=s.Top();
node k=p;
Sleep(1000);
if(k.x==dx&&k.y==dy) s.pop();
p=s.Top();
k=p;
printf("k:%d %d\n",k.x,k.y);
while(!havefind(k.x,k.y)&&check(k.x,k.y)){
Sleep(1000);
printf("k:%d %d\n",k.x,k.y);
bool havedir=false;
for(int i=0;i<4;i++){
int tx,ty;
if(!dvis[k.x][k.y][i]){
havedir=true;
tx=k.x+dir[i][0];
ty=k.y+dir[i][1];
dvis[k.x][k.y][i]=true;
if(check(tx,ty)&&!vis[tx][ty]&&matrix[tx][ty]!=0) {
vis[tx][ty]=true;
s.push((node){tx,ty,k.step+1});
print();
k=(node){tx,ty,k.step+1};break;
}
}
}
if(!havedir) break;
}
node f=s.Top();bool havedir=false;
for(int i=0;i<4;i++){
if(!dvis[f.x][f.y][i]) {havedir=true;break;}
}
if(!havedir) {
s.pop();
vis[f.x][f.y]=false;
}
}
}
bool general_matrix(int sx,int sy,int dx,int dy,int N){
for(int i=0;i<N;i++){
for(int j=0;j<N;++j){
matrix[i][j]=rand()%2;
}
}
while(!bfs(sx,sy,dx,dy,0)){
for(int i=0;i<N;i++){
for(int j=0;j<N;++j){
matrix[i][j]=rand()%2;
}
}
}
printf("成功生成迷宫\n");
}
int main(){
//队列的测试
// Queue<int> que;
// int temp=0;
// que.Top();
// que.pop();
// for(int i=0;i<10;i++){
// que.push(i);
// }
// for(int i=0;i<10;i++){
// temp=que.Top();
// que.pop();
// cout<<temp<<endl;
// }
// que.delet_Queue();
printf("输入迷宫的阶数和起点终点：");
cin>>N>>sx>>sy>>dx>>dy;
printf("输入完毕\n");
srand(time(NULL));
general_matrix(sx,sy,dx,dy,N);
dfs(sx,sy,dx,dy,1);
// bfs(sx,sy,dx,dy,1);printf(" minimum step is %d ",ans);

return 0;
}