TỔNG HỢP KIẾN THỨC TRÍ TUỆ NHÂN TẠO (AI)

Các b ước c ơb ản c ủa gi ải thu ật di truy ền
Một giải thuật di truyền đơn giản bao gồm các bước sau:
Bước 1: Khởi tạo một quần thể ban đầu gồm các chuỗi nhiễm sắc thể.
Bước 2: Xác định giá trị mục tiêu cho từng nhiễm sắc thể tương ứng.
Bước 3: Tạo các nhiễm sắc thể mới dựa trên các toán tử di truyền.
Bước 5: Xác định hàm mục tiêu cho các nhiễm sắc thể mới và đưa vào quần thể. Bước 4: Loại bớt
các nhiễm sắc thể có độ thích nghi thấp.
Bước 6: Kiểm tra thỏa mãn điều kiện dừng. Nếu điều kiện đúng, lấy ra nhiễm sắc thể tốt nhất, giải
thuật dừng lại; ngược lại, quay về bước 3.
Có hai loại điều kiện dừng cơ bản. Các điều kiện này dùng các đặc trưng tìm kiếm để quyết định
ngừng quá trình tìm kiếm .
Dựa trên cấu trúc nhiễm sắc thể: do sự hội tụ của quần thể bằng cách kiểm soát số alen được hội
tụ, ở đây alen được coi như hội tụ nếu một số phần trăm quần thể đã định trước có cùng (hoặc
tương đương đối với các biểu diễn không nhị phân) giá trị trong alen này. Nếu số alen hội tụ vượt
quá số phần trăm nào đó của tổng số alen, việc tìm kiếm sẽ kết thúc.
Dựa trên ý nghĩa đặc biệt của một nhiễm sắc thể: đo tiến bộ của giải thuật trong một số thế hệ cho
trước. Nếu tiến bộ này nhỏ hơn một hằng số ε xác định, kết thúc tìm kiếm
Thuật toán Havard (1970)
Bước 1: Phát biểu lại giả thiết (GT) và kết luận của bài toán dưới dạng chuẩn sau: GT 1,GT2,…,
GTn → KL1,KL2,…, KLm
Trong đó các GTi, KLj được xây dựng từ các biến mệnh đề và các phép nối ∧ ,∨,˥,
Bước 2: Bước bỏ phủ định (nếu cần). Khi cần bỏ các các phủ định: chuyển vế GTi sang vế kết luận
KLj và ngược lại (giống như chuyển dấu âm trong đai số từ vế phai sang trái và ngược lại)
Bước 3: Thay dấu “∧” ở GTi và “∨” ở KLj bằng các dấu “,”
Bước 4: Nếu GTi còn dấu “∨” và KLj còn dấu “∧” thì tách chúng thành hai dòng con
Bước 5: Một dòng được chứng minh nêu tồn tại chung một mệnh đề ở cả hai vế
Bước 6: Bài toán được chứng minh khi và chi khi tất cả các dòng được chứng minh. Ngược lại thì
bài toán không được chứng minh

Bài 1: Tính chi phí hành trình tốt nhất (tiết kiệm nhất): (Thuật toán GTS 2- Greedy)

Sắp xếp hội thảo (Thuật toán tô màu)


Tô màu đồ thị

Bài toán đèn giao thông (Thuật toán tô màu)
Hãy xây dựng các cột đèn sao cho việc lưu thông không bị giao nhau (số màu đèn là bao nhiêu).


Áp dụng giải thuật AKT vào bài toán tháp Hà Nội

public void heuristic()
{
this.valueH = this.disks[2].length;
for (int i = 0; i < this.disks[2].length; i++)
{
if (this.disks[2][i].getDiskId() == i + 1)
{
this.valueH--;
}
}
}
public void resolve()
{
Snapshot originalSnapshot = new Snapshot(this.diskCount);
this.lstOpenedSnapshots.add(originalSnapshot);

while (this.lstOpenedSnapshots.size() > 0)
{
Snapshot processingSnapshot = this.lstOpenedSnapshots.get(0);
this.lstSteps.add(processingSnapshot);
this.lstOpenedSnapshots.remove(0);
if (processingSnapshot.getValueH() == 0)
{
break;
}
List<Snapshot> lstGeneratedSnapshots = new
ArrayList<Snapshot>();
processingSnapshot.getAllGeneratedSnapshot(lstGeneratedSnapshots);
for (Snapshot snap : lstGeneratedSnapshots)
{
if (!this.isValidSnapshot(snap))
{
continue;
}
int i = 0;
while (i < this.lstOpenedSnapshots.size()
&& snap.getvalueF() >
this.lstOpenedSnapshots.get(i).getvalueF())
{
i++;
}
this.lstOpenedSnapshots.add(i, snap);
}
}

}

