学生作品展示

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
聊天机器人核心逻辑
作者: 赵小燕
"""

import random
import json
from utils import preprocess_text, match_pattern

class ChatBot:
    def __init__(self):
        # 加载聊天规则和回复
        self.load_knowledge_base()
        
        # 初始化对话历史
        self.conversation_history = []
        
    def load_knowledge_base(self):
        """加载知识库"""
        try:
            with open('data/knowledge_base.json', 'r', encoding='utf-8') as f:
                self.knowledge_base = json.load(f)
        except FileNotFoundError:
            # 使用默认知识库
            self.knowledge_base = {
                "greetings": {
                    "patterns": ["你好", "嗨", "在吗", "您好", "hi", "hello"],
                    "responses": [
                        "你好！很高兴和你聊天。",
                        "嗨！有什么我能帮助你的吗？",
                        "你好呀！今天过得怎么样？"
                    ]
                },
                "farewells": {
                    "patterns": ["再见", "拜拜", "下次见", "goodbye", "bye"],
                    "responses": [
                        "再见！希望很快能再次和你聊天。",
                        "拜拜！祝你有美好的一天。",
                        "下次见！"
                    ]
                },
                "thanks": {
                    "patterns": ["谢谢", "感谢", "多谢", "thank"],
                    "responses": [
                        "不客气！",
                        "很高兴能帮到你！",
                        "随时为你服务！"
                    ]
                },
                "fallback": {
                    "responses": [
                        "抱歉，我不太明白你的意思。",
                        "能换个说法吗？我没有理解。",
                        "这个问题有点复杂，我需要学习更多。"
                    ]
                }
            }
    
    def get_response(self, message):
        """根据用户输入生成回复"""
        # 预处理用户输入
        processed_input = preprocess_text(message)
        
        # 记录对话历史
        self.conversation_history.append({"user": message})
        
        # 寻找匹配的规则
        for intent, data in self.knowledge_base.items():
            if intent == "fallback":
                continue
                
            if "patterns" in data:
                for pattern in data["patterns"]:
                    if match_pattern(processed_input, pattern):
                        # 随机选择一个回复
                        response = random.choice(data["responses"])
                        self.conversation_history.append({"bot": response})
                        return response
        
        # 没有找到匹配的规则，使用默认回复
        fallback_response = random.choice(self.knowledge_base["fallback"]["responses"])
        self.conversation_history.append({"bot": fallback_response})
        return fallback_response

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
聊天机器人工具函数
作者: 赵小燕
"""

import re
import jieba

def preprocess_text(text):
    """
    预处理文本，包括分词、去除标点符号等
    """
    # 转为小写
    text = text.lower()
    
    # 去除标点符号
    text = re.sub(r'[^\w\s]', '', text)
    
    # 中文分词
    if any('\u4e00' <= char <= '\u9fff' for char in text):
        words = jieba.cut(text)
        text = ' '.join(words)
    
    return text.strip()

def match_pattern(text, pattern):
    """
    检查文本是否匹配模式
    简单实现，实际应用中可以使用更复杂的匹配算法
    """
    pattern = pattern.lower()
    
    # 直接包含匹配
    if pattern in text:
        return True
    
    # 分词匹配（简单实现）
    text_words = set(text.split())
    pattern_words = set(pattern.split())
    
    # 如果文本包含模式中的所有词，视为匹配
    return pattern_words.issubset(text_words)

/**
 * 迷宫类实现
 * 作者：刘小杰
 * 日期：2023-11-15
 */

#include <iostream>
#include <iomanip>
#include <vector>
#include <random>
#include <stack>
#include "maze.h"

using namespace std;

Maze::Maze(int rows, int cols) : rows(rows), cols(cols) {
    // 初始化迷宫网格
    grid.resize(rows, vector<CellType>(cols, CellType::WALL));
    
    // 设置起点和终点
    startRow = 1;
    startCol = 1;
    endRow = rows - 2;
    endCol = cols - 2;
}

