TRÒ CHƠI Đ͐I KHÁNG VÀ CÁC PHƯƠNG PHÁP TÌM KIɻM

p





Trong phɤn này, ta sɺ xem cách m͙t chương trình máy tính có thʀ chơi đưͣc các trò chơi
đɢu trí như các trò chơi c͝ Vua, c͝ Tư͛ng, c͝ vây, c͝ caro (go-moku), go, checker... như thɼ
nào. Các trò này còn g͍i là các trò chơi đ͑i kháng, diʂn ra giͯa hai đɢu thͧ. Nói chung, các
trò chơi đó đɾu có thʀ chuyʀn vɾ m͙t dɞng bài toán tìm kiɼm đɴc biʄt: tìm đư͝ng đi đɼn các
điʀm cao nhɢt giͯa hai đɢu thͧ. Đɴc điʀm cͧa các trò chơi trên như sau:

* Có hai đɢu thͧ, m͗i ngư͝i chʆ đi m͙t nư͛c khi t͛i lưͣt.
* Các đɢu thͧ đɾu biɼt m͍i thông tin vɾ tình trɞng trɪn đɢu.
* Trɪn đɢu không kéo dài vô tɪn, phɠi diʂn ra hòa, hoɴc m͙t bên thɬng và bên kia thua.

Thông thư͝ng ta hay g͍i các trò chơi này là các loɞi c͝. Đôi khi ta g͍i đây là các trò chơi
Minimax (dͱa trên tên cͧa thuɪt toán tìm kiɼm cơ bɠn áp dͥng cho chúng). Hình 1.1 là ví
dͥ vɾ m͙t s͑ trò chơi nói trên. Các trò chơi như chơi bài, dò mìn, xúc sɬc... không thu͙c l͛p
trò chơi này.
pp




Các trɞng thái bàn c͝ khác nhau (hay còn g͍i là m͙t thɼ c͝, tình hu͑ng c͝) trong quá trình
chơi có thʀ biʀu diʂn thành m͙t cây tìm kiɼm (đưͣc g͍i là cây trò chơi - hình 1.2) và ta sɺ
tiɼn hành tìm kiɼm trên cây đʀ tìm đưͣc nư͛c đi t͑t nhɢt. Cây trò chơi có các nút cͧa cây là
các tình hu͑ng khác nhau cͧa bàn c͝, các nhánh n͑i giͯa các nút sɺ cho biɼt tͫ m͙t tình
hu͑ng bàn c͝ chuyʀn sang tình hu͑ng khác thông qua chʆ m͙t nư͛c đi đơn nào đó. Dĩ nhiên,
các nư͛c đi này diʂn ra theo cɴp do hai đɢu thͧ lɤn lưͣt tiɼn hành. Đ͙ sâu cͧa cây trò chơi
 là s͑ tɤng cͧa cây (chính là đ͙ sâu d cͧa cây). Thuɪt ngͯ ³nư͛c đi´ trong sách đưͣc
th͑ng nhɢt chʆ bao g͓m m͙t lɤn đi cͧa m͙t đɢu thͧ hoɴc m͙t lɤn đi phɠn ͩng lɞi cͧa đ͑i
thͧ bên kia. Chú ý nó khác v͛i thói quen dùng trong thͱc tɼ m͙t nư͛c đi bao g͓m lɤn đi cͧa
ta và m͙t lɤn đi cͧa đ͑i thͧ. Nói cách khác, nư͛c đi ͟ đây thͱc chɢt chʆ là "nͭa nư͛c" theo
cách hiʀu cͧa làng c͝.

ppp


Dùng m͙t thuɪt toán vét cɞn đʀ tìm kiɼm trên cây trò chơi dư͝ng như là m͙t ý tư͟ng đơn
giɠn. Ta chʆ cɤn ch͍n nhánh cây sɺ dɨn t͛i nư͛c thɬng đʀ đi quân là đɠm bɠo thɬng lͣi. Nɼu
đúng vɪy, các loɞi c͝ sɺ tr͟ thành các trò chơi bu͓n tɸ, sɺ chɰng còn đâu nhͯng bí quyɼt
huyɾn ɠo thɤn kì và bàn c͝ sɺ chɰng khác gì bàn... tính. Rɢt tiɼc (hoɴc rɢt may) rɮng, cách
làm này lɞi không thʀ thͱc hiʄn n͕i do cái g͍i là bùng n͕ t͕ hͣp. Ví dͥ, nɼu tͫ m͙t thɼ c͝,
trung bình có khɠ năng đi đưͣc 16 nư͛c đi khác nhau (ta g͍i đó là hʄ s͑ nhánh con tɞi m͗i
nút là b = 16). Như vɪy, sau m͙t tɤng ta sɺ có 16 nút con, m͗i nút này lɞi có thʀ có 16 con
nͯa. T͕ng s͑ nút con ͟ đ͙ sâu thͩ hai là 16x16 = b^2. Cͩ như vɪy ͟ đ͙ sâu d sɺ có b^d
nút.

Nɼu giɠ sͭ đ͙ sâu cͧa cây là 100 (hʄ s͑ nhánh 16 và đ͙ sâu 100 đɾu là nhͯng con s͑ còn
nh͏ hơn con s͑ thư͝ng gɴp trong trò chơi c͝), thì s͑ nhánh phɠi duyʄt lên đɼn 16^100 hay
xɢp xʆ 10^120 - m͙t con s͑ l͛n khͧng khiɼp. Đʀ hình dung s͑ đó l͛n thɼ nào, ta giɠ sͭ tɢt
cɠ các nguyên tͭ trong vũ trͥ đɾu tr͟ thành máy tính đʀ tính nư͛c đi v͛i t͑c đ͙ m͙t giây
tính đưͣc c͡ 10^10 (10 tͷ) nư͛c đi, và nɼu chúng hoɞt đ͙ng cɪt lͱc tͫ th͝i vͥ n͕ l͛n đɼn
nay (theo m͙t s͑ lý thuyɼt, thì thɼ gi͛i này hình thành sau m͙t vͥ n͕ g͍i là vͥ n͕ l͛n
bigbang, trư͛c đây c͡ 15 tͷ năm) thì đɼn bây gi͝ m͛i có thʀ đi đưͣc nư͛c đi đɤu tiên.
Vì s͑ các khɠ năng tăng quá nhanh, chʆ có m͙t s͑ ít nhͯng vɢn đɾ đơn giɠn là thích hͣp v͛i
kiʀu tìm kiɼm vét hɼt m͍i khɠ năng này (kiʀu tìm kiɼm vét cɞn đòi h͏i phɠi kiʀm tra tɢt cɠ
các đʆnh). Do đó, các phương pháp tìm kiɼm khác đã ra đ͝i và phát triʀn. Ngưͣc lɞi, nɼu có
m͙t phương pháp luôn luôn chính xác nhɮm đánh giá m͙t thɼ c͝ này là t͑t hay kém so v͛i
thɼ kia, thì trò chơi tr͟ thành đơn giɠn bɮng cách ch͍n nư͛c đi dɨn t͛i thɼ c͝ t͑t nhɢt. Do
đó sɺ không cɤn phɠi tìm kiɼm gì nͯa. Rɢt tiɼc, các thͧ tͥc như vɪy không hɾ có. Ta cɤn có
chiɼn lưͣc tìm kiɼm trong trò chơi.

