英雄会第一届在线编程大赛:单词博弈 (C++代码) ---miss若尘


解题思路:http://blog.csdn.net/miss_ruochen/article/details/17199887

不要忘了添加头文件呀吐舌头


int who_win (string word, map<string, int>& m)
{
	typedef pair <string, int> Who_Pair;

	int size = word.size();
	if(size < 2)
		return -1;

	if(size == 2)
		return 1;

	if(size == 3) {
		if(word[0] >= word[1] && word[1] >= word[2])
			return 0;
		else
			return 1;
	}

	for(int i = 0; i < size; ++i) {
		if(i != 0 && word[i] == word[i-1])
			continue;
			
		string str = word.substr(0,i)+word.substr(i+1,size-i-1);

		bool flag = true;
		for(int j = 0; j < size-2; ++j) {
			if(str[j] >= str[j+1]) {
				flag = false;
				break;
			}
		}
		if(flag)
			return 1;
	}

	for(int k = 0; k < size; ++k) {
		if(k != 0 && word[k] == word[k-1])
			continue;
			
		string strtmp = word.substr(0,k)+word.substr(k+1,size-k-1);
		map<string, int> :: iterator m_iter;
		m_iter = m.find(strtmp);
		int state;

		if(m_iter == m.end()) {
			state = who_win(strtmp, m);
			m.insert( Who_Pair (strtmp, state) );
		}
		else {
			state = m_iter->second;
		}

		if( !state )
			return 1;
	}
	
	m.insert( Who_Pair (word, 0) );
	return 0;
}

int who (string word)
{
	map<string, int> m;
	typedef pair <string, int> Who_Pair;

	m.insert( Who_Pair ("a",0) );

	return who_win(word, m);
}


忘了说,为什么我在who函数里要给map插入一个字符'a',因为我不想每次在查找前都要判断map是否为空,不知道频繁的判断是不是会降低速度,所以我宁愿随便插入点什么了,而且字符'a’长度为1不会影响原思路的判断的,随便给的而已


  • 0
    点赞
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
以下是一个六子棋博弈树的α-β剪枝算法的Python代码: ```python import numpy as np # 博弈树节点 class Node: def __init__(self, state, depth, alpha=-np.inf, beta=np.inf): self.state = state self.depth = depth self.alpha = alpha self.beta = beta self.children = [] def is_terminal(self): return self.depth == 0 or self.state.is_game_over() def evaluate(self): # 计算当前节点的估价值 return self.state.evaluate() def generate_children(self): # 生成当前节点的所有子节点 for move in self.state.get_legal_moves(): new_state = self.state.apply_move(move) child = Node(new_state, self.depth - 1) self.children.append(child) def get_best_child(self): # 获取当前节点的最佳子节点 best_child = None if self.children: best_child = self.children[0] for child in self.children: if child.alpha >= best_child.alpha: best_child = child return best_child # MiniMax算法 def minimax(node, maximizing_player): if node.is_terminal(): return node.evaluate() if maximizing_player: value = -np.inf for child in node.children: value = max(value, minimax(child, False)) node.alpha = max(node.alpha, value) if node.beta <= node.alpha: break return value else: value = np.inf for child in node.children: value = min(value, minimax(child, True)) node.beta = min(node.beta, value) if node.beta <= node.alpha: break return value # α-β剪枝算法 def alphabeta(node, depth, alpha, beta, maximizing_player): if depth == 0 or node.is_terminal(): return node.evaluate() if maximizing_player: value = -np.inf for child in node.children: value = max(value, alphabeta(child, depth - 1, alpha, beta, False)) alpha = max(alpha, value) if beta <= alpha: break return value else: value = np.inf for child in node.children: value = min(value, alphabeta(child, depth - 1, alpha, beta, True)) beta = min(beta, value) if beta <= alpha: break return value # 六子棋游戏状态 class GameState: def __init__(self): self.board = np.zeros((6, 6), dtype=int) self.current_player = 1 def is_game_over(self): # 判断游戏是否结束 if self.get_winner() is not None: return True return False def get_winner(self): # 判断游戏胜负 for i in range(6): if np.sum(self.board[i]) == 6: return 1 elif np.sum(self.board[i]) == -6: return -1 for i in range(6): if np.sum(self.board[:, i]) == 6: return 1 elif np.sum(self.board[:, i]) == -6: return -1 if self.board.trace() == 6 or np.fliplr(self.board).trace() == 6: return 1 elif self.board.trace() == -6 or np.fliplr(self.board).trace() == -6: return -1 return None def evaluate(self): # 计算当前游戏状态的估价值 winner = self.get_winner() if winner is not None: return winner * np.inf else: return np.sum(self.board) def get_legal_moves(self): # 获取当前玩家的合法落子位置 moves = [] for i in range(6): for j in range(6): if self.board[i][j] == 0: moves.append((i, j)) return moves def apply_move(self, move): # 更新游戏状态 new_state = GameState() new_state.board = np.copy(self.board) new_state.current_player = -self.current_player i, j = move new_state.board[i][j] = self.current_player return new_state # 初始化博弈树 def initialize_tree(state, depth): root = Node(state, depth) root.generate_children() return root # 选择最佳落子位置 def select_move(state, depth): root = initialize_tree(state, depth) for child in root.children: minimax(child, False) #alphabeta(child, depth - 1, -np.inf, np.inf, False) # 使用α-β剪枝算法 root.alpha = max(root.alpha, child.alpha) best_child = root.get_best_child() return best_child.state.get_last_move() # 测试 state = GameState() while not state.is_game_over(): if state.current_player == 1: move = select_move(state, 3) state = state.apply_move(move) else: move = tuple(map(int, input("请输入黑方落子位置:").split())) state = state.apply_move(move) print(state.board) print("游戏结束,胜利者为", state.get_winner()) ``` 在代码中,`Node`类表示一个博弈树节点,`GameState`类表示一个六子棋游戏状态。`minimax`函数是标准的MiniMax算法,`alphabeta`函数是α-β剪枝算法。`initialize_tree`函数用于初始化博弈树,`select_move`函数用于选择最佳落子位置。在测试部分,程序先使用AI自动落子,然后等待人类玩家输入落子位置,直到游戏结束。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值