void Maze::generateRandomMaze() {
    // 将所有单元格初始化为墙
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            grid[i][j] = CellType::WALL;
        }
    }
    
    // 使用深度优先搜索生成迷宫
    generateMazeDFS(1, 1);
    
    // 设置起点和终点
    grid[startRow][startCol] = CellType::START;
    grid[endRow][endCol] = CellType::END;
}

void Maze::generateMazeDFS(int row, int col) {
    // 标记当前单元格为路径
    grid[row][col] = CellType::PATH;
    
    // 定义四个方向：上、右、下、左
    int dirs[4][2] = {{-2, 0}, {0, 2}, {2, 0}, {0, -2}};
    
    // 随机排列方向
    vector<int> order = {0, 1, 2, 3};
    random_device rd;
    mt19937 g(rd());
    shuffle(order.begin(), order.end(), g);
    
    // 尝试每个方向
    for (int i : order) {
        int newRow = row + dirs[i][0];
        int newCol = col + dirs[i][1];
        
        // 检查新位置是否在网格内且为墙
        if (newRow > 0 && newRow < rows - 1 && newCol > 0 && newCol < cols - 1 && 
            grid[newRow][newCol] == CellType::WALL) {
            
            // 打通墙壁
            grid[row + dirs[i][0]/2][col + dirs[i][1]/2] = CellType::PATH;
            
            // 递归处理下一个单元格
            generateMazeDFS(newRow, newCol);
        }
    }
}

void Maze::display() const {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            switch (grid[i][j]) {
                case CellType::WALL:
                    cout << "██";
                    break;
                case CellType::PATH:
                    cout << "  ";
                    break;
                case CellType::START:
                    cout << "S ";
                    break;
                case CellType::END:
                    cout << "E ";
                    break;
                case CellType::VISITED:
                    cout << ". ";
                    break;
                case CellType::SOLUTION:
                    cout << "* ";
                    break;
            }
        }
        cout << endl;
    }
}

bool Maze::isValidMove(int row, int col) const {
    // 检查位置是否在迷宫范围内
    if (row < 0 || row >= rows || col < 0 || col >= cols) {
        return false;
    }
    
    // 检查位置是否为墙
    return grid[row][col] != CellType::WALL;
}

void Maze::markVisited(int row, int col) {
    if (grid[row][col] != CellType::START && grid[row][col] != CellType::END) {
        grid[row][col] = CellType::VISITED;
    }
}

void Maze::markSolution(int row, int col) {
    if (grid[row][col] != CellType::START && grid[row][col] != CellType::END) {
        grid[row][col] = CellType::SOLUTION;
    }
}

void Maze::reset() {
    // 重置访问和解决路径标记
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            if (grid[i][j] == CellType::VISITED || grid[i][j] == CellType::SOLUTION) {
                grid[i][j] = CellType::PATH;
            }
        }
    }
}

/**
 * 路径寻找器实现
 * 作者：刘小杰
 * 日期：2023-11-15
 */

#include <iostream>
#include <queue>
#include <stack>
#include <vector>
#include <chrono>
#include <thread>
#include <functional>
#include <cmath>
#include "maze.h"
#include "pathfinder.h"

PathFinder::PathFinder(Maze* maze) : maze(maze) {}

void PathFinder::findPath(Algorithm algorithm, bool visualize) {
    // 重置迷宫
    maze->reset();
    
    bool success = false;
    
    switch (algorithm) {
        case Algorithm::DFS:
            success = findPathDFS(visualize);
            break;
        case Algorithm::BFS:
            success = findPathBFS(visualize);
            break;
        case Algorithm::ASTAR:
            success = findPathAStar(visualize);
            break;
    }
    
    if (success) {
        std::cout << "找到路径！\n";
    } else {
        std::cout << "无法找到路径！\n";
    }
}

