Xây dựng thuật toán tìm được lối ra đi từ cửa vào để đến lối ra trong mê cung

Trang
MỤC LỤC
Nhận xét của giáo viên..........................................................................................1
Mẫu chấm niên luận..............................................................................................2
Mục lục..................................................................................................................3
I. GIỚI THIỆU......................................................................................................4
1. Lời mở đầu........................................................................................................4
2. Đặc tả đề tài.......................................................................................................4
II. GIẢI QUYẾT VẤN ĐỀ...................................................................................4
1- Tạo dữ liệu nguồn.............................................................................................4
2- Nhập..................................................................................................................5
3- Thuật toán tìm kiếm theo chiều sâu (dfs)..........................................................6
4- int ok.................................................................................................................7
5- void chuan bi.....................................................................................................8
6- void tim.............................................................................................................9
7- void xuly.........................................................................................................10
8- void xuat..........................................................................................................11
9- void main.........................................................................................................12
III. KẾT LUẬN – ĐÁNH GIÁ...........................................................................13
1- Ưu điểm..........................................................................................................13
2- Nhược điểm.....................................................................................................13
3- Hướng phát triển.............................................................................................13
IV. PHỤ LỤC......................................................................................................13
1- Hướng dẫn chạy demo....................................................................................13
2- Tài liệu tham khảo...........................................................................................15
Trang
I. GIỚI THIỆU
1- Lời mở đầu
Trong cuộc sống có nhiều vấn đề bộc ta phải lựa chọn hoặc tìm ra những
phương án để giải quyết được vấn đề. Trong toán học cũng thế để giải một bài
toán đòi hỏi ta phải chọn được phương án giải được bài toán một cách tối ưu để

thu được kết quả mong muốn. Trong lập trình cũng thế ta phải tìm ra được giải
thuật đúng để làm nền tảng xây dựng chương trình chạy đúng kết quả bài toán hay
đề tài của người yêu cầu đặt ra. Chẳng hạn như bài toán mê cung, đòi hỏi ta phải
xây dựng thuật toán tìm được lối đi từ cửa vào để đến được lối ra. Trong khi đó,
có thể đứng trước nhiều ngã rẽ và phải tìm được lối đi cho đến khi thoát khỏi mê
cung.
2- Đặc tả đề tài
a- Yêu cầu
- Chương trình phải đọc mê cung từ ma trận kề trên tập tin văn bản.
- Nhập cửa vào, cửa ra.
b- Mục tiêu đạt được
- Tìm được đường đi đến cửa ra.
c- Môi trường làm việc.
- Ngôn ngữ lập trình C.
II. GIẢI QUYẾT VẤN ĐỀ
Tinh thần giải thuật:
Khởi tạo lối đi đầu tiên tại cửa vào, sau đó dùng thuật toán dfs (duyệt
theo chiều sâu ) để tìm lối đi. Trong khi tìm lối đi, lối đi có thể đi được nếu không
phải là tường ( giá trị 0 trong ma trận kề ). Ngược lại là tường buộc phải quay lui.
Trong lúc đi, tại những điểm đi qua đều được đánh dấu. Khi khhong thể đi được
nên phải quay lui tại điểm vừa đi qua và cứ như thế cho đến khi đi đến cửa ra.
Chương trình được viết như sau:
#include<stdlib.h>
#include<stdio.h>
#define inp "inp.txt"
#define out "out.txt"
int inx,iny,outx,outy;
int x[2500],y[2500],a[50][50],c[50][50],
dx[5]={0,0,1,0,-1},
dy[5]={0,-1,0,1,0};

