MÔN HỌC CÁC HỆ GIẢI BÀI TOÁN THÔNG MINH ĐỒ ÁN CUỐI KỲ XÂY DỰNG HỆ HỖ TRỢ HỌC TẬP LÝ THUYẾT ĐỒ THỊ
Bạn đang xem bản rút gọn của tài liệu. Xem và tải ngay bản đầy đủ của tài liệu tại đây (342.06 KB, 21 trang )
TRƯỜNG ĐẠI HỌC CÔNG NGHỆ THÔNG TIN
KHOA KHOA HỌC MÁY TÍNH
MƠN HỌC
CÁC HỆ GIẢI BÀI TỐN THƠNG MINH
ĐỒ ÁN CUỐI KỲ
XÂY DỰNG HỆ HỖ TRỢ HỌC TẬP LÝ THUYẾT ĐỒ THỊ
Lớp: CS316.G21
GVLT: Đỗ Văn Nhơn
GVTH : Nguyễn Đình Hiển
SVTH:
Huỳnh Hữu Hóa
Nguyễn Quốc Nam
Trần Minh Trí
Nguyễn Văn Tài
13520282
13520519
13520923
13520729
TP.Hồ Chí Minh, tháng 06 năm 2016
LỜI CẢM ƠN
Trong quá trình học tập và nghiên cứu mơn “Các hệ giải tốn thơng minh”, nhóm đã nhận
được sự quan tâm hướng dẫn rất tận tình của quý thầy. Thơng qua việc trình bày kết quả
nghiên cứu đồ án mơn học, nhóm chúng em xin chân thành bày tỏ lòng biết ơn đến Thầy
Đỗ Văn Nhơn và Thầy Nguyễn Đình Hiển đã tận tình hướng dẫn và giúp đỡ nhóm hồn
thành đồ án mơn học.
Bản thân chúng em rất mong sẽ tiếp tục nhận được sự quan tâm, hướng dẫn tận tình của
quý thầy.
Trân trọng cảm ơn quý thầy.
Sinh viên thực hiện
Huỳnh Hữu
Hóa
Nguyễn Quốc Nam
Trần Minh Trí
Nguyễn Văn Tài
Tài liệu tham khảo :
/>_s%C3%A2u
B
%81u_r%E1%BB%99ng
/>
NHẬN XÉT
………………………………………………………………………………………………
………………………………………………………………………………………………
………………………………………………………………………………………………
………………………………………………………………………………………………
………………………………………………………………………………………………
………………………………………………………………………………………………
………………………………………………………………………………………………
………………………………………………………………………………………………
………………………………………………………………………………………………
………………………………………………………………………………………………
………………………………………………………………………………………………
………………………………………………………………………………………………
………………………………………………………………………………………………
………………………………………………………………………………………………
………………………………………………………………………………………………
………………………………………………………………………………………………
………………………………………………………………………………………………
………………………………………………………………………………………………
………………………………………………………………………………………………
Nội dung
LỜI CẢM ƠN............................................................................................................................................2
NHẬN XÉT................................................................................................................................................3
I.
GIỚI THIỆU......................................................................................................................................5
a.
Giới thiệu chung.............................................................................................................................5
b.
Mô tả ứng dụng..............................................................................................................................5
II.
CƠ SỞ LÝ THUYẾT.....................................................................................................................6
1)
Thuật toán DFS..............................................................................................................................6
2)
Thuật toán BFS..............................................................................................................................6
3)
Thuật toán Dijkstra.......................................................................................................................7
4)
Thuật tốn Floyd...........................................................................................................................7
5)
Thuật tốn Ford-Bellman..............................................................................................................8
III.
PHÂN TÍCH VÀ THIẾT KẾ........................................................................................................9
IV.
ỨNG DỤNG VÀ ĐÁNH GIÁ KẾT QUẢ...................................................................................17
a.
Các nút chức năng.......................................................................................................................17
b.
Đánh giá kết quả..........................................................................................................................18
HỢP ĐỒNG LÀM VIỆC NHÓM...........................................................................................................19
I.
GIỚI THIỆU
a. Giới thiệu chung
Nhằm phục vụ nhu cầu học tập về lý thuyết đồ thị , tìm hiểu một cách chi tiết hơn
về quá trình thao tác trên các thuật tốn trong đồ thị như các thuật tốn DFS(tìm
kiếm theo chiều sâu) , BFS (tìm kiếm theo chiều rộng) , Dijkstra, Floyd, FordBellman , nhóm em quyết định đi xây dựng một ứng dụng hỗ trợ học tập lý thuyết
đồ thị mang tên là “Drawing”.
b. Mô tả ứng dụng
Ứng dụng “Drawing” mơ tả q trình chạy các thuật tốn DFS(tìm kiếm theo
chiều sâu) , BFS (tìm kiếm tốt nhất đầu tiên) , Dijkstra, Floyd và Ford-Bellman
một cách chi tiết lần lượt từng bước để người dùng có thể hiểu sâu hơn về lý
thuyết đồ thị.
II.
CƠ SỞ LÝ THUYẾT
1) Thuật tốn DFS
- Tìm kiếm ưu tiên chiều sâu hay tìm kiếm theo chiều sâu (tiếng Anh: Depthfirst search - DFS) là một thuật toán duyệt hoặc tìm kiếm trên một cây hoặc
một đồ thị. Thuật tốn khởi đầu tại gốc (hoặc chọn một đỉnh nào đó coi như
gốc) và phát triển xa nhất có thể theo mỗi nhánh.
- Thơng thường, DFS là một dạng tìm kiếm thơng tin khơng đầy đủ mà q trình
tìm kiếm được phát triển tới đỉnh con đầu tiên của nút đang tìm kiếm cho tới
khi gặp được đỉnh cần tìm hoặc tới một nút khơng có con. Khi đó giải thuật
quay lui về đỉnh vừa mới tìm kiếm ở bước trước. Trong dạng không đệ quy, tất
cả các đỉnh chờ được phát triển được bổ sung vào một ngăn xếp LIFO.
- Độ phức tạp thời gian của thuật toán là O(|V| + |E|).
Ý tưởng thuật toán :
- DFS trên đồ thị vô hướng cũng giống như khám phá mê cung với một cuộn chỉ
và một thùng sơn đỏ để đánh dấu, tránh bị lạc. Trong đó mỗi đỉnh s trong đồ
thị tượng trưng cho một cửa trong mê cung.
- Ta bắt đầu từ đỉnh s, buộc đầu cuộn chỉ vào s và đánh đấu đỉnh này "đã thăm".
Sau đó ta đánh dấu s là đỉnh hiện hành u.
- Bây giờ, nếu ta đi theo cạnh (u,v) bất kỳ.
- Nếu cạnh (u,v) dẫn chúng ta đến đỉnh "đã thăm" v, ta quay trở về u.
- Nếu đỉnh v là đỉnh mới, ta di chuyển đến v và lăn cuộn chỉ theo. Đánh dấu v là
"đã thăm". Đặt v thành đỉnh hiện hành và lặp lại các bước.
- Cuối cùng, ta có thể đi đến một đỉnh mà tại đó tất cả các cạnh kề với nó đều
dẫn chúng ta đến các đỉnh "đã thăm". Khi đó, ta sẽ quay lui bằng cách cuộn
ngược cuộn chỉ và quay lại cho đến khi trở lại một đỉnh kề với một cạnh còn
chưa được khám phá. Lại tiếp tục quy trình khám phá như trên.
- Khi chúng ta trở về s và khơng cịn cạnh nào kề với nó chưa bị khám phá là lúc
DFS dừng.
2) Thuật toán BFS
- Trong lý thuyết đồ thị, tìm kiếm theo chiều rộng (BFS) là một thuật tốn tìm
kiếm trong đồ thị trong đó việc tìm kiếm chỉ bao gồm 2 thao tác: (a) thăm một
đỉnh của đồ thị; (b) thêm các đỉnh kề với đỉnh vừa thăm vào danh sách có thể
thăm trong tương lai. Có thể sử dụng thuật tốn tìm kiếm theo chiều rộng cho
hai mục đích: tìm kiếm đường đi từ một đỉnh gốc cho trước tới một đỉnh đích,
và tìm kiếm đường đi từ đỉnh gốc tới tất cả các đỉnh khác. Trong đồ thị không
có trọng số, thuật tốn tìm kiếm theo chiều rộng ln tìm ra đường đi ngắn
nhất có thể. Thuật tốn BFS bắt đầu từ đỉnh gốc và lần lượt thăm các đỉnh kề
với đỉnh gốc. Sau đó, với mỗi đỉnh trong số đó, thuật tốn lại lần lượt thăm các
đỉnh kề với nó mà chưa được thăm trước đó và lặp lại. Xem thêm thuật tốn
tìm kiếm theo chiều sâu, trong đó cũng sử dụng 2 thao tác trên nhưng có trình
tự thăm các đỉnh khác với thuật tốn tìm kiếm theo chiều rộng.
- Độ phức tạp thời gian của thuật toán là O(|V| + |E|).
Ý tưởng thuật toán :
- Chèn đỉnh gốc vào hàng đợi
- Lấy ra đỉnh đầu tiên trong hàng đợi và thăm nó
- Nếu đỉnh này chính là đỉnh đích, dừng q trình tìm kiếm và trả về kết quả.
- Nếu khơng phải thì chèn tất cả các đỉnh kề với đỉnh vừa thăm nhưng chưa được
thăm trước đó vào hàng đợi.
- Nếu hàng đợi là rỗng, thì tất cả các đỉnh có thể đến được đều đã được thăm –
dừng việc tìm kiếm và trả về "khơng thấy".
- Nếu hàng đợi khơng rỗng thì quay về bước 2.
3) Thuật toán Dijkstra
- Thuật toán Dijkstra, mang tên của nhà khoa học máy tính người Hà Lan Edsger
Dijkstra vào năm 1956 và ấn bản năm 1959[1], là một thuật toán giải quyết bài
toán đường đi ngắn nhất nguồn đơn trong một đồ thị có hướng khơng có cạnh
mang trọng số âm. Thuật tốn thường được sử dụng trong định tuyến với một
chương trình con trong các thuật tốn đồ thị hay trong cơng nghệ Hệ thống
định vị tồn cầu (GPS).
Ý tưởng thuật tốn :
Ý tưởng của thuật toán được chứng minh như sau :
-
Chúng ta sẽ chỉ ra, khi một đỉnh v được bổ sung vào tập S, thì d[v] là giá trị
của đường đi ngắn nhất từ nguồn s đến v.
- Theo định nghĩa nhãn d, d[v] là giá trị của đường đi ngắn nhất trong các đường
đi từ nguồn s, qua các đỉnh trong S, rồi theo một cạnh nối trực tiếp u-v đến v.
- Giả sử tồn tại một đường đi từ s đến v có giá trị bé hơn d[v]. Như vậy trong
đường đi, tồn tại đỉnh giữa s và v không thuộc S. Chọn w là đỉnh đầu tiên như
vậy.
4) Thuật tốn Floyd
- Thuật tốn Floyd-Warshall cịn được gọi là thuật tốn Floyd được Robert
Floyd tìm ra năm 1962.thuật tốn Floyd là một thuật toán giải quyết bài
toán
đường đi ngắn nhất trong một đồ thị có hướng có cạnh mang trọng số dương
dựa trên khái niệm các Đỉnh Trung Gian.
- Bài tốn: Xét đồ thị có hướng có trọng số G=<V,E>:
Tập đỉnh: V={v1, v2, …, vn}
Ma trận khoảng cách: W = (i, j)
- Thuật toán Floyd-Warshall giúp xác định tất cả các Đường đi ngắn nhất giữa
tất cả các cặp đỉnh.
- Định lý: Thuật toán Floyd-Warshall cho ta Ma trận W* = Wn là ma trận
khoảng cách nhỏ nhất của đồ thị G.
Ý tưởng thuật toán
- Có thể hiểu 1 cách đơn giản. Để đi từ a --> b. Bạn mất 1 quãng đường là x.
- Thuật tốn sẽ tìm 1 đường đi gián tiếp từ a -- k -- b và nếu đường đi này ngắn
hơn đường đi trực tiếp thì ta gán ln giá trị nhỏ nhất của đường đi trực tiếp
bằng đường đi gián tiếp.
- Thuật toán Floyd cần O(n^3) để giải Bài toán đường đi ngắn nhất cho mỗi cặp
đỉnh
5) Thuật toán Ford-Bellman
- Thuật tốn Bellman-Ford là một thuật tốn tính các đường đi ngắn nhất nguồn
đơn trong một đồ thị có hướng có trọng số (trong đó một số cung có thể có
trọng số âm). Thuật tốn Dijkstra giải cùng bài tốn này tuy nhiên Dijkstra có
thời gian chạy nhanh hơn đơn giản là đòi hỏi trọng số của các cung phải có
giá trị khơng âm.
- Thuật tốn Bellman Ford chạy trong thời gian O(V·E), trong đó V là số đỉnh
và E là số cung của đồ thị.
Ý tưởng thuật toán
- Bước 1: Khởi tạo ∏(0,x)=0; ∏(0,i)=+∞, ∀i≠x và k=1
- Bước 2: Với mỗi i∈X ta đặt:
∏(k,i)=min({∏(k-1,i)}𝖴{∏(k-1,j)+L[j][i]})
-
Bước 3: Nếu ∏(k,i)=∏(k-1,i) với i∈X thì ∏(k,i) chính là độ dài đường đi
ngắn nhất từ x đến i. Ngược lại nếu k
Ưu điểm :
+ Từ 1 đỉnh xuất phát nhìn hình ta có thế suy ra đường đi ngắn nhất từ đỉnh đó tới
các đỉnh khác mà khơng cần làm lại từ đầu.
+ Ví dụ : Từ đỉnh 1 ta có thể tìm đường đi ngắn nhất từ 1->3 và 1->4 mà khơng
cần làm lại.
Nội dung thuật tốn
III.
PHÂN TÍCH VÀ THIẾT KẾ
Các lớp chức năng chính : DFS.cs , BFS.cs , Dijkstra.cs, Floyd.cs, FB.cs.
Lớp DFS.cs : lớp xử lý thuật toán DFS
class DFS : Algorithms
{
public DFS():base()
{
0)
}
public override void Run(int verIDStart, int verIDStartEnd =
{
List<int> listV = PhatSinhDinh(verIDStart);
Color.Blue;
Form1.getInstance().MainListVertex[verIDStart].Color =
Form1.getInstance().fInvalidate();//reset lai cua so ve
Thread.Sleep(Form1.timeSleep);//
Visited.Add(verIDStart);
if(listV.Count != 0){
foreach (int i in listV) {
int e = CheckEdgetoVertex(verIDStart, i);
Color.Blue;
if (!checkVisited(i))
{
Form1.getInstance().MainListEdge[e].Color =
Form1.getInstance().DrawMoveV(verIDStart, i);
Thread.Sleep(Form1.timeSleep);
Run(i);
Form1.getInstance().DrawMoveV(i, verIDStart);
Thread.Sleep(Form1.timeSleep);
Color.Red;
Color.Red)
}
else {
Form1.getInstance().MainListEdge[e].Color =
Form1.getInstance().fInvalidate();
Thread.Sleep(Form1.timeSleep *
20);
}
if (Form1.getInstance().MainListEdge[e].Color ==
Color.LightSlateGray;
}
}
Form1.getInstance().MainListEdge[e].Color =
}
}
Lớp BFS.cs : lớp xử lý thuật toán BFS
class BFS : Algorithms
{
public BFS() :base()
{
i++)
}
public void InitParent() {
for (int i = 0; i < Form1.getInstance().MainListVertex.Count;
{
}
Parent[i] = -1;
}
public override void Run(int verIDStart, int verIDEnd = 0)
{
int V, listTop = 0, listEnd = 0;
List<int> listV = new
List<int>();
listV.Add(verIDStart);
while (listTop <= listEnd)
{ V = listV[listTop];
listTop++;
int e = CheckEdgetoVertex(Parent[V], V);
if (!checkVisited(V))
{
if (Parent[V] != -1 && e != -1)
{
// ve canh noi 2 dinh
Form1.getInstance().MainListEdge[e].Color =
Color.Blue;
Form1.getInstance().DrawMoveV(Parent[V], V);
}
Form1.getInstance().MainListVertex[V].Color =
Color.Blue;
}
}
listV = GhepList(V,listV, PhatSinhDinh(V));
listEnd = listV.Count - 1;
Form1.getInstance().fInvalidate();
}
public List<int> GhepList(int V,List<int> l1, List<int> l2) {
for (int i = 0; i < l2.Count ; i++)
{
if (!CheckExists(l1, l2[i]))
{
l1.Add(l2[i]);
Parent[l2[i]] = V;
}
}
return l1;
}
bool CheckExists(List<int> L, int v) {
for (int i = 0; i < L.Count; i++)
{
if (v == L[i]) return true;
}
return false;
}
}
Lớp Dijkstra.cs : lớp xử lý thuật toán Dijkstra
class Dijkstra:Algorithms
{
int[] Len;
int countVertex;
public Dijkstra():base()
{
countVertex = Form1.getInstance().MainListVertex.Count;
}
void KhoiTao(int verIDStart)
{
Len = new int[countVertex];
for (int i = 0; i < countVertex; i++)
{
Len[i] =
Int16.MaxValue;
Parent[i] = verIDStart;
}
Len[verIDStart] = 0;
}
public override void Run(int verIDStart, int verIDEnd = 0)
{
KhoiTao(verIDStart);
int i = 0;
bool kt = true;
while (!checkVisited(verIDEnd))
{
for (i = 0; i < countVertex; i++)
{
if (!checkVisited(i) && Len[i] < Int16.MaxValue)
break;
}
if (i == countVertex)
{
kt = false;
break;
}
for (int j = 0; j < countVertex; j++)
{
if (!checkVisited(j) && Len[i] > Len[j])
i = j;
}
int temp;
Visited.Add(i);
for (int j = 0; j < countVertex; j++)
{
if (!checkVisited(j) && Len[i] + (temp = Matrix[i,
j] != -1 ? Matrix[i, j] : Int16.MaxValue) < Len[j])
{
Len[j] = Len[i] + Matrix[i,
j]; Parent[j] = i;
}
}
}
if (kt)
{
Stack<int> st = new Stack<int>();
int k = verIDEnd;
while (k != verIDStart)
{
st.Push(k);
k = Parent[k];
Color.Red)
}
st.Push(verIDStart);
int s = -1;
int e = -1;
while (st.Count != 0)
{
e = st.Pop();
if (Form1.getInstance().MainListVertex[e].Color !=
Form1.getInstance().MainListVertex[e].Color =
Color.Blue;//to mau dinh
Form1.getInstance().fInvalidate();
Thread.Sleep(Form1.timeSleep *
20); if (s != -1)
{
//to canh
int v = CheckEdgetoVertex(s, e);
Form1.getInstance().MainListEdge[v].Color =
Color.Blue;
//ve canh
Form1.getInstance().DrawMoveV(s,
e); Thread.Sleep(Form1.timeSleep *
20);
}
s = e;
}
Form1.getInstance().fInvalidate();
MessageBox.Show("Khoang cach tu tu " + verIDStart + ">" + verIDEnd + " = " + Len[verIDEnd].ToString());
}
else
{
MessageBox.Show("Khong co duong di tu " + verIDStart
+ "->" + verIDEnd);
}
}
}
Lớp Floyd.cs : lớp xử lý thuật toán Floyd
class Floyd : Algorithms
{
int[,] G;//ma tran lien ket
int[,] A;//ma tran coppy tu G
int[,] P;//ma tran phu luu
vet public Floyd()
: base()
{
G = Form1.getInstance().ConverMatrix();
A = new int[Form1.getInstance().MainListVertex.Count,
Form1.getInstance().MainListVertex.Count];
P = new int[Form1.getInstance().MainListVertex.Count,
Form1.getInstance().MainListVertex.Count];
}
public int Max()
{
int sum = 0;
for (int i = 0; i <
Form1.getInstance().MainListVertex.Count; i++)
{
for (int j = 0; j <
Form1.getInstance().MainListVertex.Count; j++)
{
if (G[i, j] > 0)
sum += G[i, j];
}
}
return sum;
}
public override void Run(int vStart, int vEnd)
{
for (int i = 0; i <
Form1.getInstance().MainListVertex.Count; i++)
{
for (int j = 0; j <
Form1.getInstance().MainListVertex.Count; j++)
{
if (G[i, j] > 0)
{
A[i, j] = G[i, j];
}
else
{
A[i, j] = Max();
}
P[i, j] = -1;
}
}
for (int k = 0; k <
Form1.getInstance().MainListVertex.Count; k++)
{
for (int i = 0; i <
Form1.getInstance().MainListVertex.Count; i++)
{
for (int j = 0; j <
Form1.getInstance().MainListVertex.Count; j++)
{
if (i != j && j != k && k != i && A[i, k] > 0
&& A[k, j] > 0 && A[i, j] > A[i, k] + A[k, j])
{
A[i, j] = A[i, k] + A[k, j];
P[i, j] = k;
}
}
}
}
String temp = "";
Stack<int> st = new Stack<int>();
st.Push(vEnd);
st.Push(vStart);
while (true)
{
int
i
=
st.Pop(); int j
= st.Pop(); int
k = P[i, j];
}
Color.Red)
st.Push(j);
if (k == -1)
{
st.Push(i);
break;
}
st.Push(k);
st.Push(i);
int s = 1; int e =
-1;
while (st.Count != 0)
{
e = st.Pop();
if (Form1.getInstance().MainListVertex[e].Color !=
Form1.getInstance().MainListVertex[e].Color =
Color.Blue;//to mau dinh
Form1.getInstance().fInvalidate();
Thread.Sleep(Form1.timeSleep *
20); if (s != -1)
{
//to canh
int v = CheckEdgetoVertex(s,
e); if (v != -1)
{
Form1.getInstance().MainListEdge[v].Color =
Color.Blue;
//ve canh
Form1.getInstance().DrawMoveV(s,
e); Thread.Sleep(Form1.timeSleep *
20);
}
}
s = e;
}
Form1.getInstance().fInvalidate();
if (A[vStart, vEnd] != Max())
MessageBox.Show("Khoang cach tu tu " + vStart + "->" +
vEnd + " = " + A[vStart, vEnd].ToString());
else MessageBox.Show("Khong co duong di tu " + vStart + ">" + vEnd);
Lớp FB.cs : lớp xử lý thuật toán Ford-Bellman
class FB : Algorithms
{
private int[] Truoc;
private int[] khoangcach;
public FB() {
Matrix = Form1.getInstance().ConverMatrix();
Truoc = new int[Form1.getInstance().MainListVertex.Count];
khoangcach = new
int[Form1.getInstance().MainListVertex.Count];
}
public override void Run(int verIDStart, int verIDEnd = 0)
{
for (int i = 0; i <
Form1.getInstance().MainListVertex.Count; i++)
{
if (Matrix[verIDStart, i] > 0)
khoangcach[i] = Matrix[verIDStart, i];
else khoangcach[i] =
int.MaxValue; if
(Matrix[verIDStart, i] > 0)
Truoc[i] = verIDStart;
else Truoc[i] = -1;
}
for (int i = 0; i <
Form1.getInstance().MainListVertex.Count - 2; i++)
{
for (int u = 0; u <
Form1.getInstance().MainListVertex.Count; u++)
{
for (int v = 0; v <
Form1.getInstance().MainListVertex.Count; v++)
{
if (verIDStart != u && u != v && verIDStart !=
v && Matrix[u,v]>0)
{
if (khoangcach[v] > khoangcach[u] +
Matrix[u, v])
{
Matrix[u, v]; ;
}
}
}
}
}
khoangcach[v] = khoangcach[u] +
Truoc[v] = u;
//chuyen duong di ngan nhat vao stack
Stack<int> st = new Stack<int>();
st.Push(verIDEnd);
while (true) {
int v = st.Pop();
if (v == verIDStart)
{ st.Push(v);
break;
}
if (v == -1) {
break;
}
int vTrc = Truoc[v];
st.Push(v);
st.Push(vTrc);
Color.Red)
}
int s = 1; int e =
-1;
//duyet do hoa cho duong di ngan nhat
while (st.Count != 0) {
e = st.Pop();
if (Form1.getInstance().MainListVertex[e].Color !=
Form1.getInstance().MainListVertex[e].Color =
Color.Blue;//to mau dinh
Form1.getInstance().fInvalidate();
Thread.Sleep(Form1.timeSleep *
20); if (s != -1) {
int v = CheckEdgetoVertex(s, e);
Form1.getInstance().MainListEdge[v].Color =
Color.Blue;
//ve canh
Form1.getInstance().DrawMoveV(s,
e); Thread.Sleep(Form1.timeSleep *
20);
}
s = e;
}
Form1.getInstance().fInvalidate();
if (khoangcach[verIDEnd] != int.MaxValue)
MessageBox.Show("Khoang cach tu tu " + verIDStart + ">" + verIDEnd + " = " + khoangcach[verIDEnd].ToString());
else
MessageBox.Show("khong co duong di ngan nhat tu " +
verIDStart + "->" + verIDEnd);
}
IV. ỨNG DỤNG VÀ ĐÁNH GIÁ KẾT QUẢ
a. Các nút chức năng
Chọn đỉnh bắt đầu
Chọn đỉnh kết thúc
Nút nhập thông tin đầu vào bài toán
Reset về trạng thái ban đầu
Thực hiện mô phỏng thuật DFS
Thực hiện mô phỏng thuật BFS
Thực hiện mô phỏng thuật Floyd
Thực hiện mô phỏng thuật Dijkstra
Thực hiện mô phỏng thuật Ford-Bellman
b. Đánh giá kết quả
- Ứng dụng có giao diện đơn giản , dễ sử dụng .
- Có thể cải tiến bằng cách cài đặt thêm các lớp thuật khác liên quan đến lý thuyết
đồ thị như thuật toán leo đồi , leo đồi dốc đứng , A*,….
HỢP ĐỒNG LÀM VIỆC NHĨM
Danh sách thành viên:
Huỳnh Hữu Hóa
13520282
KHMT2013
Nguyễn Quốc Nam
13520519
KHMT2013
Trần Minh Trí
13520923
KHMT2013
Nguyễn Văn Tài
13520729
KHMT2013
Mục tiêu nhóm chính mà nhóm đề ra là giúp đỡ nhau hồn thành tốt mơn học, nâng cao
kĩ năng làm việc nhóm.
Tiêu
chuẩn
đánh giá
4 - Xuất sắc
Tỷ
trọng
3 – Tơt
2 - Tạm
được
Tệ
Đóng góp
nội dụng
bài làm
40%
Chất lượng bài
làm tốt, số lượng
bài nhiều. Hướng
dẫn giúp đỡ các
bạn khác hoàn
thành phần bài
làm
Số lượng bài
nhiều, chất
lượng bài tốt.
Số lượng,
chất lượng
bài làm đảm
bảo theo sự
phân chia
của các bạn
trong nhóm
Khơng hồn
thành phần
bài làm của
mình.
Giải quyết
vấn đề và
tư duy
sáng tạo
20%
Tham gia nhiệt
tình đóng góp ý
kiến khi họp
nhóm, sáng tạo
Tham gia nhiệt
tình đóng góp
ý kiến khi họp
nhóm
Tham gia
đầy đủ các
buổi họp
nhóm, có
Ít khi đóng
góp ý kiến
cho nhóm.
trong các bài tập
khó
đóng góp ý
kiến
Sự hợp tác
và tinh
thần trách
nhiệm
20%
Hồn thành tốt
phần việc của
mình và giúp đỡ
các thành viên
khác
Hồn thành tốt Hồn thành 1
phần việc của phần phần
mình
việc của
mình,
Khơng hồn
thành cơng
việc của
mình, trễ
hạn
Tư duy
phản biện,
tơng trọng
và lắng
nghe
10%
Lắng nghe ý kiến
các thành viên và
tích cực phản
biện, góp ý
Ln lắng
nghe ý kiến
các thành viên
và có tranh
luận.
Khơng tơn
trọng, lắng
nghe ý kiến
các thành
viên trong
nhóm
Chun
cần
10%
Tham gia đầy đủ
các buổi họp
nhóm
Tham gia gần Tham gia
như đầy đủ các dưới ½ các
buổi họp nhóm buổi họp
nhóm
Lắng nghe ý
kiến các
thành viên
nhưng khơng
phản biện,
tranh luận
Khơng tham
gia hoặc ít
tham gia họp
nhóm
Cách đánh giá tính điểm cho các thành viên trong nhóm:
Các thành viên có tổng đánh giá > 15đ : đạt 100% điểm của nhóm.
Các thành viên có tổng đánh giá từ 14-15đ : đạt 80% điểm của nhóm.
Các thành viên có tổng đánh giá từ 10-13đ : đạt 70% số điểm của nhóm.
Các thành viên có tổng đánh giá từ 6 – 10đ: đạt 60% số điểm của nhóm.
Các thành viên có tổng đánh giá < 6đ : đạt 50% số điểm của nhóm.
Các qui định nhóm:
Họp nhóm mỗi tuần 1 lần vào 14h chủ nhật, nếu có vấn đề phát sinh có thể họp nhóm
nhiều hơn.
Vị trí họp nhóm tại phịng 1004 KTX khu B , có thể thay đổi, nếu có thay đổi sẽ được
thơng báo đến các thành viên.