IV. Chiɼn lưͣc tìm kiɼm trong trò chơi

M͙t chiɼn lưͣc thư͝ng đưͣc cɠ ngư͝i lɨn máy dùng là phân tích thɼ c͝ chʆ sau m͙t s͑ nư͛c
đi nào đó cͧa cɠ hai bên. Sau khi "nhìn xa" xem bàn c͝ có nhͯng khɠ năng biɼn đ͕i như thɼ
nào sau m͙t s͑ nư͛c, ta sɺ đánh giá đ͙ xɢu t͑t cͧa các thɼ c͝ nhɪn đưͣc. Tiɼp theo, ta sɺ
ch͍n nư͛c đi sɺ dɨn t͛i m͙t thɼ c͝ t͑t nhɢt trong s͑ đó có cân nhɬc đɼn cách đi cͧa cɠ hai
bên. V͛i máy, thɼ c͝ này đưͣc đánh giá là t͑t hơn thɼ c͝ kia nh͝ so sánh điʀm cͧa thɼ đó
do b͙ lưͣng giá trɠ lɞi. Chúng ta chʆ có khɠ năng xét trư͛c m͙t s͑ hͯu hɞn các nư͛c (ví dͥ
đɞi kiʄn tư͛ng chơi c͝ vua có thʀ xét trư͛c 8-10 nư͛c đi, ngư͝i thư͝ng chʆ 2-4 nư͛c đi). Rõ
ràng là nɼu xét càng sâu thì chơi càng gi͏i. Nhưng không thʀ thͱc hiʄn điɾu này v͛i đ͙ sâu
quá l͛n đưͣc do s͑ nút ͟ đ͙ sâu đó có thʀ tr͟ nên l͛n khͧng khiɼp và không đͧ th͝i gian đʀ
phân tích. Nɼu dͫng ͟ m͙t đ͙ sâu hͣp lý thì b͙ phân tích có thʀ hoàn thành viʄc tính toán
trong m͙t th͝i gian hɞn đʈnh.






Giɠ sͭ chúng ta có m͙t b͙ phân tích thɼ c͝ có thʀ áp dͥng tɢt cɠ các luɪt, các phương pháp
đánh c͝ khác nhau vào tͫng thɼ c͝ và chuyʀn đ͕i chúng thành m͙t con s͑ đɞi diʄn (cho
điʀm thɼ c͝). Mɴt khác, ta giɠ sͭ con s͑ đó là dương khi áp dͥng cho thɼ c͝ cͧa m͙t đɢu
thͧ (đưͣc g͍i là ngư͝i chơi cͱc đɞi - maximizer), và là âm khi áp dͥng cho đɢu thͧ bên kia
(đưͣc g͍i là ngư͝i chơi cͱc tiʀu - minimizer). Quá trình tính toán cho điʀm thɼ c͝ đưͣc g͍i
là lưͣng giá tĩnh (static evaluation). Hàm thͱc hiʄn viʄc tính toán đưͣc g͍i là m͙t b͙ lưͣng
giá tĩnh, và giá trʈ nhɪn đưͣc g͍i là điʀm lưͣng giá tĩnh. Cɠ hai đɢu thͧ đɾu c͑ gɬng đi như
thɼ nào đó đʀ đɞt đưͣc điʀm tuyʄt đ͑i l͛n nhɢt. Ngư͝i chơi cͱc đɞi sɺ tìm nhͯng nư͛c đi
dɨn đɼn điʀm cͧa mình tr͟ nên l͛n hơn (hay cao nhɢt có thʀ đưͣc) hay điʀm cͧa đ͑i thͧ
b͛t âm hơn (nh͏ hơn vɾ giá trʈ tuyʄt đ͑i). Còn đɢu thͧ cͧa anh ta, ngư͝i chơi cͱc tiʀu, lɞi ra
sͩc phɠn kháng lɞi, đʀ dɨn t͛i điʀm âm cͧa anh ta âm hơn hay điʀm dương cͧa đ͑i thͧ nh͏
đi (hình 1.4).

Ví dͥ m͙t phɤn cây trò chơi trong hình 1.5.

Ngư͝i chơi cͱc đɞi hi v͍ng ch͍n nư͛c đi bên phɠi đʀ đɞt đưͣc điʀm 8. Thɼ nhưng nɼu đi như
vɪy thì khi đɼn lưͣt đi cͧa ngư͝i chơi cͱc tiʀu, anh ta sɺ c͑ gɬng không cho ngư͝i chơi cͱc
đɞi đɞt đưͣc điʀm này bɮng cách ch͍n nư͛c đi nhánh bên trái và như vɪy, ngư͝i chơi cͱc
đɞi chʆ đưͣc có 1 điʀm thay vì 8. Ngưͣc lɞi, nɼu ngư͝i chơi cͱc đɞi ch͍n nư͛c đi bên trái, thì
trong tình hu͑ng xɢu nhɢt anh ta vɨn còn đưͣc 2 điʀm, l͛n hơn là ch͍n nư͛c đi bên phɠi.
Nói chung, ngư͝i chơi cͱc đɞi sɺ phɠi tìm cách nhɪn ra các nư͛c đi cͧa đ͑i phương tiɼp theo
làm cho điʀm giɠm xu͑ng. Và tương tͱ như vɪy, ngư͝i chơi cͱc tiʀu phɠi nhɪn biɼt đưͣc
nư͛c đi cͧa ngư͝i chơi cͱc đɞi c͑ gɬng làm tăng điʀm lên. Thͧ tͥc tìm nư͛c đi t͑t nhɢt trên
cây trò chơi như trên đưͣc g͍i là thͧ tͥc Minimax do điʀm ͟ m͗i nút có thʀ là điʀm cͱc đɞi
hoɴc có thʀ là điʀm cͱc tiʀu và có thuɪt toán như sau:

-------------------------------------------------------------------------------------------
Thuɪt toán Minimax
- Nɼu như đɞt đɼn gi͛i hɞn tìm kiɼm (đɼn tɤng dư͛i cùng cͧa cây tìm kiɼm), tính giá trʈ tĩnh
cͧa thɼ c͝ hiʄn tɞi ͩng v͛i ngư͝i chơi ͟ đó. Ghi nh͛ kɼt quɠ
- Nɼu như mͩc đang xét là cͧa ngư͝i chơi cͱc tiʀu, áp dͥng thͧ tͥc Minimax này cho các
con cͧa nó. Ghi nh͛ kɼt quɠ nh͏ nhɢt
- Nɼu như mͩc đang xét là cͧa ngư͝i chơi cͱc đɞi, áp dͥng thͧ tͥc Minimax này cho các con
cͧa nó. - Ghi nh͛ kɼt quɠ l͛n nhɢt.
-------------------------------------------------------------------------------------------
Viɼt chương trình cho thuɪt toán Minimax
Bây gi͝, ta thͭ dͱa vào phát biʀu trên đʀ viɼt chương trình cho thuɪt toán này bɮng ngôn
ngͯ tͱa Pascal. Đây là m͙t hàm có tên là Minimax và sɺ là loɞi đʄ qui. Trư͛c hɼt, đʀ hàm
này biɼt đã đɞt đɼn gi͛i hɞn tìm kiɼm chưa, ta cɤn cung cɢp cho nó m͙t tham s͑ vɾ đ͙ sâu
tìm kiɼm depth (đʀ biɼt phɠi tìm đɼn đâu), đ͓ng th͝i ta cũng phɠi cho biɼt thɼ c͝ hiʄn tɞi
pos đʀ nó tͫ đó nó biɼt cách tính tiɼp. Giá trʈ trɠ vɾ cͧa hàm chính là điʀm cͧa thɼ c͝ (bàn
c͝) pos. Vɪy hàm sɺ có khai báo dɞng:

Code: [Check Download Links] & [Get Direct Link]Ê

function Minimax (pos, depth): integer;

M͗i khi Minimax đưͣc g͍i, nó sɺ càng gɤn đɼn gi͛i hɞn tìm kiɼm, do đó ta sɺ g͍i hàm này
v͛i đ͙ sâu bɮng đ͙ sâu cũ trͫ đi m͙t. Đɞt đɼn đ͙ sâu gi͛i hɞn chính là khi depth = 0. Khi
đɞt đ͙ sâu này ta sɺ g͍i hàm lưͣng giá Eval đʀ đánh giá chɢt lưͣng cͧa thɼ c͝ pos hiʄn tɞi
(thͱc hiʄn điɾu m͙t cͧa thuɪt toán). Như vɪy bư͛c đɤu hàm này có dɞng sau:

Code: [Check Download Links] & [Get Direct Link]Ê

function Minimax (pos, depth): integer;
begin
if depth = 0 then { Đã đңt đӁn giӝi hңn }
Minimax := Eval (pos) { Tính giá trӍ thӁ cӟ pos }
else begin
...
Minimax (pos, depth - 1); { Gӏi đӉ qui vӝi đӛ sâu giҥn dҩn}
...
end;
end;

͞ trên, Minimax đưͣc g͍i v͛i đ͙ sâu giɠm đi m͙t. Đó là đ͙ sâu cͧa các thɼ c͝ là con. Các
thɼ c͝ con pos' đó là các thɼ c͝ đưͣc tɞo ra tͫ pos bɮng cách đi m͙t nư͛c đi hͣp lʄ m nào
đó. Do đó ta phɠi có các lʄnh thͱc hiʄn đi quân đʀ đɼn các thɼ c͝ m͛i. Đʀ biɼt tͫ thɼ c͝ pos
có thʀ đi đưͣc nhͯng nư͛c nào, ta dùng m͙t thͧ tͥc Gen có tham s͑ là thɼ c͝ cha pos. Thͧ
tͥc này sɺ cɢt các thɼ c͝ con pos' đó vào b͙ nh͛ (dɞng danh sách). Viʄc tiɼp theo là ta lɢy
tͫng thɼ c͝ đó ra và áp dͥng tiɼp thͧ tͥc Minimax cho nó đʀ tính điʀm value cͧa nó.

Vɪy hàm Minimax bây gi͝ có dɞng:

Code: [Check Download Links] & [Get Direct Link]Ê

function Minimax (pos, depth): integer;
begin
if depth = 0 then
Minimax := Eval (pos) { Tính giá trӍ thӁ cӟ pos }
else begin
Gen (pos); { Sinh ra mӏi nưӝc đi tӭ thӁ cӟ pos }
while còn lҧy đưӥc mӛt nưӝc đi m do
begin
pos := Tính thӁ cӟ mӝi nhӟ đi m;
value := Minimax (pos, depth-1); { Tính điӅm cөa pos }
...
end;
...
end;
end;

Theo phát biʀu cͧa thuɪt toán, ta thɢy các điɾu 2 và 3 chʆ khác nhau ͟ cách ch͍n kɼt quɠ
t͑t nhɢt best phͥ thu͙c vào ngư͝i chơi đang là ngư͝i chơi cͱc đɞi hay cͱc tiʀu. Cu͑i cùng
thuɪt toán sɺ trɠ vɾ điʀm t͑t nhɢt đɞt đưͣc. Vɪy hàm này đưͣc phát triʀn tiɼp thành:

Code: [Check Download Links] & [Get Direct Link]

function Minimax (pos, depth): integer;
begin
if depth = 0 then
Minimax := Eval (pos) { Tính giá trӍ thӁ cӟ pos }
else begin
Gen (pos); { Sinh ra mӏi nưӝc đi tӭ thӁ cӟ pos }
while còn lҧy đưӥc mӛt nưӝc đi m do
begin
pos := Tính thӁ cӟ mӝi nhӟ đi m;
value := Minimax (pos, depth-1); { Tính điӅm cөa pos }
{ Chӏn điӅm tӓt nhҧt tuǤ thuӛc theo ngưӟi chơi }
if ngưӟi chơi là ngưӟi cӳc đңi then
begin
if best < value then best := value;
end
else begin
if best > value then best := value;
end
end;
Minimax := best; { Trҥ vӃ giá trӍ tӓt nhҧt }
end;
end;

Thông thư͝ng đʀ cho tiʄn (và cũng rɢt gɤn sͱ thͱc) ta coi cɠ hai ngư͝i chơi (hai bên) có
cùng cách đánh giá vɾ m͙t thɼ c͝. Có điɾu thɼ c͝ này là t͑t v͛i m͙t ngư͝i thì phɠi đưͣc
đánh giá là t͓i v͛i ngư͝i kia và ngưͣc lɞi. Trong máy tính cách thʀ hiʄn t͑t nhɢt là ta cho
điʀm m͙t thɼ c͝ có thêm dɢu âm dương: dɢu âm dành cho ngư͝i chơi cͱc đɞi và dɢu âm
cho ngư͝i chơi cͱc tiʀu. V͛i ngư͝i chơi cͱc đɞi sɺ mong mu͑n điʀm này càng dương càng
t͑t, còn ngư͝i chơi cͱc tiʀu lɞi mong mu͑n điʀm này càng âm càng t͑t. Do đó đʀ dʂ xͭ lí ta
sɺ tuƒ theo mͩc ngư͝i chơi mà đ͕i dɢu giá trʈ đánh giá thɼ c͝ pos. Chú ý rɮng, thay đ͕i đ͙
sâu là chuyʀn sang đ͑i phương nên phɠi đ͕i dɢu. Chương trình thͱc hiʄn đ͕i dɢu như sau:

Code: [Check Download Links] & [Get Direct Link]

value := -Minimax (pos, depth-1); { Tính điӅm cөa pos }

