一,极大极小搜索及alpha-beta剪枝(参考这里)
在博弈搜索中,比如:围棋,五子棋,象棋等,结果有三种可能:胜利,失败和平局。
理论上可以穷举所有的走法,这就需要生成整棵博弈树。实际上不可行。因此搜索时可以限制博弈树的深度,到达该深度则不再往下搜,相当于只往前看n步。
假设:max和min对弈,轮到max走棋了,那么我们遍历max的每一个可能走棋方法,然后对于前面max的每一个走棋方法,遍历min的每一个走棋方法,然后接着遍历max的每一个走棋方法,。。。直到分出了胜负或者达到了搜索深度的限制。若达到搜索深度限制时尚未分出胜负,则根据当前局面的形式,给出一个得分,计算得分的方法被称为估价函数,不同游戏的估价函数如何设计和具体的游戏相关。
在搜索树中,轮到max走棋的节点为极大结点,轮到min走棋的节点是极小节点。
极大极小搜索
确定估价函数,来计算每个棋局结点的估价值,对max方有利,估价值为正,对max越有利,估价值越大;对min方有利,估价值为负,对min方越有利,估价值越小。
从当前棋局的结点要决定下一步如何走时,以当前棋局节点为根,生成一棵深度为n的搜索树。不妨总是假设当前棋局结点是max结点。
用局面估价函数计算出每个叶子结点的估价值。
若某个非叶子结点是极大结点,则其估价值为其子节点中估价最大的那个结点的估价值。
若某个非叶子结点是极小结点,则其估价值为其子结点中估价最小的那个结点的估价值。
max选当前棋局结点的估价值最大的那个子节点,作为此步行棋的走法。
伪代码如下(参考这里):
function minimax(node, depth)
if node is a terminal node or depth = 0
return the heuristic value of node
if the adversary is to play at node
let α := +∞
foreach child of node
α := min(α, minimax(child, depth-1))
else {we are to play at node}
let α := -∞
foreach child of node
α := max(α, minimax(child, depth-1))
return α
alpha和beta剪枝
若结点x是min结点,其兄弟结点中,已经求出来的最大估价值是b(有些兄弟结点还没有算),那么在对x的子节点进行考察的时候,一旦发现x的某子节点的估价值小于等于b,则不必在考察后边x的结点了。这里被剪掉的是x结点的子节点,也就是极大结点。同理对应的还有beta剪枝,剪掉的是极小结点。
二,例题
poj1568 Find the Winning Move
给定一个4*4的四子连珠棋盘的局面,现在轮到x先走,请问x下在哪里可以必胜。
....
.xo.
.ox.
....
在穷尽搜索中,而非搜几层就停止的情况下,估价函数只有三种取值,正(inf),0,负(-inf),分别代表己方胜,平,负。
必胜是无论对手怎么走,自己最后都能找到获胜办法,不是自己无论怎么走都能获胜。
如果能找到一个走法,其对应的结点估价值是inf,则就是一个必胜的策略。
具体代码如下:
/*************************************************************************
> File Name: 1568.cpp
> Author: gwq
> Mail: gwq5210@qq.com
> Created Time: 2015年09月01日 星期二 14时41分57秒
************************************************************************/
#include <cmath>
#include <ctime>
#include <cctype>
#include <climits>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#include <sstream>
#include <iostream>
#include <algorithm>
#define INF (INT_MAX / 10)
#define clr(arr, val) memset(arr, val, sizeof(arr))
#define pb push_back
#define sz(a) ((int)(a).size())
using namespace std;
typedef set<int> si;
typedef vector<int> vi;
typedef map<int, int> mii;
typedef pair<int, int> pii;
typedef long long ll;
const double esp = 1e-5;
#define N 5
int ansx, ansy, cnt;
char mp[N][N], tp[N];
int max_search(int x, int y, int beta);
void print(void)
{
for (int i = 0; i < 4; ++i) {
printf("%s\n", mp[i]);
}
}
bool check(int x, int y)
{
bool flag = true;
for (int i = 0; i < 4; ++i) {
if (mp[x][i] != mp[x][y]) {
flag = false;
break;
}
}
if (flag) {
return true;
}
flag = true;
for (int i = 0; i < 4; ++i) {
if (mp[i][y] != mp[x][y]) {
flag = false;
break;
}
}
if (flag) {
return true;
}
int c = 0;
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 4; ++j) {
if (i + j == x + y) {
if (mp[i][j] == mp[x][y]) {
++c;
}
}
}
}
if (c == 4) {
return true;
}
c = 0;
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 4; ++j) {
if (i - j == x - y) {
if (mp[i][j] == mp[x][y]) {
++c;
}
}
}
}
if (c == 4) {
return true;
} else {
return false;
}
}
int min_search(int x, int y, int alpha)
{
int ans = INF;
if (check(x, y)) {
return INF;
}
if (cnt == 16) {
return 0;
}
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 4; ++j) {
if (mp[i][j] == '.') {
mp[i][j] = 'o';
++cnt;
int tmp = max_search(i, j, ans);
ans = min(ans, tmp);
mp[i][j]= '.';
--cnt;
if (ans <= alpha) {
return ans;
}
}
}
}
return ans;
}
int max_search(int x, int y, int beta)
{
int ans = -INF;
if (check(x, y)) {
return -INF;
}
if (cnt == 16) {
return 0;
}
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 4; ++j) {
if (mp[i][j] == '.') {
mp[i][j] = 'x';
++cnt;
int tmp = min_search(i, j, ans);
ans = max(ans, tmp);
mp[i][j]= '.';
--cnt;
if (ans >= beta) {
return ans;
}
}
}
}
return ans;
}
bool solve(void)
{
int alpha = -INF;
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 4; ++j) {
if (mp[i][j] == '.') {
mp[i][j] = 'x';
++cnt;
int tmp = min_search(i, j, alpha); // X走过之后O走
mp[i][j] = '.';
--cnt;
if (tmp == INF) {
ansx = i;
ansy = j;
return true;
}
}
}
}
return false;
}
int main(int argc, char *argv[])
{
while (scanf("%s", tp) != EOF) {
if (tp[0] == '$') {
break;
}
cnt = 0;
for (int i = 0; i < 4; ++i) {
scanf("%s", mp[i]);
for (int j = 0; j < 4; ++j) {
if (mp[i][j] != '.') {
++cnt;
}
}
}
if (cnt <= 4) { // 这一步直接从2S+到0ms,然而并不知道为啥
printf("#####\n");
continue;
}
if (solve()) {
printf("(%d,%d)\n", ansx, ansy);
} else {
printf("#####\n");
}
}
return 0;
}
poj 1085 Triangle War
两个游戏者轮流填充虚线三角形,每次只能填充一条短边,若某游戏者填充一条短边后组成了一个小三角形,则该游戏者拥有这个三角形,并且可以继续填充。
当所有边都被填充之后,拥有三角形数目多的游戏者获胜。给定一个局面,问谁可以赢。
三角形的个数是9,当一个人拥有5个及以上个三角形是这个人就必胜。这里的估价函数定义为a的三角形数-b的三角形数。
代码如下:
/*************************************************************************
> File Name: 1085.cpp
> Author: gwq
> Mail: gwq5210@qq.com
> Created Time: 2015年09月01日 星期二 16时35分54秒
************************************************************************/
#include <cmath>
#include <ctime>
#include <cctype>
#include <climits>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#include <sstream>
#include <iostream>
#include <algorithm>
#define INF (INT_MAX / 10)
#define clr(arr, val) memset(arr, val, sizeof(arr))
#define pb push_back
#define sz(a) ((int)(a).size())
using namespace std;
typedef set<int> si;
typedef vector<int> vi;
typedef map<int, int> mii;
typedef pair<int, int> pii;
typedef long long ll;
const double esp = 1e-5;
#define N 20
int num[N], who, n, cnt, ans[2];
int dx[] = {1, 1, 2, 2, 2, 3, 3, 4, 5, 4, 4, 5, 5, 6, 6, 7, 8, 9};
int dy[] = {2, 3, 3, 4, 5, 5, 6, 5, 6, 7, 8, 8, 9, 9, 10, 8, 9, 10};
int mp[][N] = {
{0, 1, 2},
{2, 4, 5},
{3, 4, 7},
{5, 6, 8},
{7, 10, 11},
{11, 12, 16},
{8, 12, 13},
{9, 10, 15},
{13, 14, 17}
};
int getid(int a, int b)
{
int aa = min(a, b);
int bb = max(a, b);
for (int i = 0; i < 18; ++i) {
if (aa == dx[i] && bb == dy[i]) {
return i;
}
}
return -1;
}
// 检查三角形的时候,需要注意,因为加入的时候可能组成两个三角形
int check(int id)
{
int ret = 0;
for (int i = 0; i < 9; ++i) {
if (mp[i][0] == id || mp[i][1] == id || mp[i][2] == id) {
int flag = 0;
for (int j = 0; j < 3; ++j) {
flag += num[mp[i][j]];
}
if (flag == 3) {
ret++;
}
}
}
return ret;
}
int min_search(int alpha, int a, int b);
int max_search(int beta, int a, int b)
{
if (cnt == 18) {
return a > b ? INF : -INF;
}
if (a >= 5) {
return INF;
}
if (b >= 5) {
return -INF;
}
int tmp = -INF;
for (int i = 0; i < 18; ++i) {
if (!num[i]) {
num[i] = 1;
++cnt;
// 改变后需要恢复,索性存起来
int aa = a;
int bb = b;
int cc = check(i);
aa += cc;
if (cc) {
// 这里传入的值需要注意,这个的父节点是max,
// 所以这里的剪枝需要beta,而不是tmp,即当前
// min结点获得的最大值。下边类似
tmp = max(max_search(beta, aa, bb), tmp);
} else {
tmp = max(min_search(tmp, aa, bb), tmp);
}
num[i] = 0;
--cnt;
if (tmp >= beta) {
return tmp;
}
}
}
return tmp;
}
int min_search(int alpha, int a, int b)
{
if (cnt == 18) {
return a > b ? INF : -INF;
}
if (a >= 5) {
return INF;
}
if (b >= 5) {
return -INF;
}
int tmp = INF;
for (int i = 0; i < 18; ++i) {
if (!num[i]) {
num[i] = 1;
++cnt;
int aa = a;
int bb = b;
int cc = check(i);
bb += cc;
if (!cc) {
tmp = min(max_search(tmp, aa, bb), tmp);
} else {
tmp = min(min_search(alpha, aa, bb), tmp);
}
--cnt;
num[i] = 0;
if (tmp <= alpha) {
return tmp;
}
}
}
return tmp;
}
int main(int argc, char *argv[])
{
int t;
int cs = 0;
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
clr(num, 0);
clr(ans, 0);
who = 0;
cnt = n;
for (int i = 0; i < n; ++i) {
int a, b;
scanf("%d%d", &a, &b);
int id = getid(a, b);
num[id] = 1;
int cc = check(id);
if (cc) {
ans[who] += cc;
} else {
who = !who;
}
}
int ret = 0;
if (!who) {
ret = max_search(INF, ans[0], ans[1]);
} else {
ret = min_search(-INF, ans[0], ans[1]);
}
printf("Game %d: %c wins.\n", ++cs, ret == INF ? 'A' : 'B');
}
return 0;
}