Thuật toán Minimax (AI trong Game

)

function findBestMove(board):
bestMove = NULL
for each move in board :
if current move is better than bestMove
bestMove = current move
return bestMove
function minimax(board, isMaximizingPlayer):
if(CheckStateGame(curMove) == WIN_GAME)
return MAX
if(CheckStateGame(curMove) == LOSE_GAME)
return MIN
if( CheckStateGame(curMove) == DRAW_GAME)
return DRAW_VALUE
if isMaximizingPlayer :
bestVal = -INFINITY
for each move in board :
value = minimax(board, false)
bestVal = max( bestVal, value)
return bestVal
else :
bestVal = +INFINITY
for each move in board :
value = minimax(board, true)
bestVal = min( bestVal, value)

return bestVal
function minimax(board, depth,isMaximizingPlayer):
if(CheckStateGame(curMove) == WIN_GAME)
return MAX - depth
if(CheckStateGame(curMove) == LOSE_GAME)
return MIN + depth
if( CheckStateGame(curMove) == DRAW_GAME)
return DRAW_VALUE
if isMaximizingPlayer :
bestVal = -INFINITY
for each move in board :
value = minimax(board, depth +1, false)
bestVal = max( bestVal, value)
return bestVal
else :
bestVal = +INFINITY
for each move in board :


value = minimax(board, depth + 1,true)
bestVal = min( bestVal, value)
return bestVal

Thuật toán loang ứng dụng trong game
dò mìn
//Mở một ô trống
void open_empty_pos(int row, int col) {
int i, j;
opened[row][col] = 1; // Đánh dấu ô đang xét đã được mở
if (p[row][col] == EMPTY) { // Nếu ô đang xét trống và có mật độ bằng 0

// Xét các ô xung quanh
for (i = -1; i < 2; i++) {
for (j = -1; j < 2; j++) {
if (i!=0 || j!=0) {
if (row + i >= 0 && row + i <= maxrow && col + j
>=0 && col + j <= maxcol) { // Nếu ô nằm trong bàn
if (!opened[row + i][col + j])
// Nếu ô chưa được mở
open_empty_pos(row + i, col +
j);
}
}
}
}
}
}

Đề tài: Bài toán Đong nước môn Trí Tuệ Nhân Tạo

#include <iostream>
#include <conio.h>
using namespace std;
int ucln(int, int);
int x, y;
int vx, vy;
int z;
int luat1();
int luat2();
int luat3();
int main()

{
cout << "Bai Toan Dong Nuoc" << endl;
cout << "Nhap dung tich binh X: ";


cin >> vx;
cout << "Nhap dung tich binh Y: ";
cin >> vy;
cout << "Nhap dung tich can dong: z = ";
cin >> z;
if (z % ucln(vx, vy) != 0)
{ cout << "Khong the dong duoc theo yeu cau!" << endl;
}
else
{
x = 0;
y = 0;
while (x != z && y != z)
{
luat1();
luat2();
luat3();
}
}
getch();
return 0;
}
int ucln(int a, int b)
{
if (a <= 0 || b <= 0)

return 1;
while (a % b != 0 && b % a != 0)
{
if (a > b)
a = a % b;
else
b = b % a;
}
return a > b ? b : a;
}
int luat1()
{
if (x == vx)
{
x = 0;
cout << "Luat L1 -> x = " << x << ", y = " << y << endl;
return 1;
}
return 0;
}
int luat2()
{
if (y == 0)


{
y = vy;
cout << "Luat L2 -> x = " << x << ", y = " << y << endl;
return 1;

}
return 0;

}
int luat3()
{
if (x < vx && y > 0)
{
if (y > vx - x)
{
y -= vx - x;
x = vx;
}
else
{
x += y;
y = 0;
}
cout << "Luat L3 -> x = " << x << ", y = " << y << endl;
return 1;
}
return 0;
}

H ướng gi ải quy ết bài toán tô màu đồ thị
int bac(int m,int n,int a[7][7])
{
int i,j,bac;
for(i=1;i<=n;i++)
{

bac=0;
for(j=1;j<=m;j++)
{
if(a[i][j]==1)
{
bac=bac+1;
}
}
return bac;
}
}
Mạng nơ-ron nhân tạo hay thường gọi ngắn gọn là mạng nơ-ron là một mô hình toán học hay mô hình tính toán
được xây dựng dựa trên các mạng nơ-ron sinh học. Nó gồm có một nhóm các nơ-ron nhân tạo (nút) nối với nhau, và
xử lý thông tin bằng cách truyền theo các kết nối và tính giá trị mới tại các nút (cách tiếp cận connectionism đối vớ i
tính toán). Trong nhiều trường hợp, mạng nơ-ron nhân tạo là một hệ thống thích ứng (adaptive system) tự thay đổi
cấu trúc của mình dựa trên các thông tin bên ngoài hay bên trong chảy qua mạng trong quá trình học. Trong thự c tế