Cũng do dùng cùng hàm lưͣng giá nên khi đɼn lưͣt ngư͝i chơi cͱc đɞi và cͱc tiʀu có cùng
cái nhìn như nhau vɾ m͙t thɼ c͝. Điɾu này dɨn đɼn có thʀ dùng cùng cách ch͍n nư͛c đi t͑t
nhɢt cho h͍ (g͙p đưͣc điɾu 2 và 3 lɞi v͛i nhau đưͣc). Giá trʈ best cɤn đưͣc kh͟i đɤu rɢt nh͏
đʀ đɠm bɠo không vưͣt m͍i giá trʈ value, t͑t nhɢt là giá trʈ -vô cùng:

Code: [Check Download Links] & [Get Direct Link]

function Minimax (pos, depth): integer;
begin
if depth = 0 then
Minimax := Eval (pos) { Tính giá trӍ thӁ cӟ pos }
else begin
best := -INFINITY;
Gen (pos); { Sinh ra mӏi nưӝc đi tӭ thӁ cӟ pos }
while còn lҧy đưӥc mӛt nưӝc đi m do
begin
pos := Tính thӁ cӟ mӝi nhӟ đi m;
value := -Minimax (pos, depth - 1);
if value > best then best := value;
end;
Minimax := best;
end;
end;

Thông thư͝ng, bàn c͝ đưͣc biʀu diʂn bɮng các biɼn toàn cͥc. Do đó thay cho truyɾn tham
s͑ là m͙t bàn c͝ m͛i pos vào thͧ thͥc Minimax thì ngư͝i ta biɼn đ͕i luôn biɼn toàn cͥc này
nh͝ thͱc hiʄn nư͛c đi "thͭ" (nư͛c đi dɨn đɼn bàn c͝ m͛i pos). Sau khi Minimax thͱc hiʄn
viʄc tính toán dͱa vào bàn c͝ lưu ͟ biɼn toàn cͥc thì thuɪt toán sɺ dùng m͙t s͑ thͧ tͥc đʀ
loɞi b͏ nư͛c đi này. Như vɪy Minimax b͏ các tham s͑ pos như sau:

Code: [Check Download Links] & [Get Direct Link]

function Minimax (depth): integer;
begin
if depth = 0 then Minimax := Eval { Tính thӁ cӟ pos trong biӁn toàn cӧc }
else begin
best := -INFINITY;
Gen; { Sinh ra mӏi nưӝc đi tӭ thӁ cӟ pos }
while còn lҧy đưӥc mӛt nưӝc đi m do
begin
thӳc hiӉn nưӝc đi m;
value := -Minimax (depth - 1);
bӑ thӳc hiӉn nưӝc đi m;
if value > best then best := value;
end;
Minimax := best;
end;
end;

Thuɪt toán Minimax v͛i viʄc đɠo dɢu m͗i khi thay đ͕i đ͙ sâu như trên đôi khi đưͣc g͍i là
thuɪt toán Negamax.

Đánh giá thuɪt toán Minimax

Nɼu hʄ s͑ nhánh trung bình cͧa cây là b và ta thͱc hiʄn tìm kiɼm đɼn đ͙ sâu d thì s͑ nút
phɠi lưͣng giá ͟ đáy cây như ta đã biɼt là bd. Đây chính là s͑ đo đ͙ phͩc tɞp cͧa thuɪt
toán. Nɼu b = 40, d = 4 (các con s͑ thư͝ng gɴp trong trò chơi c͝) thì s͑ nút phɠi lưͣng giá
là 40^4 = 2560000 (trên 2 triʄu rư͡i nút). Còn v͛i b = 40, d = 5 thì s͑ nút phɠi lưͣng giá
sɺ tăng 40 lɤn nͯa thành 40^5 = 102400000 (trên 102 triʄu nút).

Lưu ý: toàn b͙ ý tư͟ng cͧa thuɪt toán này là dͱa trên viʄc chuyʀn đ͕i m͗i thɼ c͝ thành m͙t
con s͑ đʀ đánh giá. Rɢt tiɼc là các con s͑ này thư͝ng không t͑t và không đͧ đʀ đánh giá
 hɼt m͍i điɾu. Mɴt khác, thuɪt toán này có thʀ rɢt t͑n kém (chɞy chɪm) do viʄc sinh các
nư͛c đi và lưͣng giá rɢt t͑n th͝i gian tính toán, do vɪy đ͙ sâu cͧa cây trò chơi cũng bʈ hɞn
chɼ nhiɾu. Ta cɤn có thêm nhͯng cɠi tiɼn đʀ cɠi thiʄn tình hình.

°Ê Ê
VI. Thͧ tͥc AlphaBeta
Thͧ tͥc AlphaBeta là m͙t cɠi tiɼn thuɪt toán Minimax nhɮm tʆa b͛t nhánh cͧa cây trò chơi,
làm giɠm s͑ lưͣng nút phɠi sinh và lưͣng giá, do đó có thʀ tăng đ͙ sâu cͧa cây tìm kiɼm.
Giɠ sͭ hình 1.6 là m͙t thɼ c͝ mà hai nút đɤu tiên đã đưͣc lưͣng giá. Nɼu thͱc hiʄn thͧ tͥc
Minimax đ͑i v͛i các nút đó sɺ cho thɢy ngư͝i chơi cͱc đɞi đã đưͣc đɠm bɠo nɼu đi nư͛c bên
trái sɺ đưͣc ít nhɢt là 2 điʀm dù là các lưͣng giá cͧa các nút khác cho kɼt quɠ như thɼ nào
đi nͯa.

Bây gi͝, ta lɞi giɠ sͭ nút tiɼp theo đưͣc lưͣng giá và cho kɼt quɠ là 1. Nɼu đi vào nhánh này
thì đ͑i phương sɺ đɠm bɠo làm điʀm cͧa ngư͝i chơi cͱc đɞi không thʀ vưͣt quá đưͣc giá trʈ
1 dù là các lưͣng giá cͧa các nút khác cho kɼt quɠ như thɼ nào đi nͯa. Do đó đɼn đây, nư͛c
đi t͑t nhɢt là ch͍n nư͛c đi bên trái v͛i đɠm bɠo là ít nhɢt đɞt đưͣc 2 điʀm. Và do đó, hoàn
toàn không cɤn thiɼt phɠi lưͣng giá nút còn lɞi.

--------------------------------------------------------------------------------------------
Nguyên tɬc Alpha-Beta
Nɼu biɼt điɾu đó thɪt sͱ t͓i thì đͫng mɢt th͝i gian tìm hiʀu nó sɺ t͓i tʄ đɼn đâu
--------------------------------------------------------------------------------------------