int m,n,i,j,d,s;
FILE *f;
void nhap()
{
f=fopen(inp,"r");
fscanf(f,"%d %d",&m,&n);
Trang
fscanf(f,"%d %d %d %d",&inx,&iny,&outx,&outy);
for (i=0;i<m;++i)
for (j=0;j<n;++j) fscanf(f,"%d",&a[i][j]);
fclose(f);
}
int ok(int i,int j)
{
if ((i<0)||(i>=m)||(j<0)||(j>=n)) return 0;
if ((a[i][j]!=0)||(c[i][j]!=0)) return 0;
return 1;
}
void dfs(int i,int j)
{
if ((i==outx-1)&&(j==outy-1)) d=1;
else
{
int k;
for (k=1;k<=4;++k)
if (ok(i+dx[k],j+dy[k]))
{
c[i+dx[k]][j+dy[k]]=k;
dfs(i+dx[k],j+dy[k]);
}

}
}
void chuanbi()
{
for (i=0;i<m;++i)
for (j=0;j<n;++j) c[i][j]=0;
c[0][0]=-1;
d=0;
}
void tim()
{
s=0;
x[0]=outx-1;
y[0]=outy-1;
i=outx-1;
j=outy-1;
Trang
int k;
while (c[i][j]!=-1)
{
k=c[i][j];
i=i-dx[k];
j=j-dy[k];
s++;
x[s]=i;
y[s]=j;
}
}
void xuly()
{

chuanbi();
dfs(inx-1,iny-1);
if (d==1) tim();
}
void xuat()
{
FILE *f;
f=fopen(out,"w");
if (d != 1)fprintf(f,"Noresult");
if (d==1)
{
/*for (i=0;i<m;++i)
{
for (j=0;j<n;++j)
if (c[i][j]!=0) fprintf(f,"1 ");else fprintf(f,"0 ");
fprintf(f,"\n");
}*/
fprintf(f,"%d\n",s);
for (i=s;i>=0;i--) fprintf(f,"%4d%4d\n",x[i],y[i]);
// for (i=s;i>=0;i--) fprintf(f,"%d\n",y[i]);
}
fclose(f);
}
int main()
{
nhap();
xuly();
Trang
xuat();
return 0;

}
Tác dụng từng chương trình con được diễn giải như sau:
1- Tạo dữ liệu nguồn.
Tạo dữ liệu nguồn là ma trận kề được viết trên tập tin văn bản là file “inp.txt”
để tạo thành mê cung trong đó 0 là lối đi được và 1 là tường nên không đi được và
buộc phải quay lui. Và thiết lập lối ra để thoát khỏi mê cung với file “out.txt”
Trong đó lệnh FILE *f dùng để gọi tập tin văn bản vào chương trình:
- Gán f = fopen (inp,”r”).
- Inp là đường dẫn đến tập tin ta cần gọi ( ví dụ: (“f:\inp.txt”,”r”)).
- fclose ( f ) là lệnh đóng tập tin vừa gọi.
Trang
Inp.txt
10 10
1 1 10 10
0 0 0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1 0 1
1 0 0 0 0 0 0 0 0 1
1 0 1 1 1 1 1 1 0 1
1 0 0 0 0 0 1 0 1 1
1 1 1 0 1 0 1 0 1 1
1 0 0 0 0 0 1 0 0 1
1 0 1 1 1 1 1 1 0 1
0 0 0 0 0 0 0 0 1 0
0 1 1 1 1 1 1 0 0 0
Out.txt
36
0 0 2 4 8 2
0 1 2 3 8 3
0 2 2 2 8 4
0 3 2 1 8 5

0 4 3 1 8 6
0 5 4 1 8 7
0 6 4 2 9 7
0 7 4 3 9 8
0 8 5 3 9 9
1 8 6 3
2 8 6 2
2 7 6 1
2 6 7 1
2 5 8 1
2- Nhập
Sau khi đọc ma trận kề và chuyển từ ma trận kề sang mê cung được minh họa
bởi đoạn code và sơ đồ khối sau:
void nhap()
{
f=fopen(inp,"r");
fscanf(f,"%d %d",&m,&n);
fscanf(f,"%d %d %d %d",&inx,&iny,&outx,&outy);
for (i=0;i<m;++i)
for (j=0;j<n;++j) fscanf(f,"%d",&a[i][j]);
fclose(f);
}

Trang
f = fopen (inp,”r”)
i<001
end
j<01
i ++
a[i][j]

j ++
Begin