maze_python/tanxin.py

import math
from maze import *
import math
import copy
from collections import deque



class Greedy3x3ResourceCollector:
    """
    基于3x3视野的贪心资源收集器
    每次移动时选择3x3视野范围内最高价值的资源
    只能进行上下左右移动
    """

    def __init__(self, map_data, start=None, end=None):
        """
        初始化3x3视野贪心资源收集器

        Args:
            map_data: 迷宫地图，2D列表 (注意：这里是[y][x]格式)
            start: 起始位置 (x, y)，如果为None则自动寻找
            end: 目标位置 (x, y)，如果为None则自动寻找
        """
        self.original_map = copy.deepcopy(map_data)
        self.map_data = copy.deepcopy(map_data)
        self.rows = len(map_data)
        self.cols = len(map_data[0]) if self.rows > 0 else 0

        # 寻找起始位置和目标位置
        self.start = start or self._find_position('s')
        self.end = end or self._find_position('e')

        if not self.start:
            raise ValueError("无法找到起始位置 's'")
        if not self.end:
            raise ValueError("无法找到目标位置 'e'")

        self.current_pos = self.start
        self.path = [self.start]
        self.collected_resources = []
        self.total_value = 0
        self.visited_resources = set()
        self.explored_positions = set([self.start])
        
        # 增加历史移动记录和死胡同检测相关变量
        self.position_visit_count = {self.start: 1}  # 记录每个位置的访问次数
        self.deadend_positions = set()  # 记录已知的死胡同位置
        self.backtrack_points = []  # 记录可能的回溯点
        self.oscillation_detection = []  # 用于检测来回走动的历史
        self.max_oscillation_length = 6  # 检测来回走动的最大长度

        # 预处理每个点到终点的距离
        self.distance_to_end = self._calculate_distance_to_end()

        print(f"3x3视野贪心算法初始化")
        print(f"起始位置: {self.start}")
        print(f"目标位置: {self.end}")

    def _find_position(self, target):
        """寻找地图中指定字符的位置，返回(x, y)格式"""
        for y in range(self.rows):
            for x in range(self.cols):
                cell_value = str(self.map_data[y][x]).lower()
                if cell_value.startswith(target.lower()):
                    return (x, y)
        return None

    def get_3x3_vision(self, pos):
        """
        获取以pos为中心的3x3视野范围内的所有单元格

        Args:
            pos: 当前位置 (x, y)

        Returns:
            dict: {(x, y): cell_value} 形式的字典
        """
        x, y = pos
        vision = {}

        # 遍历3x3范围
        for dx in range(-1, 2):
            for dy in range(-1, 2):
                new_x, new_y = x + dx, y + dy

                # 检查边界
                if 0 <= new_x < self.cols and 0 <= new_y < self.rows:
                    vision[(new_x, new_y)] = self.map_data[new_y][new_x]

        return vision

    def get_adjacent_cells(self, pos):
        """
        获取当前位置的上下左右四个相邻位置

        Args:
            pos: 当前位置 (x, y)

        Returns:
            list: 可移动的相邻位置列表
        """
        x, y = pos
        adjacent = []

        # 上下左右四个方向
        directions = [(0, -1), (0, 1), (-1, 0), (1, 0)]  # 上、下、左、右

        for dx, dy in directions:
            new_x, new_y = x + dx, y + dy

            # 检查边界和可移动性
            if (0 <= new_x < self.cols and
                0 <= new_y < self.rows and
                self.can_move_to((new_x, new_y))):
                adjacent.append((new_x, new_y))

        return adjacent

    def can_move_to(self, pos):
        """
        检查是否可以移动到指定位置

        Args:
            pos: 目标位置 (x, y)

        Returns:
            bool: 是否可以移动
        """
        x, y = pos
        cell = self.map_data[y][x]

        # 不能移动到墙壁
        if cell == '1':
            return False

        return True

    def evaluate_resource_value(self, cell):
        """
        评估资源的价值

        Args:
            cell: 单元格内容

        Returns:
            int: 资源价值，正数表示收益，负数表示损失
        """
        if cell.startswith('g'):
            # 金币资源，提取数值
            try:
                return int(cell[1:])
            except ValueError:
                return 0
        elif cell.startswith('t'):
            # 陷阱资源，提取数值并取负
            try:
                return -int(cell[1:])
            except ValueError:
                return 0
        else:
            # 其他类型单元格没有资源价值
            return 0

    def find_best_resource_in_3x3_vision(self):
        """
        在3x3视野内寻找最佳资源，新的优先级顺序：
        1. 金币（优先直接相邻，也考虑对角线上可通过两步到达的）
        2. 空地（优先离终点更近的）
        3. boss或机关
        4. 陷阱（尽可能减少损失）
        5. 墙壁不考虑
        
        加入死胡同检测和回溯机制
        """
        x, y = self.current_pos
        
        # 更新当前位置的访问次数
        self.position_visit_count[self.current_pos] = self.position_visit_count.get(self.current_pos, 0) + 1
        
        # 检查是否处于死胡同中
        if self.is_deadend(self.current_pos):
            self.deadend_positions.add(self.current_pos)
            # 寻找回溯点
            backtrack_point = self.find_backtrack_point()
            if backtrack_point != self.current_pos:
                # 将当前位置到回溯点的路径添加到路径计划中
                self.backtrack_points.append(backtrack_point)
                print(f"检测到死胡同，计划回溯到: {backtrack_point}")
                # 如果回溯点是相邻的，直接返回
                if abs(backtrack_point[0] - x) + abs(backtrack_point[1] - y) == 1:
                    return backtrack_point, 0  # 回溯点，价值为0
        
        # 如果有待回溯的点，优先选择那个方向
        if self.backtrack_points:
            target = self.backtrack_points[-1]
            # 计算到回溯点的方向
            for dx, dy in [(0, 1), (1, 0), (0, -1), (-1, 0)]:
                nx, ny = x + dx, y + dy
                if (nx, ny) == target:
                    return (nx, ny), 0  # 回溯点，价值为0
                
                # 如果相邻点在路径上且朝向回溯点方向，也可以选择
                if (0 <= nx < self.cols and 0 <= ny < self.rows and 
                    self.map_data[ny][nx] != '1'):  # 使用'1'表示墙壁
                    if ((nx > x and target[0] > x) or 
                        (nx < x and target[0] < x) or 
                        (ny > y and target[1] > y) or 
                        (ny < y and target[1] < y)):
                        return (nx, ny), 0  # 朝向回溯点的方向，价值为0
            
            # 如果已经到达回溯点或无法向回溯点移动，弹出这个回溯点
            if self.current_pos == self.backtrack_points[-1]:
                self.backtrack_points.pop()
        
        # 检测是否陷入来回走动的循环
        if len(self.path) >= 2:
            self.oscillation_detection.append(self.current_pos)
            if len(self.oscillation_detection) > self.max_oscillation_length:
                self.oscillation_detection.pop(0)
            
            if self.detect_oscillation():
                print("检测到来回走动，尝试打破循环")
                # 清空回溯点列表，寻找新的探索方向
                self.backtrack_points = []
                # 尝试找到访问次数最少的相邻位置
                min_visits = float('inf')
                least_visited = None
                
                for dx, dy in [(0, 1), (1, 0), (0, -1), (-1, 0)]:
                    nx, ny = x + dx, y + dy
                    if (0 <= nx < self.cols and 0 <= ny < self.rows and 
                        self.map_data[ny][nx] != '1'):  # 使用'1'表示墙壁
                        visits = self.position_visit_count.get((nx, ny), 0)
                        if visits < min_visits:
                            min_visits = visits
                            least_visited = (nx, ny)
                
                if least_visited:
                    return least_visited, 0  # 访问次数最少的位置，价值为0
        
        # 按照新的优先级在3x3视野内寻找最佳位置
        # 1. 收集相邻和对角线上的所有单元格
        adjacent_cells = []  # 相邻的单元格 [(pos, cell_type, value)]
        diagonal_cells = []  # 对角线上的单元格 [(pos, cell_type, value, can_reach)]
        
        for i in range(-1, 2):
            for j in range(-1, 2):
                nx, ny = x + i, y + j
                
                # 检查位置是否在地图范围内
                if 0 <= nx < self.cols and 0 <= ny < self.rows:
                    pos = (nx, ny)
                    cell = self.map_data[ny][nx]
                    
                    # 检查是否是墙，不能走
                    if cell == '1':
                        continue
                        
                    # 计算资源价值
                    value = self.evaluate_resource_value(cell)
                    cell_type = self._get_cell_type(cell)
                    
                    # 相邻位置（上下左右）
                    if i == 0 or j == 0:
                        if i != 0 or j != 0:  # 排除自身位置
                            adjacent_cells.append((pos, cell_type, value))
                    # 对角线位置
                    else:
                        # 判断是否可以两步到达
                        can_reach = self._can_reach_diagonal_coin(self.current_pos, pos)
                        diagonal_cells.append((pos, cell_type, value, can_reach))
        
        # 2. 优先级1：查找相邻的金币
        adjacent_coins = [(pos, value) for pos, cell_type, value in adjacent_cells
                          if cell_type == 'gold' and value > 0]
        
        if adjacent_coins:
            # 如果有多个金币，选择价值最高的
            best_coin = max(adjacent_coins, key=lambda x: x[1])
            return best_coin
        
        # 3. 优先级2：查找可达的对角线上的金币
        diagonal_coins = [(pos, value) for pos, cell_type, value, can_reach in diagonal_cells
                          if cell_type == 'gold' and value > 0 and can_reach]
        
        if diagonal_coins:
            # 如果有多个可达的对角线金币，选择价值最高的
            best_diag_coin = max(diagonal_coins, key=lambda x: x[1])
            # 计算到达这个对角线金币的两步路径中的第一步
            dx, dy = best_diag_coin[0]
            step_x = 1 if dx > x else -1
            step_y = 1 if dy > y else -1
            
            # 检查两种可能路径的第一步
            path1_pos = (x + step_x, y)
            path2_pos = (x, y + step_y)
            
            # 选择离终点更近的路径
            dist1 = self.distance_to_end.get(path1_pos, float('inf'))
            dist2 = self.distance_to_end.get(path2_pos, float('inf'))
            
            if dist1 <= dist2 and self.can_move_to(path1_pos):
                return path1_pos, 0
            elif self.can_move_to(path2_pos):
                return path2_pos, 0
        
        # 4. 优先级3：查找空地，优先选择离终点更近的
        empty_spaces = [(pos, self.distance_to_end.get(pos, float('inf'))) 
                       for pos, cell_type, _ in adjacent_cells
                       if cell_type == 'empty']
        
        if empty_spaces:
            # 选择离终点最近的空地
            best_empty = min(empty_spaces, key=lambda x: x[1])
            return best_empty[0], 0
        
        # 5. 优先级4：boss或机关
        mechanism_positions = [(pos, value) for pos, cell_type, value in adjacent_cells
                              if cell_type in ['boss', 'mechanism']]
        
        if mechanism_positions:
            # 选择任意一个boss或机关位置
            return mechanism_positions[0][0], mechanism_positions[0][1]
        
        # 6. 优先级5：陷阱，尽可能减少损失
        trap_positions = [(pos, value) for pos, cell_type, value in adjacent_cells
                         if cell_type == 'trap']
        
        if trap_positions:
            # 选择损失最小的陷阱（value是负数，所以用max）
            best_trap = max(trap_positions, key=lambda x: x[1])
            return best_trap
        
        # 如果找不到合适的位置，就选择任意一个可行的相邻位置
        for dx, dy in [(0, 1), (1, 0), (0, -1), (-1, 0)]:
            nx, ny = x + dx, y + dy
            if (0 <= nx < self.cols and 0 <= ny < self.rows and 
                self.map_data[ny][nx] != '1'):  # 使用'1'表示墙壁
                return (nx, ny), 0
        
        # 如果实在没有可行位置，返回None
        return None, 0
        
    def _get_cell_type(self, cell):
        """
        获取单元格类型
        
        Args:
            cell: 单元格内容
            
        Returns:
            str: 'gold', 'trap', 'boss', 'mechanism', 'empty', 'wall', 'start', 'end'
        """
        if cell.startswith('g'):
            return 'gold'
        elif cell.startswith('t'):
            return 'trap'
        elif cell.startswith('b'):
            return 'boss'
        elif cell.startswith('l'):
            return 'mechanism'
        elif cell == 's':
            return 'start'
        elif cell == 'e':
            return 'end'
        elif cell == '1':
            return 'wall'
        else:
            return 'empty'  # 包括 '0' 和其他可通行的单元格

    def find_exploration_target(self):
        """
        当视野内没有资源时，寻找探索目标
        严格按照优先级：未走过的路 > 走过的路（很久之前走过的优先）
        """
        adjacent = self.get_adjacent_cells(self.current_pos)
        
        # 1. 优先级1：未走过的路
        unexplored = [pos for pos in adjacent if pos not in self.explored_positions]
        if unexplored:
            return unexplored[0]  # 选择第一个未探索的位置
        
        # 2. 优先级2：走过的路，按时间排序（很久之前走过的优先）
        explored = []
        for pos in adjacent:
            if pos in self.explored_positions:
                # 找出这个位置在路径中最早出现的索引
                if pos in self.path:
                    earliest_index = self.path.index(pos)
                    explored.append((pos, earliest_index))
                else:
                    # 如果在explored_positions但不在path中，可能是通过其他方式标记的
                    # 给它一个很大的索引，表示是最近才探索的
                    explored.append((pos, float('inf')))
        
        if explored:
            # 按照索引排序，索引越小表示越早走过
            explored.sort(key=lambda x: x[1])
            return explored[0][0]
        
        return None

    def collect_resource(self, pos):
        """
        收集指定位置的资源

        Args:
            pos: 资源位置 (x, y)
        """
        x, y = pos
        cell = self.map_data[y][x]
        value = self.evaluate_resource_value(cell)

        if value != 0:
            self.collected_resources.append({
                'position': pos,
                'type': cell,
                'value': value
            })
            self.total_value += value
            self.visited_resources.add(pos)

            print(f"收集资源: 位置{pos}, 类型{cell}, 价值{value}, 总价值{self.total_value}")

    def run_3x3_greedy_collection(self, max_moves=1000):
        """
        运行3x3视野贪心资源收集算法
        严格按照优先级：金币 > 未走过的路 > 走过的路 > 墙/陷阱
        对于走过的路，优先走很久之前走过的路

        Args:
            max_moves: 最大移动步数，防止无限循环

        Returns:
            dict: 包含路径、收集的资源等信息
        """
        print("\\n开始3x3视野贪心资源收集...")

        moves = 0
        stuck_count = 0  # 连续无法找到资源的次数
        max_stuck = 20   # 最大连续无资源次数

        while moves < max_moves and stuck_count < max_stuck:
            moves += 1

            # 在3x3视野内寻找最佳位置（按照严格优先级）
            best_pos, best_value = self.find_best_resource_in_3x3_vision()

            if best_pos is not None:
                # 移动到选定位置
                self.current_pos = best_pos
                self.path.append(best_pos)
                self.explored_positions.add(best_pos)
                
                # 如果是资源位置，进行收集
                if best_value != 0:
                    print(f"第{moves}步: 发现视野内金币 位置{best_pos}, 价值{best_value}")
                    self.collect_resource(best_pos)
                    stuck_count = 0  # 收集到资源后重置无资源计数
                else:
                    # 是普通路径
                    if best_pos not in self.explored_positions:
                        print(f"第{moves}步: 移动到未走过的路 位置{best_pos}")
                    else:
                        print(f"第{moves}步: 移动到走过的路 位置{best_pos}")
                    stuck_count += 1
            else:
                # 没有可移动位置，结束收集
                print(f"第{moves}步: 无法进行任何移动，结束收集")
                break

            # 检查是否达到终点
            if self.current_pos == self.end:
                print(f"第{moves}步: 到达终点！")
                break

        if moves >= max_moves:
            print(f"达到最大移动步数 {max_moves}，结束收集")
        elif stuck_count >= max_stuck:
            print(f"连续 {max_stuck} 步未找到资源，结束收集")

        print("3x3视野资源收集完成！")
        print(f"总步数: {len(self.path)-1}, 收集资源数: {len(self.collected_resources)}, 资源总价值: {self.total_value}")
        return self.get_collection_result()

    def get_collection_result(self):
        """获取收集结果"""
        return {
            'path': self.path.copy(),
            'collected_resources': self.collected_resources.copy(),
            'total_value': self.total_value,
            'total_moves': len(self.path) - 1,
            'resources_count': len(self.collected_resources),
            'start_pos': self.start,
            'end_pos': self.end,
            'final_pos': self.current_pos,
            'explored_positions': len(self.explored_positions)
        }

    def reset(self):
        """重置收集器状态"""
        self.map_data = copy.deepcopy(self.original_map)
        self.current_pos = self.start
        self.path = [self.start]
        self.collected_resources = []
        self.total_value = 0
        self.visited_resources = set()
        self.explored_positions = set([self.start])
        self.position_visit_count = {self.start: 1}
        self.deadend_positions = set()
        self.backtrack_points = []
        self.oscillation_detection = []

    def get_path(self):
        """
        获取完整的资源收集路径
        返回：路径列表，格式为 [(x1, y1), (x2, y2), ...]
        """
        # 先重置状态
        self.reset()
        
        max_steps = self.rows * self.cols * 3  # 设置最大步数限制，避免无限循环
        steps = 0
        reached_goal = False
        
        while steps < max_steps and not reached_goal:
            _, _, reached_goal = self.next_step()
            steps += 1
            
            # 如果路径长度已经很长但还没到达目标，可能是在循环
            if steps > self.rows * self.cols * 2:
                print(f"警告：路径过长 ({steps} 步)，可能存在循环。提前结束。")
                break
        
        if reached_goal:
            print(f"找到路径！总步数: {steps}, 总收集价值: {self.total_value}")
        else:
            print(f"未能找到到达目标的路径，已走 {steps} 步，总收集价值: {self.total_value}")
            
        print(f"发现的死胡同数量: {len(self.deadend_positions)}")
        
        return self.path

    def next_step(self):
        """
        执行下一步移动
        返回：(新位置, 收集的资源价值, 是否到达目标)
        """
        if self.current_pos == self.end:
            return self.current_pos, 0, True
            
        next_pos, value = self.find_best_resource_in_3x3_vision()
        if next_pos is None:
            # 如果找不到下一步，说明卡住了，可能是迷宫设计问题
            print("找不到下一步移动，可能被卡住了")
            return self.current_pos, 0, False
            
        # 记录新位置和路径
        self.current_pos = next_pos
        self.path.append(next_pos)
        self.explored_positions.add(next_pos)
        
        # 更新位置访问计数
        self.position_visit_count[next_pos] = self.position_visit_count.get(next_pos, 0) + 1
        
        # 如果当前位置是回溯点且有多个回溯点，移除当前回溯点
        if self.backtrack_points and next_pos == self.backtrack_points[-1]:
            self.backtrack_points.pop()
            
        # 收集资源
        x, y = next_pos
        cell = self.map_data[y][x]
        value = self.evaluate_resource_value(cell)
        
        if value > 0 and next_pos not in self.visited_resources:
            self.collected_resources.append((next_pos, value))
            self.visited_resources.add(next_pos)
            self.total_value += value
            # 标记资源已被收集，避免重复计算
            if cell.startswith('g') or cell.startswith('c'):
                try:
                    self.map_data[y][x] = 'v'  # 将收集过的资源标记为已访问
                except:
                    pass
        
        # 检查是否到达目标
        reached_goal = (next_pos == self.end)
        
        # 调试信息
        if len(self.path) % 10 == 0:
            print(f"当前路径长度: {len(self.path)}, 总收集价值: {self.total_value}")
            print(f"已发现的死胡同数量: {len(self.deadend_positions)}")
            
        return next_pos, value, reached_goal

    def is_deadend(self, pos):
        """
        判断当前位置是否是死胡同
        死胡同的定义：除了来路外，周围全是墙/陷阱/已走过的路
        """
        x, y = pos
        valid_directions = 0
        
        for dx, dy in [(0, 1), (1, 0), (0, -1), (-1, 0)]:
            nx, ny = x + dx, y + dy
            if (0 <= nx < self.cols and 0 <= ny < self.rows and 
                self.map_data[ny][nx] != '1' and  # 使用'1'表示墙壁
                (nx, ny) not in self.explored_positions):
                valid_directions += 1
                
        # 如果没有未探索的方向，则是死胡同
        return valid_directions == 0
    
    def find_backtrack_point(self):
        """
        寻找回溯点，即从路径中找到最近的有未探索方向的点
        """
        # 从最近访问到最早访问的路径点遍历
        for pos in reversed(self.path):
            x, y = pos
            
            # 检查这个点的四个方向是否有未探索的路
            for dx, dy in [(0, 1), (1, 0), (0, -1), (-1, 0)]:
                nx, ny = x + dx, y + dy
                if (0 <= nx < self.cols and 0 <= ny < self.rows and 
                    self.map_data[ny][nx] != '1' and  # 使用'1'表示墙壁
                    (nx, ny) not in self.explored_positions):
                    return pos
                    
        # 如果找不到回溯点，则返回起始点
        return self.start
        
    def detect_oscillation(self):
        """
        检测路径中是否有来回走动的情况
        """
        if len(self.oscillation_detection) < self.max_oscillation_length:
            return False
        
        # 检查最近的移动是否形成循环
        recent_moves = self.oscillation_detection[-self.max_oscillation_length:]
        
        # 打印调试信息
        print(f"检查振荡: {recent_moves[-6:]}")
        
        # 检查是否有重复位置模式 (例如A-B-A-B或A-B-C-A-B-C)
        for pattern_length in range(2, self.max_oscillation_length // 2 + 1):
            if recent_moves[-pattern_length:] == recent_moves[-2*pattern_length:-pattern_length]:
                print(f"检测到振荡！模式长度: {pattern_length}")
                return True
                
        # 更简单的检测：检查是否在有限步数内多次访问同一位置
        position_counts = {}
        for pos in recent_moves:
            if pos in position_counts:
                position_counts[pos] += 1
                if position_counts[pos] >= 3:  # 在短时间内访问同一位置3次以上
                    print(f"检测到位置 {pos} 被频繁访问 {position_counts[pos]} 次")
                    return True
            else:
                position_counts[pos] = 1
        
        return False
        
    def calculate_exploration_potential(self, pos):
        """
        计算位置的探索潜力值
        潜力值基于：
        1. 周围未探索的方向数
        2. 到达过这个位置的次数（次数越多潜力越低）
        3. 是否含有资源
        """
        x, y = pos
        potential = 0
        
        # 检查周围四个方向是否有未探索的路
        for dx, dy in [(0, 1), (1, 0), (0, -1), (-1, 0)]:
            nx, ny = x + dx, y + dy
            if (0 <= nx < self.cols and 0 <= ny < self.rows):
                # 未探索的路增加潜力
                if (nx, ny) not in self.explored_positions and self.map_data[ny][nx] != '1':
                    potential += 10
                    
                # 有资源的路增加更多潜力
                cell = self.map_data[ny][nx]
                if cell.startswith('g'):
                    try:
                        value = int(cell[1:])
                        potential += value * 2
                    except ValueError:
                        potential += 5  # 如果无法解析值，则默认增加5点潜力
        
        # 访问次数越多，潜力越低
        visit_penalty = self.position_visit_count.get(pos, 0) * 5
        potential = max(0, potential - visit_penalty)
        
        return potential

    def _calculate_distance_to_end(self):
        """
        使用BFS预处理计算每个点到终点的距离
        返回字典 {(x, y): distance}
        """
        distances = {}
        queue = deque([(self.end, 0)])  # (位置, 距离)
        visited = {self.end}
        
        # 方向：上、下、左、右
        directions = [(0, -1), (0, 1), (-1, 0), (1, 0)]
        
        while queue:
            (x, y), dist = queue.popleft()
            distances[(x, y)] = dist
            
            # 检查四个方向
            for dx, dy in directions:
                nx, ny = x + dx, y + dy
                
                # 检查边界和可行性
                if (0 <= nx < self.cols and 
                    0 <= ny < self.rows and 
                    self.map_data[ny][nx] != '1' and  # 不是墙
                    (nx, ny) not in visited):
                    
                    visited.add((nx, ny))
                    queue.append(((nx, ny), dist + 1))
        
        print(f"已预处理完成从终点的距离计算，可达点数量: {len(distances)}")
        return distances

    def _can_reach_diagonal_coin(self, current_pos, diagonal_pos):
        """
        检查对角线上的金币是否可通过两步到达
        
        Args:
            current_pos: 当前位置 (x, y)
            diagonal_pos: 对角线上的金币位置 (x, y)
            
        Returns:
            bool: 是否可以通过两步到达
        """
        cx, cy = current_pos
        dx, dy = diagonal_pos
        
        # 计算方向
        step_x = 1 if dx > cx else -1
        step_y = 1 if dy > cy else -1
        
        # 检查两种可能的两步路径
        path1 = [(cx + step_x, cy), diagonal_pos]  # 先横后纵
        path2 = [(cx, cy + step_y), diagonal_pos]  # 先纵后横
        
        # 检查路径1是否可行
        path1_valid = True
        for x, y in path1:
            if not (0 <= x < self.cols and 0 <= y < self.rows and self.map_data[y][x] != '1'):
                path1_valid = False
                break
                
        # 检查路径2是否可行
        path2_valid = True
        for x, y in path2:
            if not (0 <= x < self.cols and 0 <= y < self.rows and self.map_data[y][x] != '1'):
                path2_valid = False
                break
                
        return path1_valid or path2_valid

    def add_path_to_map(self):
        """
        将路径标记到地图上
        
        Returns:
            list: 标记了路径的地图
        """
        marked_map = copy.deepcopy(self.original_map)
        
        # 标记起点和终点
        sx, sy = self.start
        ex, ey = self.end
        marked_map[sy][sx] = 'S'
        marked_map[ey][ex] = 'E'
        
        # 标记路径
        for i, (x, y) in enumerate(self.path):
            # 跳过起点和终点
            if (x, y) == self.start or (x, y) == self.end:
                continue
            
            # 检查是否是资源位置
            cell = self.original_map[y][x]
            if (x, y) in self.visited_resources:
                marked_map[y][x] = '*'  # 已收集资源
            else:
                # 只有不是特殊位置才标记为路径
                if not (cell.startswith('g') or cell.startswith('t') or 
                        cell.startswith('b') or cell.startswith('l')):
                    marked_map[y][x] = '.'  # 路径
        
        return marked_map


    """
    传统的贪心路径寻找算法
    """
    
class GreedyPlayer:
    """
    传统贪心路径寻找算法
    """
    
    def __init__(self, map_data):
        """
        初始化贪心玩家
        
        Args:
            map_data: 迷宫地图，2D列表 (注意：这里是[y][x]格式)
        """
        self.map_data = copy.deepcopy(map_data)
        self.rows = len(map_data)
        self.cols = len(map_data[0]) if self.rows > 0 else 0
        
        # 寻找起点和终点
        self.start = None
        self.end = None
        for y in range(self.rows):
            for x in range(self.cols):
                cell_value = str(self.map_data[y][x]).lower()
                if cell_value.startswith('s'):
                    self.start = (x, y)
                elif cell_value.startswith('e'):
                    self.end = (x, y)
        
        if not self.start or not self.end:
            raise ValueError("无法找到起点或终点")
            
        self.path = []
        self.marked_map = copy.deepcopy(map_data)
        self.total_reward = 0
    
    def find_path(self):
        """
        使用传统贪心算法寻找路径
        """
        current = self.start
        self.path = [current]
        visited = set([current])
        
        while current != self.end:
            x, y = current
            best_move = None
            best_value = float('-inf')
            
            # 检查四个方向
            for dx, dy in [(0, 1), (1, 0), (0, -1), (-1, 0)]:
                nx, ny = x + dx, y + dy
                
                if (0 <= nx < self.cols and 0 <= ny < self.rows and 
                    str(self.map_data[ny][nx]) != '1' and
                    (nx, ny) not in visited):
                    
                    # 计算移动价值
                    cell = str(self.map_data[ny][nx])
                    value = 0
                    
                    # 终点最高价值
                    if cell.lower().startswith('e'):
                        value = float('inf')
                    # 金币为正价值
                    elif cell.lower().startswith('g'):
                        try:
                            value = int(cell[1:])
                        except ValueError:
                            value = 1
                    # 陷阱为负价值
                    elif cell.lower().startswith('t'):
                        try:
                            value = -int(cell[1:])
                        except ValueError:
                            value = -1
                    
                    if value > best_value:
                        best_value = value
                        best_move = (nx, ny)
            
            if best_move:
                # 更新当前位置
                current = best_move
                self.path.append(current)
                visited.add(current)
                
                # 收集资源
                x, y = current
                cell = str(self.map_data[y][x])
                if cell.lower().startswith('g'):
                    try:
                        self.total_reward += int(cell[1:])
                    except ValueError:
                        self.total_reward += 1
                elif cell.lower().startswith('t'):
                    try:
                        self.total_reward -= int(cell[1:])
                    except ValueError:
                        self.total_reward -= 1
                
                # 标记路径
                if not cell.lower().startswith('e'):
                    self.marked_map[y][x] = '.'
            else:
                # 无法继续移动
                break
                
        return self.path
    
    def get_total_reward(self):
        """
        获取收集到的总奖励
        """
        return self.total_reward

# 使用示例
def main():
    obj = MazeGenerator(20,'demo.csv',name="龙脊峡谷迷宫")
    obj.generate(
        seed=123,
        boss_count=2,
        traps_range=(5, 10),
        mechanisms_range=(3, 7),
        skill_traps=8
      )
    obj.export_to_csv()

    map_data = obj.read_csv()
    see = MazeGenerator(1,filename ='demo.csv')
    see.read_from_csv()
    print("=== 原始迷宫 ===")
    see.print_maze()
    
    print("\\n" + "="*60)
    print("使用传统贪心算法:")
    print("="*60)
    player = GreedyPlayer(map_data)
    player.find_path()
    see.maze = player.marked_map
    see.print_maze()
    print(f"传统贪心算法总收益: {player.get_total_reward()}")
    
    print("\\n" + "="*60)
    print("使用3x3视野贪心算法:")
    print("="*60)
    # 使用新的3x3视野算法
    greedy_3x3 = Greedy3x3ResourceCollector(map_data)
    result = greedy_3x3.run_3x3_greedy_collection()
    
    # 显示结果
    see.maze = greedy_3x3.add_path_to_map()
    see.print_maze()
    
    print(f"\\n3x3视野算法结果:")
    print(f"  总移动步数: {result['total_moves']}")
    print(f"  收集资源数量: {result['resources_count']}")
    print(f"  资源总价值: {result['total_value']}")
    print(f"  探索位置数: {result['explored_positions']}")
    
    print("\\n收集的资源详情:")
    for i, resource in enumerate(result['collected_resources'], 1):
        print(f"  {i}. 位置{resource['position']}: {resource['type']} (价值: {resource['value']})")


def demo_3x3_greedy():
    """演示3x3视野贪心算法"""
    
    # 创建一个示例迷宫
    demo_maze = [
        ['s', '0', 'g5', '1', 't3'],
        ['0', '1', '0', '0', 'g2'],
        ['g3', '0', '1', 't2', '0'],
        ['0', 't1', '0', '0', 'g4'],
        ['1', '0', 'g1', '0', 'e']
    ]
    
    print("=== 3x3视野贪心算法演示 ===")
    print("迷宫说明:")
    print("  s: 起点, e: 终点")
    print("  g数字: 金币资源 (正收益)")
    print("  t数字: 陷阱资源 (负收益)")
    print("  0: 可通行路径, 1: 墙壁")
    print("\\n原始迷宫:")
    for row in demo_maze:
        print(' '.join(f"{cell:>2}" for cell in row))
    
    # 使用3x3视野贪心算法
    collector = Greedy3x3ResourceCollector(demo_maze)
    result = collector.run_3x3_greedy_collection()
    
    # 显示标记后的迷宫
    marked_maze = collector.add_path_to_map()
    print("\\n标记路径后的迷宫:")
    print("S: 起点, E: 终点, *: 已收集资源, .: 路径")
    for row in marked_maze:
        print(' '.join(f"{cell:>2}" for cell in row))
    
    print(f"\\n算法结果:")
    print(f"  总移动步数: {result['total_moves']}")
    print(f"  收集资源数量: {result['resources_count']}")
    print(f"  资源总价值: {result['total_value']}")
    
    return collector, result




if __name__ == "__main__":
    # 运行演示
    print("选择运行模式:")
    print("1. 完整迷宫生成和算法比较")
    print("2. 简单3x3视野算法演示")
    
    choice = input("请输入选择 (1 或 2，默认为 2): ").strip()
    
    if choice == "1":
        main()
    else:
        demo_3x3_greedy()