Ý tư͟ng này đưͣc g͍i là nguyên tɬc Alpha-Beta do nó dùng trong thͧ tͥc AlphaBeta (ta sɺ
xét dư͛i đây). Hai tham s͑ cͧa thͧ tͥc này (theo các đɴt tên truyɾn th͑ng) đưͣc g͍i là
alpha và beta và dùng đʀ theo dõi các triʀn v͍ng - chúng cho biɼt các giá trʈ nɮm ngoài
khoɠng [alpha, beta] là các điʀm "thɪt sͱ t͓i" và không cɤn phɠi xem xét nͯa. Khoɠng
[alpha, beta] còn đưͣc g͍i là cͭa s͕ alpha, beta. Trong ngͯ cɠnh cͧa các trò chơi, nguyên
tɬc Alpha-Beta nói rɮng, m͗i khi xem xét m͙t nút bɢt kì, nên kiʀm tra các thông tin đã biɼt
vɾ các nút cha, ông cͧa nó. Rɢt có thʀ do có đͧ thông tin tͫ cha, ông nên không cɤn phɠi
làm bɢt cͩ viʄc gì nͯa cho nút này. Cũng vɪy, nguyên tɬc này cũng giúp chʆnh sͭa hoɴc xác
đʈnh chính xác giá trʈ tɞi nút cha, ông nó. Như trên nói, m͙t cách đʀ tiʄn theo dõi quá trình
tính toán là dùng các tham s͑ alpha và beta đʀ ghi lɞi các thông tin theo dõi cɤn thiɼt. Thͧ
tͥc AlphaBeta đưͣc bɬt đɤu tɞi nút g͑c v͛i giá trʈ cͧa alpha là -vôcùng và beta là +vôcùng.
Thͧ tͥc sɺ tͱ g͍i đʄ quy chính nó v͛i khoɠng cách giͯa các giá trʈ alpha và beta ngày càng
hɶp hơn.

Viɼt chương trình cho thuɪt toán AlphaBeta

Tͫ phát biʀu trên ta sɺ xây dͱng hàm AlphaBeta bɮng ngôn ngͯ tͱa Pascal. Hàm này sɺ có
dɞng khai báo như dư͛i, trong đó depth là đ͙ sâu tìm kiɼm, INFINITY là giá trʈ vô cùng,
thuɪt toán tính toán dͱa trên thɼ c͝ hiʄn tɞi pos là các biɼn toàn cͥc:

Code: [Check Download Links] & [Get Direct Link]

function AlphaBeta(alpha, beta, depth): integer;
begin
if depth = 0 then
AlphaBeta := Eval { Tính giá trӍ thӁ cӟ pos }
else begin
best := -INFINITY;
Gen; { Sinh ra mӏi nưӝc đi tӭ vӍ trí pos }
while (còn lҧy đưӥc mӛt nưӝc đi m) and (best < beta) do
begin
if best > alpha then alpha := best;
thӳc hiӉn nưӝc đi m;
value := -AlphaBeta(-beta, -alpha, depth-1);
bӑ thӳc hiӉn nưӝc đi m;
if value > best then best := value;
end;
AlphaBeta := best;
end;
end;

L͝i g͍i thͧ tͥc AlphaBeta đɤu tiên v͛i đ͙ sâu tìm kiɼm 4 và thɼ c͝ hiʄn tɞi pos có dɞng như
sau:

Code: [Check Download Links] & [Get Direct Link]

AlphaBeta(-INFINITY, +INFINITY, 4);

Cũng tương tͱ như thuɪt toán Minimax ta đã g͙p hai mͥc 2 và 3 làm m͙t nh͝ viʄc đ͕i dɢu
thích hͣp. So v͛i thuɪt toán Minimax thì trong thuɪt toán AlphaBeta đã đưa thêm hai biɼn
alpha, beta làm hai mͩc ngư͡ng. Ta thɢy cͩ m͗i khi best >= beta thì thuɪt toán không thͱc
hiʄn tiɼp vòng lɴp, có nghĩa là nó không chʈu m͟ r͙ng tiɼp nhͯng nhánh còn lɞi nͯa. Các
nhánh đó đã bʈ cɬt b͏ - và do đó ta sɺ tiɼt kiʄm đưͣc th͝i gian. Viʄc cɬt b͏ này hoàn toàn
an toàn v͛i nhͯng lí do ta đã xét ͟ trên. Ta thɢy rɮng m͗i lɤn hàm này đưͣc g͍i thì chʆ có
tham s͑ beta đưͣc dùng đʀ so sánh cɬt b͏, còn tham s͑ alpha không đưͣc dùng. Tuy nhiên
khi áp dͥng cùng thuɪt toán cho cây con thì ta đã hoán vʈ hai giá trʈ alpha, beta cho nhau
(và đɠo cɠ dɢu), do đó alpha sɺ có tác dͥng trong đ͙ sâu sau, r͓i đ͙ sâu sau nͯa lɞi đɼn
lưͣt beta... Nói cách khác, m͙t giá trʈ chʆ luôn ɠnh hư͟ng đɼn ngư͝i chơi cͱc đɞi, còn giá trʈ
kia lɞi luôn ɠnh hư͟ng đɼn ngư͝i chơi cͱc tiʀu. Chúng là các ngư͡ng cͧa h͍ (ngư͡ng giͯa
các nư͛c đi đưͣc chɢp nhɪn và không chɢp nhɪn). Nhͯng nư͛c đi cɤn quan tâm phɠi nɮm
l͍t giͯa hai giá trʈ này. Dɤn dɤn khoɠng cách giͯa hai giá trʈ alpha - beta càng ngày càng
thu hɶp và dɨn đɼn các nhánh cây có giá trʈ nɮm ngoài khoɠng này nhanh chóng bʈ cɬt b͏
(hình 1.7).

Đánh giá thuɪt toán AlphaBeta

Trong điɾu kiʄn lí tư͟ng, thuɪt toán AlphaBeta chʆ phɠi xét s͑ nút theo công thͩc:

v͛i d chɲn

v͛i d lɸ

V͛i b = 40 và d = 4 ta có s͑ nút phɠi xét là 2x40^2 - 1 = 3199. Như vɪy trong điɾu kiʄn lí
tư͟ng thì s͑ nút phɠi xét nh͝ AlphaBeta (chʆ khoɠng 3 nghìn nút) ít hơn thuɪt toán Minimax
(hơn 2,5 triʄu nút) là 2560000 / 3199 khoɠng 800 lɤn. Còn v͛i b = 40 và d = 5 ta có s͑ nút
phɠi xét là 40^3 + 40^(5/2) - 1 = 64000+10119-1 = 74118. S͑ nút phɠi xét nh͝
AlphaBeta ít hơn thuɪt toán Minimax (hơn 102 triʄu nút) là 102400000/74118 = 1382 lɤn.

Dư͛i đây là bɠng so sánh s͑ nút phɠi xét giͯa hai thuɪt toán Minimax và AlphaBeta.
Ta có thʀ nhɪn xét như sau:

- S͑ lɤn tăng s͑ nút khi tăng đ͙ sâu cͧa Minimax luôn là hʄ s͑ phân nhánh b, trong trư͝ng
hͣp này là 40. S͑ lɤn tăng cͧa AlphaBeta ít hơn nhiɾu: chʆ c͡ 1.7 lɤn khi tăng tͫ d lɸ sang d
chɲn và 23.2 lɤn khi tͫ d chɲn sang lɸ - trung bình chʆ tăng khoɠng hơn 6 lɤn khi tăng d
- S͑ nút cͧa AlphaBeta tăng chɪm hơn rɢt nhiɾu lɤn so v͛i Minimax. Tʆ s͑ nút phɠi xét giͯa
hai thuɪt toán này càng cao khi d càng l͛n.
Công thͩc tính s͑ nút cho thɢy s͑ nút phɠi xét khi dùng AlphaBeta ít hơn nhiɾu so v͛i
Minimax nhưng vɨn là hàm s͑ mũ và vɨn dɨn t͛i bùng n͕ t͕ hͣp. Thuɪt toán AlphaBeta
hoàn toàn không ch͑ng đưͣc bùng n͕ t͕ hͣp mà chʆ làm giɠm t͑c đ͙ bùng n͕. Tuy trong
thͱc tɼ s͑ nút phɠi xét (lưͣng giá) thư͝ng nhiɾu hơn trong điɾu kiʄn lí tư͟ng nhưng nó vɨn
đͧ đʀ tiɼt kiʄm khá nhiɾu th͝i gian. Trong cùng m͙t khoɠng th͝i gian, thuɪt toán AlphaBeta
có thʀ tìm đɼn đ͙ sâu gɢp hai lɤn đ͙ sâu tìm kiɼm bɮng Minimax. Hình 1.8 là đ͓ thʈ so sánh
giͯa hai thuɪt toán này.
Ví dͥ: Ta sɺ xem xét thuɪt toán AlphaBeta hoɞt đ͙ng như thɼ nào đ͑i v͛i cây trò chơi như
trong hình 1.9.
Cây này có đ͙ sâu bɮng 3 và hʄ s͑ phân nhánh bɮng 3. Các thͩ tͱ kɼt luɪn (các con s͑ bên
trái) đưͣc đưa ra như sau:

[1-2] Tìm kiɼm đi xu͑ng dư͛i theo nhánh trái cho đɼn lá. ͞ đây giá trʈ tĩnh thu đưͣc là 8.
Giá trʈ đɤu tiên này do ngư͝i chơi cͱc đɞi đưͣc phép ch͍n trong ba giá trʈ ͟ nhánh này đã
đɠm bɠo rɮng là kɼt quɠ thu đưͣc sɺ ít nhɢt là bɮng 8. Điɾu lưu ý này đưͣc bư͛c 2 ghi lɞi.

[3-5] Đʀ chɬc chɬn không còn có điʀm nào cao hơn 8, ngư͝i chơi cͱc đɞi phɠi xét cɠ hai thɼ
c͝ còn lɞi và thu đưͣc các giá trʈ 7 và 2. Do đó đɼn đây đã kɼt luɪn chính xác điʀm cao nhɢt
có thʀ đɞt đưͣc ͟ cây con là đúng bɮng 8.

[6]. Leo lên m͙t tɤng cây. Đây là các nư͛c đi cͧa ngư͝i chơi cͱc tiʀu. Ta không hi v͍ng anh
ta cho ngư͝i chơi cͱc đɞi đưͣc nhiɾu điʀm nên có thʀ tɞm kɼt luɪn ͟ mͩc này là sɺ đɞt đưͣc
nhiɾu nhɢt là 8 điʀm.

[7-8]. Đʀ xem ngư͝i chơi cͱc tiʀu còn lͱa ch͍n nào t͑t hơn (và t͓i tʄ hơn cho ngư͝i chơi
cͱc đɞi) ta phɠi xem xét cɠ hai nư͛c đi còn lɞi. Nư͛c đi còn lɞi đɤu tiên dɨn đɼn giá trʈ lưͣng
giá tĩnh là 9 - m͙t giá trʈ l͛n hơn 8. Như vɪy nhánh giͯa là t͓i tʄ hơn cho ngư͝i chơi cͱc
tiʀu. Đɼn đây viʄc cɬt b͏ đưͣc thͱc hiʄn - đͫng hòng ngư͝i chơi cͱc đɞi v͛i t͛i đưͣc điʀm
đó khi đã có sɲn lͱa ch͍n thɢp hơn cho anh ta (là 8). Điɾu này cũng dɨn đɼn không cɤn
thiɼt phɠi xét hai nút còn lɞi - đɮng nào nhánh giͯa cũng đͧ t͓i tʄ r͓i và ngư͝i chơi cͱc tiʀu
sɺ không ch͍n nó đʀ đi.

[9-14]. Ngư͝i chơi cͱc tiʀu cɤn phɠi khɠo sát tiɼp lͱa ch͍n cu͑i cùng. Cách làm tương tͱ
như phɤn trên. ͞ đây phɠi lưͣng giá cɠ ba nút cây và kɼt luɪn cu͑i cùng đưͣc đưa ra là
ngư͝i chơi cͱc đɞi đi gi͏i lɬm thì chʆ đɞt đưͣc 4 điʀm.

[15]. Như vɪy nh͝ viʄc khɠo sát nhánh cây bên phɠi ngư͝i chơi cͱc tiʀu thɢy rɮng nɼu ch͍n
đi theo nhánh này thì ngư͝i chơi cͱc đɞi chʆ đưͣc có 4 điʀm thay cho 8.

[16]. Bây gi͝ ta có thʀ kɼt luɪn ͟ mͩc trên cùng. Mͩc này là cͧa ngư͝i chơi cͱc đɞi. Anh ta
thɢy rɮng nɼu ch͍n đi theo nhánh trái thì đưͣc 4 điʀm. Như vɪy anh ta đã chɬc chɬn điʀm
cͧa mình sɺ ít nhɢt là 4 r͓i. Đʀ xem liʄu có thʀ đɞt đưͣc điʀm cao hơn nͯa hay không cɤn
phɠi xem xét hai nhánh còn lɞi.

[17-30]. Tương tͱ như phɤn trên, ta kɼt luɪn nhánh giͯa sɺ mang lɞi cho ngư͝i chơi cͱc đɞi
5 điʀm. 31. Cũng tương tͱ như kɼt luɪn 16, ͟ đây ta kɼt luɪn khɠ quan hơn là ngư͝i chơi
cͱc đɞi đã cɤm chɬc 5 điʀm và có thʀ còn cao hơn.

[32-38] Ta kɼt luɪn đưͣc rɢt nhanh là cây con bên phɠi chʆ cho "thu hoɞch" nhiɾu nhɢt là 3
điʀm - m͙t điʀm s͑ quá kém do đó thuɪt toán không bu͓n xem xét các trư͝ng hͣp còn lɞi
nͯa. Do đó đã tiɼt kiʄm đưͣc 6 nút không cɤn phɠi lưͣng giá và cũng không phɠi sinh nư͛c
đi cho hai trư͝ng hͣp.

[39]. Kɼt luɪn cu͑i cùng là điʀm cao nhɢt mà ngư͝i chơi cͱc đɞi có thʀ thu đưͣc là 5 điʀm
nh͝ ch͍n đi theo nhánh giͯa.