sử dụng, nhiều mạng nơ-ron là các công cụ mô hình hóa dữ liệu thống kê phi tuyến. Chúng có thể được dùng để mô
hình hóa các mối quan hệ phức tạp giữa dữ liệu vào và kết quả hoặc để tìm kiếm các dạng/mẫu trong dữ liệu.





Áp dụng tìm kiếm Heuristic vào bài toán Mã Đi Tuần
private int BestNextStep(OneSquare qO) {
int avaiPos[];
avaiPos = qO.GetAvailablePositions();
int k = 8;

int idx = -1;
int e = 0;
for (int i = 0; i < avaiPos.length; i++) {
if (this.sq[avaiPos[i]].visited)
continue;
e = NumOfOmitedSquare(this.sq[avaiPos[i]], avaiPos[i]);
if ((e > 0) && (e < k)) {
k = e;
idx = i;
}
}
if (idx == -1)
return idx;
else
return avaiPos[idx];
}
int[] FindTheWay(int startSquare) {
int i = 0;
int path[];
path = new int[64];
for (i = 0; i < 64; i++){
sq[i].visited = false;
}
sq[startSquare - 1].visited = true;
int nxt[];
int n = -1;
int moves = 0;


int currentSquare = startSquare - 1;

path[currentSquare] = moves + 1;
// Tìm đường đi theo thứ tự 1,2,... lưu vào mảng path[]
for (i = 0; i < 64; i++) {
n = BestNextStep(sq[currentSquare]);
if (n < 0)
break;
sq[n].visited = true;
moves++;
currentSquare = n;
path[currentSquare] = moves + 1;
}
// Tìm đến những ô chưa được đi đến (unvisited)
int nUnvisited = 0;
int unvisited = -1;
for (i = 0; i < 64; i++) {
if (!sq[i].visited) {
unvisited = i;
nUnvisited++;
}
}
if (nUnvisited == 1) {
nxt = sq[currentSquare].GetAvailablePositions();
for (i = 0; i < nxt.length; i++) {
if (nxt[i] == unvisited) {
path[unvisited] = moves + 2;
break;
}
}
} else {
return null;

}
return path;
}

bài toán TACI = giải thuật Akt
#include <stdio.h> #include<conio.h> #include<math.h> int a[3][3]={ {2,8,3},{1,6,4},{7,0,5} }; int A[3]
[3]={ {1,2,3},{8,0,4},{7,6,5} }; int b[3][3]={ {2,8,3},{1,6,4},{7,0,5} }; int I,J,I1,J1,g=0,h; void xuly(); int
ketthuc(); int tinh(); int tim(int ); void timdinhtrong(); void swap(int & , int &); void xetchon(); void
chep1(); void chep2(); void main() {// clrscr(); xuly(); printf("\n So buoc lap la : %d",g); getch(); } void
xuly(){ while(!ketthuc()) { g++; xetchon(); printf("%d \n",h); for(int i=0; i<3; i++) { for(int j=0; j<3; j++)
printf("%d ",a[i][j]);printf("\n"); } getch(); } } int ketthuc() { for(int i=0;i<3;i++) for(int j=0;j<3;j++) if (a[i][j]!
=A[i][j]) return 0; return 1; } int tinh() { int bac=0; for(int i=0;i<3;i++) for(int j=0;j<3;j++) { if(tim(b[i][j]))
bac+=abs(I1-i)+abs(J1-j); } return bac; } int tim(int x) { for(int i=0;i<3;i++) for(int j=0;j<3;j++) if (A[i]
[j]==x && x!=0 ) { I1=i; J1=j; return 1; } return 0; } void timdinhtrong() { for(int i=0;i<3;i++) for(int
j=0;j<3;j++) if (a[i][j]==0) { I=i;J=j; } } void swap( int &x , int &y) { int temp; temp=x; x=y; y=temp; } void
xetchon() { int min=100; timdinhtrong(); for(int j=0;j<3;j++) for(int l=0;l<3;l++) { if ((abs(I-j)+(abs(Jl))==1)) { swap(b[j][l],b[I][J]); h=tinh(); if( hh=min; } void chep1() { for(int i=0;i<3;i++) for(int j=0;j<3;j++) b[i][j]=a[i][j]; } void chep2() { for(int
i=0;i<3;i++) for(int j=0;j<3;j++) a[i][j]=b[i][j]; }