bool PathFinder::findPathDFS(bool visualize) {
    // 获取起点和终点
    int startRow = maze->getStartRow();
    int startCol = maze->getStartCol();
    int endRow = maze->getEndRow();
    int endCol = maze->getEndCol();
    
    // 定义四个方向：上、右、下、左
    const int dirs[4][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
    
    // 用于回溯路径的前驱节点记录
    std::vector<std::vector<std::pair<int, int>>> predecessor(
        maze->getRows(), 
        std::vector<std::pair<int, int>>(maze->getCols(), {-1, -1})
    );
    
    // 使用栈进行DFS
    std::stack<std::pair<int, int>> stack;
    stack.push({startRow, startCol});
    
    while (!stack.empty()) {
        // 获取当前位置
        auto [currentRow, currentCol] = stack.top();
        stack.pop();
        
        // 如果到达终点
        if (currentRow == endRow && currentCol == endCol) {
            // 回溯并标记解决路径
            int row = currentRow, col = currentCol;
            while (row != startRow || col != startCol) {
                maze->markSolution(row, col);
                auto [prevRow, prevCol] = predecessor[row][col];
                row = prevRow;
                col = prevCol;
                
                if (visualize) {
                    maze->display();
                    std::this_thread::sleep_for(std::chrono::milliseconds(50));
                }
            }
            
            return true;
        }
        
        // 标记当前位置为已访问
        maze->markVisited(currentRow, currentCol);
        
        // 显示当前搜索状态
        if (visualize) {
            maze->display();
            std::this_thread::sleep_for(std::chrono::milliseconds(50));
        }
        
        // 尝试四个方向
        for (int i = 0; i < 4; i++) {
            int newRow = currentRow + dirs[i][0];
            int newCol = currentCol + dirs[i][1];
            
            // 检查是否是有效移动并且没有访问过
            if (maze->isValidMove(newRow, newCol) && 
                predecessor[newRow][newCol].first == -1) {
                
                // 记录前驱节点
                predecessor[newRow][newCol] = {currentRow, currentCol};
                
                // 将新位置加入栈
                stack.push({newRow, newCol});
            }
        }
    }
    
    // 没有找到路径
    return false;
}

#ifndef MAZE_H
#define MAZE_H

#include <vector>

/**
 * 迷宫单元格类型枚举
 */
enum class CellType {
    WALL,     // 墙壁
    PATH,     // 通道
    START,    // 起点
    END,      // 终点
    VISITED,  // 已访问
    SOLUTION  // 解决路径
};

/**
 * 迷宫类
 */
class Maze {
private:
    int rows;  // 行数
    int cols;  // 列数
    std::vector<std::vector<CellType>> grid;  // 迷宫网格
    int startRow, startCol;  // 起点位置
    int endRow, endCol;      // 终点位置
    
    /**
     * 使用深度优先搜索生成迷宫
     */
    void generateMazeDFS(int row, int col);
    
public:
    /**
     * 构造函数
     * @param rows 迷宫行数
     * @param cols 迷宫列数
     */
    Maze(int rows, int cols);
    
    /**
     * 生成随机迷宫
     */
    void generateRandomMaze();
    
    /**
     * 显示迷宫
     */
    void display() const;
    
    /**
     * 检查移动是否有效
     * @param row 行索引
     * @param col 列索引
     * @return 如果移动有效则为true
     */
    bool isValidMove(int row, int col) const;
    
    /**
     * 将单元格标记为已访问
     * @param row 行索引
     * @param col 列索引
     */
    void markVisited(int row, int col);
    
    /**
     * 将单元格标记为解决路径
     * @param row 行索引
     * @param col 列索引
     */
    void markSolution(int row, int col);
    
    /**
     * 重置迷宫（清除访问和解决路径标记）
     */
    void reset();
    
    // Getter方法
    int getRows() const { return rows; }
    int getCols() const { return cols; }
    int getStartRow() const { return startRow; }
    int getStartCol() const { return startCol; }
    int getEndRow() const { return endRow; }
    int getEndCol() const { return endCol; }
    CellType getCell(int row, int col) const { return grid[row][col]; }
};

#endif // MAZE_H