VII. Hư͛ng cɠi thiʄn viʄc tʆa nhánh cͧa thuɪt toán AlphaBeta
Thuɪt toán AlphaBeta nói chung giúp chúng ta tiɼt kiʄm nhiɾu th͝i gian so v͛i Minimax mà
vɨn đɠm bɠo kɼt quɠ tìm kiɼm chính xác. Tuy nhiên lưͣng tiɼt kiʄm này không ͕n đʈnh -
phͥ thu͙c vào s͑ nút mà nó cɬt b͏. Trong trư͝ng hͣp xɢu nhɢt thuɪt toán không cɬt đưͣc
m͙t nhánh nào và phɠi xét s͑ nút đúng bɮng Minimax. Ta cɤn đɦy mɞnh viʄc cɬt b͏ nh͝
đɦy nhanh sͱ thu hɶp cͧa cͭa s͕ tìm kiɼm alpha - beta. Cͭa s͕ này đưͣc thu hɶp m͙t bư͛c
khi gɴp m͙t giá trʈ m͛i t͑t hơn giá trʈ cũ. Khi gɴp giá trʈ t͑t nhɢt thì cͭa s͕ này thu hɶp
nhɢt. Do đó nɼu càng s͛m gɴp giá trʈ t͑t nhɢt thì cͭa s͕ càng chóng thu hɶp. Như vɪy phɠi
làm sao cho các nút ͟ lá đưͣc sɬp xɼp theo trɪt tͱ tͫ cao xu͑ng thɢp. Trɪt tͱ này càng t͑t
bao nhiêu thì thuɪt toán chɞy càng nhanh bɢy nhiêu (các công thͩc vɾ s͑ nút phɠi lưͣng giá
trong điɾu kiʄn lí tư͟ng ͟ trên tính đưͣc v͛i trɪt tͱ là t͑t nhɢt). Ta sɺ tr͟ lɞi phɤn này trong
m͙t chương riêng.

T͕ng kɼt chương 1

Chương này trình bɤy nhͯng kiɼn thͩc chung vɾ trò chơi c͝, các đʈnh nghĩa và thɼ nào là
cây trò chơi. Do bùng n͕ t͕ hͣp quá l͛n cͧa cây trò chơi mà cɠ ngư͝i và máy không thʀ (và
không bao gi͝) có thʀ tìm kiɼm vét cɞn (hɼt m͍i khɠ năng). Do đó phương pháp tìm kiɼm
duy nhɢt là chʆ tìm kiɼm đɼn m͙t đ͙ sâu gi͛i hɞn nào đó và ch͍n nư͛c đi dɨn đɼn m͙t thɼ
c͝ có lͣi nhɢt cho mình. Do phɠi tính cɠ khɠ năng ch͑ng trɠ cͧa đ͑i phương nên ta không
dùng đưͣc các thuɪt toán tìm kiɼm thông thư͝ng. Phɠi dùng m͙t thuɪt toán tìm kiɼm riêng
cho cây trò chơi. Đó là thuɪt toán Minimax và cɠi tiɼn cͧa nó là AlphaBeta. Tuy cɠ hai thuɪt
toán đɾu không tránh đưͣc bùng n͕ t͕ hͣp nhưng AlphaBeta làm chɪm bùng n͕ t͕ hͣp hơn
nên đưͣc dùng nhiɾu trong các trò chơi c͝.

VII. Hư͛ng cɠi thiʄn viʄc tʆa nhánh cͧa thuɪt toán AlphaBeta
Thuɪt toán AlphaBeta nói chung giúp chúng ta tiɼt kiʄm nhiɾu th͝i gian so v͛i Minimax mà
vɨn đɠm bɠo kɼt quɠ tìm kiɼm chính xác. Tuy nhiên lưͣng tiɼt kiʄm này không ͕n đʈnh -
phͥ thu͙c vào s͑ nút mà nó cɬt b͏. Trong trư͝ng hͣp xɢu nhɢt thuɪt toán không cɬt đưͣc
m͙t nhánh nào và phɠi xét s͑ nút đúng bɮng Minimax. Ta cɤn đɦy mɞnh viʄc cɬt b͏ nh͝
đɦy nhanh sͱ thu hɶp cͧa cͭa s͕ tìm kiɼm alpha - beta. Cͭa s͕ này đưͣc thu hɶp m͙t bư͛c
khi gɴp m͙t giá trʈ m͛i t͑t hơn giá trʈ cũ. Khi gɴp giá trʈ t͑t nhɢt thì cͭa s͕ này thu hɶp
nhɢt. Do đó nɼu càng s͛m gɴp giá trʈ t͑t nhɢt thì cͭa s͕ càng chóng thu hɶp. Như vɪy phɠi
làm sao cho các nút ͟ lá đưͣc sɬp xɼp theo trɪt tͱ tͫ cao xu͑ng thɢp. Trɪt tͱ này càng t͑t
bao nhiêu thì thuɪt toán chɞy càng nhanh bɢy nhiêu (các công thͩc vɾ s͑ nút phɠi lưͣng giá
trong điɾu kiʄn lí tư͟ng ͟ trên tính đưͣc v͛i trɪt tͱ là t͑t nhɢt). Ta sɺ tr͟ lɞi phɤn này trong
m͙t chương riêng.

T͕ng kɼt chương 1

Chương này trình bɤy nhͯng kiɼn thͩc chung vɾ trò chơi c͝, các đʈnh nghĩa và thɼ nào là
cây trò chơi. Do bùng n͕ t͕ hͣp quá l͛n cͧa cây trò chơi mà cɠ ngư͝i và máy không thʀ (và
không bao gi͝) có thʀ tìm kiɼm vét cɞn (hɼt m͍i khɠ năng). Do đó phương pháp tìm kiɼm
duy nhɢt là chʆ tìm kiɼm đɼn m͙t đ͙ sâu gi͛i hɞn nào đó và ch͍n nư͛c đi dɨn đɼn m͙t thɼ
c͝ có lͣi nhɢt cho mình. Do phɠi tính cɠ khɠ năng ch͑ng trɠ cͧa đ͑i phương nên ta không
dùng đưͣc các thuɪt toán tìm kiɼm thông thư͝ng. Phɠi dùng m͙t thuɪt toán tìm kiɼm riêng
cho cây trò chơi. Đó là thuɪt toán Minimax và cɠi tiɼn cͧa nó là AlphaBeta. Tuy cɠ hai thuɪt
toán đɾu không tránh đưͣc bùng n͕ t͕ hͣp nhưng AlphaBeta làm chɪm bùng n͕ t͕ hͣp hơn
nên đưͣc dùng nhiɾu trong các trò chơi c͝.

Bài đ͍c

SƠ LƯ͢C Vɽ LʇCH Sͬ CÁC CHƯƠNG TRÌNH CHƠI C͜

Vào năm 1950, Alan Turing - m͙t nhà nghiên cͩu ngư͝i Anh đi tiên phong trong lĩnh vͱc
máy tính s͑, đã viɼt chương trình chơi c͝ đɤu tiên. Vào lúc đó, Turing phɠi viɼt và chɞy
chương trình cͧa ông bɮng... bút chì và giɢy. Chương trình đó, cũng như chͧ nhân cͧa nó,
chơi c͝ rɢt t͓i, nhưng đɞt đưͣc mͥc đích: cho thɢy máy tính có thʀ chơi đưͣc c͝. Cũng vào
năm đó, Claude Shannon đã vɞch ra m͙t chiɼn lưͣc cho máy tính chơi c͝ t͑t. Nhưng vào
nhͯng năm 1950 t͑c đ͙ máy tính rɢt chɪm nên không ai dám tiên đoán liʄu máy tính có thʀ
thɬng con ngư͝i đưͣc không, dù trong các trò chơi đơn giɠn như trò Checker.

Năm 1958, m͙t chương trình chơi c͝ đã lɤn đɤu tiên hɞ đưͣc đ͑i phương là con ngư͝i.
Ngư͝i thua là m͙t cô thư kí cͧa chính đ͙i lɪp trình ra nó, cô chưa bao gi͝ chơi c͝ trư͛c đó
và đưͣc dɪy chơi c͝ chʆ m͙t gi͝ trư͛c cu͙c đɢu. Đ͑i v͛i ngày nay chiɼn công này thɪt nh͏
nhoi, nhưng nó cho thɢy tri thͩc có thʀ đưͣc đưa vào trong m͙t chương trình chơi c͝. Lưͣng
tri thͩc này đưͣc đo chính xác bɮng m͙t gi͝ h͍c chơi.

Sau chiɼn thɬng đó, m͙t s͑ ngư͝i trong nhóm lɪp trình c͝ đɤu tiên đã tiên đoán rɮng vào
nhͯng năm 60 sɺ có chương trình chơi c͝ đưͣc liʄt vào hàng ngũ kiʄn tư͛ng thɼ gi͛i. Vào
nhͯng năm cu͑i cͧa thɪp kͷ 60, Spassky đã tr͟ thành kiʄn tư͛ng c͝ thɼ gi͛i và các chương
trình chơi c͝ đã chiɼm đưͣc nhͯng thͩ hɞng cao trong hàng ngũ nhͯng ngư͝i chơi cao cɢp.
Nhưng nhiɾu ngư͝i cho rɮng máy tính sɺ không bao gi͝ có thʀ giɠi quyɼt đưͣc nhͯng nhiʄm
vͥ thông minh, không thʀ đɞt đưͣc chͩc Vô đʈch c͝ thɼ gi͛i.

L͝i tiên đoán này đưͣc nhɬc lɞi m͙t lɤn nͯa vào nhͯng năm 70, liên quan đɼn m͙t cu͙c
đánh cưͣc giͯa David Levy, m͙t kiʄn tư͛ng qu͑c tɼ ngư͝i Anh (theo phân loɞi cͧa Liên
đoàn c͝ qu͑c tɼ các đɰng cɢp cao bao g͓m: Kiʄn tư͛ng qu͑c tɼ, Đɞi kiʄn tư͛ng và Vô đʈch
thɼ gi͛i) và John McCarthy, m͙t nhà nghiên cͩu trong lĩnh vͱc trí tuʄ nhân tɞo. L͝i thách
đɢu đưͣc đưa ra vào năm 1978. Trɪn đɢu đã đưͣc diʂn ra và chương trình c͝ t͑t nhɢt th͝i
đó, CHESS 4.7 đã bʈ Levy hɞ trong trɪn đɢu có năm ván tɞi Toronto v͛i thành tích ba ván
ngư͝i thɬng, m͙t hoà và m͙t máy thɬng. Levy không chʆ chiɼn thɬng mà còn đút túi s͑ tiɾn
đánh cưͣc 1000 bɠng.

Nɼu như mͥc đích cͧa cu͙c đánh cưͣc là làm cho nhͯng nhà nghiên cͩu phɠi nghĩ kĩ trư͛c
khi tiên đoán đɼn ngày thɬng lͣi, thì lɤn đánh cưͣc này cho thɢy: mɴc dù tiên đoán sai
trong nhͯng năm 1958-1968 và 1968-1978, các chuyên gia chương trình c͝ lɞi tiɼp tͥc tiên
đoán tiɼp rɮng máy tính sɺ đɞt đɼn vô đʈch c͝ thɼ gi͛i trong thɪp kʆ tiɼp theo.

Nhưng m͙t lɤn nͯa, vào năm 1988, Vô đʈch c͝ thɼ gi͛i vɨn là con ngư͝i.

Trong năm tiɼp theo, Deep Thought, m͙t chương trình c͝ mɞnh nhɢt tͫ xưa đɼn nay đã
chiɼn thɬng m͙t cách dʂ dàng Kiʄn tư͛ng Qu͑c tɼ Levy. B͙ não cͧa Deep Thought có 250
chip và hai b͙ xͭ lí trong m͙t bɠng mɞch đơn, nó có khɠ năng xét 750.000 thɼ c͝ trong m͙t
giây và tìm trư͛c đưͣc đɼn 10 nư͛c. Cũng trong năm đó, nó là máy tính đɤu tiên hɞ đưͣc
m͙t Đɞi kiʄn tư͛ng (Bent Larsen). Deep Thought đã tr͟ thành m͙t trong m͙t trăm ngư͝i
chơi c͝ mɞnh nhɢt thɼ gi͛i. Nhưng trong trɪn đɢu diʂn ra vào năm 1989 giͯa nhà Vô đʈch
thɼ gi͛i Garry Kasparov và Deep Thought thì nó đã bʈ nhà vô đʈch đè bɶp.

Các l͝i tiên đoán lɞi đɼn như các lɤn trư͛c. Đã ba lɤn các nhà nghiên cͩu tiên đoán: 'trong
thɪp kʆ t͛i'. Nhưng lɤn này h͍ lɞi sͭa lɞi là: 'trong 3 năm t͛i'...

Trong năm 1993, Deep Thought đã hɞ Judit Polgar - lúc đó là Đɞi kiʄn tư͛ng trɸ nhɢt trong
lʈch sͭ và là ngư͝i phͥ nͯ chơi hay nhɢt thɼ gi͛i, trong trɪn đɢu 2 ván.

Trong năm 1996, Deep Blue (tên m͛i cͧa Deep Thought và lúc này nó thu͙c hãng IBM) là
m͙t máy tính song song có 32 b͙ xͭ lí v͛i 256 mɞch tích hͣp c͡ l͛n, khɠ năng xét tͫ 2 đɼn
400 triʄu nư͛c đi m͗i giây) đã thɬng Gary Kasparov trong ván đɤu tiên cͧa trɪn đɢu 6 ván,
nhưng lɞi thua trong toàn trɪn (v͛i tʆ s͑ máy thɬng 1, hoà 2 và thua 3).

Cu͑i cùng đích mà m͍i ngư͝i ch͝ đͣi đã t͛i, nhưng sau 9 năm tͫ l͝i tiên đoán cu͑i và 39
năm tͫ lúc có chương trình chơi c͝ đɤu tiên, Deep Blue đã chiɼn thɬng nhà đương kim Vô
đʈch thɼ gi͛i Garry Kasparov vào tháng 5/1997 trong m͙t cu͙c chiɼn dài đɤy khó khăn, v͛i
tͷ s͑ sát nút 2 thɬng, 1 thua và 3 hoà.

Phɞm H͓ng Nguyên, sưu tɤm, t͕ng hͣp và dʈch tͫ Internet