离散数学西电第三版实战：逻辑、关系、代数、图论的代码实现

简介：《离散数学（西电第三版）》教材配套答案PDF，面向计算机科学与信息技术专业学生，用于课后习题自测与难点查证。内容覆盖集合论、关系与函数、图论、组合数学、数理逻辑等章节，包含大量习题详细解答，可帮助读者检验解题思路、巩固离散数学核心概念。资源为单个PDF文件，压缩包大小9.26MB，便于直接下载与离线查阅；已有400人学习浏览，适合本科阶段备考及考研复习使用。与普通教材不同，本答案文件按章节提供系统化解答，可快速定位对应知识点，尤其适合自学与考前强化训练。

1. 离散数学西电第三版在学什么：不背定理，先看它解决什么问题

很多后端工程师把离散数学当成毕业前最后一门理论课，直到某天在依赖解析里遇到循环引用，或者在分布式系统里发现“等价关系”选错了划分方式，才回头翻教材。搜索“离散数学西电第三版”的人，大多不是要封面和目录，而是卡在某个习题、某个证明，或者某张关系图上。这本教材的系统性强，章节顺序基本覆盖数理逻辑、集合论与关系、代数系统、图论四大块，恰好对应着程序里布尔运算、数据建模、抽象代数结构和网络算法。这篇文章不按目录复述定义，而是把这四个板块翻译成能动手验证的代码和参数，让翻书的人可以直接对着运行结果理解证明题的结论。

2. 命题与谓词逻辑：按西电第三版的演算规则写一个真值表求值器

2.1 连接词的工程语义先对齐

课本对连接词的定义是一张真值表，但在写代码时，直接把 → 想成 if 语句会出问题。 p → q 的真值表里，只有当 p 为真且 q 为假时结果才为假，其余三行全为真。这个定义在工程上对应的是“不违背承诺”，而不是“因果关系”。比如规则“如果文件存在，则读取内容”写成 file_exists → read_success ，在文件不存在时整条规则为真，这符合系统里“前置条件不满足就不触发后续动作”的语义。

把这几个连接词先映射到熟悉的运算，后面做题会顺很多：

教材符号	含义	程序里的常见对应
¬	否定	not
∧	合取	and
∨	析取	or
⊕	异或	^
→	蕴含	not p or q
↔	等价	p == q

记住 → 等价于 not p or q 这一个公式，能解决大部分谓词演算里的化简题。谓词逻辑的量词也不要死背分配律， ∀x(P(x) ∧ Q(x)) 可以理解成两个集合同时满足条件，对应到程序里就是 all(...) 与 any(...) 的组合关系。

2.2 用 Python 把公式编译成可执行函数

手工画真值表很容易漏行，尤其是公式里出现三个以上变元时。常见做法是先把中缀公式转成后缀表达式，再交给一个栈式求值器。这里以字符串列表形式输入后缀表达式，让求值顺序完全可见。

def eval_prop(expr, env):
    """
    对一个后缀表示的逻辑表达式求值。
    expr: list[str]，每个元素是变元、 常量或运算符
    env:  dict[str, bool]，变元到真值的映射
    """
    stack = []
    for token in expr:
        if token in env:
            stack.append(env[token])
        elif token == "!":
            stack.append(not stack.pop())
        elif token == "&":
            b, a = stack.pop(), stack.pop()
            stack.append(a and b)
        elif token == "|":
            b, a = stack.pop(), stack.pop()
            stack.append(a or b)
        elif token == "->":
            b, a = stack.pop(), stack.pop()
            stack.append((not a) or b)
        elif token == "<->":
            b, a = stack.pop(), stack.pop()
            stack.append(a == b)
    return stack[0]

这段代码的求值顺序是固定的：遇到变元压栈，遇到运算符弹出操作数，再把结果压回去。注意二元运算里先弹出来的是右操作数，所以代码里先赋值给 b 再赋值给 a 。如果写反， a -> b 会变成 b -> a ，真值表完全不一样。 env 参数把变元取值从外部传入，这样同一个表达式可以反复求值，不用每次重写公式。

2.3 用笛卡尔积生成全部赋值，直接判定永真式

永真式的判定在教材里叫“重言式”，工程上对应到配置校验里的“无论输入如何，规则都不产生冲突”。手工证明要分情况讨论，程序只需要枚举所有可能取值。

from itertools import product

def is_tautology(expr, vars_):
    """
    判断 expr 是否为永真式。
    vars_: list[str]，表达式中出现的所有变元
    返回 (是否为永真式, 反例字典)
    """
    for values in product([True, False], repeat=len(vars_)):
        env = dict(zip(vars_, values))
        if not eval_prop(expr, env):
            return False, env
    return True, None

product([True, False], repeat=len(vars_)) 生成了所有组合，相当于把真值表的每一行都跑了一遍。 dict(zip(vars_, values)) 把变元名和取值配对成环境变量。这里有个实际经验：变元数量超过 12 个时，2^n 行的枚举会明显变慢，教材习题一般不会出到那么大，所以这套代码用来对付课后题完全够用。

谓词逻辑层面同理，不用手工展开量词。把论域建模成一个 Python 集合， ∀xP(x) 就是 all(P(x) for x in universe) ， ∃xP(x) 就是 any(...) 。遇到“不存在某个 x 使 P 成立”这种否定量词，直接看 not any(...) ，比在纸上反复换量词符号更不容易错。

3. 关系与闭包：用矩阵视角把传递闭包算出来

3.1 关系矩阵为什么是邻接矩阵的另一套说法

集合 A 上的二元关系可以写成 n×n 矩阵，第 i 行第 j 列是 1 就表示 a_i R a_j 。这个矩阵和离散数学西电第三版里关系的复合运算直接对应：两个关系矩阵相乘再取大于 0 的项，得到的就是复合关系。图论里的邻接矩阵只是这种关系矩阵给有向图换了个名字。

程序里保存二元关系时，常见做法是把每条边存成元组 (a, b) ，但判断传递性时需要频繁查“中间节点”，元组列表的查询效率不如矩阵。所以做闭包运算时，我一般先把关系读成 list[list[int]] ，每一步运算都在矩阵上做，最后再转回边集合输出。

3.2 三种闭包在 Python 里的最小实现

教材里自反闭包、对称闭包、传递闭包是三个分开的定义，代码里对应也是三个独立函数。自反闭包只需要在对角线上补 1；对称闭包要求若 (i, j) 存在则 (j, i) 也必须存在；传递闭包则要反复补上通过中间节点可达的边。

def reflexive_closure(M):
    n = len(M)
    return [[M[i][j] or (i == j) for j in range(n)] for i in range(n)]

def symmetric_closure(M):
    n = len(M)
    return [[M[i][j] or M[j][i] for j in range(n)] for i in range(n)]

def transitive_closure(M):
    n = len(M)
    R = [row[:] for row in M]
    for k in range(n):
        for i in range(n):
            for j in range(n):
                R[i][j] = R[i][j] or (R[i][k] and R[k][j])
    return R

自反闭包的关键参数是 i == j ，它把单位矩阵并进原关系矩阵，结果依然保持布尔语义。对称闭包里 M[j][i] 读取的是转置位置的元素，这一步做完矩阵一定对称。传递闭包的三层循环里， k 是中间节点， R[i][k] and R[k][j] 表示从 i 到 j 能经过 k 走通。直接用 R 自身参与更新是 Floy-Warshall 算法的布尔版本，比反复做矩阵乘法更快，时间复杂度稳定在 O(n^3)，空间 O(n^2)。

3.3 Warshall 算法的边界条件与教材习题对照

用这个算法验证课后题时，最常踩的坑是初始矩阵直接复制原始关系后，忘记处理自身到自身的可达性。教材里传递闭包的定义允许长度为 0 的路径吗？不同教材处理方式不同。西电这个版本的惯例是不把 (i, i) 自动加入，除非原关系里已经有自环。所以如果题目要求“自反传递闭包”，需要先调用 reflexive_closure ，再调用 transitive_closure ，顺序不能反。先求自反闭包再求传递闭包，对角线上的 1 会随着传递性扩散到所有能到达自己的节点，得到的结果才符合“自反且传递”的最小关系。

这里有一个工程映射值得注意：等价关系要求自反、对称、传递，恰好是构建并查集时的三大性质。关系矩阵上的闭包运算，对应到并查集里就是不断合并连通分量。教材里的“商集”概念，在程序里就是并查集每个根节点对应的集合。做题时如果遇到一个关系要判断是否为等价关系，与其手算四条性质，不如直接在矩阵上检查对角线全 1、矩阵对称、传递闭包不产生新边。

提示：用闭包算法检查传递性时，如果原矩阵规模在 100 以上，三层循环会明显卡顿。可以先用 len(M) 确认规模，超过 200 就考虑用邻接表加 BFS 做可达性查询。

4. 代数系统的同态与同构：用循环群读懂抽象结构

4.1 群定义里的四条公理怎么验证

教材定义群需要满足封闭性、结合律、单位元、逆元四条。前两条在有限集合上可以暴力验证，后两条需要结合具体运算来看。常见做法是把集合和运算封装成两个参数，写一个通用检查函数，然后对练习里给出的每个代数系统跑一遍。

def is_group(elements, op, identity):
    """
    elements: list，有限集合
    op: 二元运算函数，op(a, b) 返回 a 和 b 运算后的结果
    identity: 单位元
    """
    # 封闭性和单位元
    for a in elements:
        if op(a, identity) != a or op(identity, a) != a:
            return False
        for b in elements:
            if op(a, b) not in elements:
                return False
    # 结合律
    for a in elements:
        for b in elements:
            for c in elements:
                if op(op(a, b), c) != op(a, op(b, c)):
                    return False
    # 逆元
    for a in elements:
        found = False
        for b in elements:
            if op(a, b) == identity:
                found = True
                break
        if not found:
            return False
    return True

这段代码里， op 是唯一的可控参数。整数加法群传入 lambda a, b: a + b ，模 n 乘法群传入 lambda a, b: (a * b) % n 。检查结合律的部分是三重循环，时间复杂度是集合大小的三次方，教材习题里集合元素一般不超过 8 个，跑起来没有压力。逆元的检查只要求存在 b 使运算结果为单位元，没有额外要求 b 唯一，实际在群定义下唯一性是由结合律自动保证的。

4.2 用模 7 乘法群找生成元

循环群是理解同构的最好切入点。模 7 乘法群 {1,2,3,4,5,6} 在乘法运算下构成一个阶为 6 的群，它的生成元就是那些幂次能遍历所有元素的数。找生成元的代码核心是模拟连续运算，看从某个元素出发不断自乘能覆盖多少元素。

def find_generators(elements, op, identity):
    """
    返回群中的所有生成元。
    生成元是指其幂次能遍历整个非单位元集合的元素。
    """
    gens = []
    for g in elements:
        seen = []
        x = identity
        while True:
            x = op(x, g)          # 每步乘以 g
            if x in seen:
                break
            seen.append(x)
        if len(seen) == len(elements):
            gens.append(g)
    return gens

elements = [1, 2, 3, 4, 5, 6]
op = lambda a, b: (a * b) % 7
print(find_generators(elements, op, 1))  # [3, 5]

x = identity 是起点，循环里先乘 g 再入列表，保证不会把单位元重复计入。 if x in seen 判断是否回到了已经出现过的元素，一旦回到就说明进入循环，不能再产生新元素。运行结果 [3, 5] 说明这两个元素是模 7 乘法群的生成元。这个结果和加法群 Z6 的生成元 {1,5} 一一对应，映射 f(k) = 3^k mod 7 就把 Z6 里的加法翻译成了模 7 乘法。这就是同构的具象表现：两个系统里的元素名字不同，运算结构完全一致。

4.3 同态不是同构：工程里最常见的结构映射

同态要求 f(a * b) = f(a) * f(b) ，但不要求 f 是双射。工程里大量使用同态：哈希函数把任意长度的数据映射到固定长度， hash(a + b) 与 hash(a) + hash(b) 在某些构造下保持运算关系，但显然不是一一映射。同构要求可逆，意味着两边的信息量完全相等。

映射类型	是否一一对应	运算保持	工程例子
同态	否	是	哈希函数、状态机的状态压缩
同构	是	是	数据库表结构重命名、坐标系变换
同胚	拓扑层面	只要求连续	无

做题时判断同态，只需要验证 f(a op b) == f(a) op' f(b) 对集合中所有元素成立。判断同构，还要额外验证 f 是双射，最直接的办法是看 len(f(elements)) == len(elements) 且没有两个输入映射到同一个输出。在编程里，这个检查可以写成 len(set(map(f, elements))) == len(elements) 。

代数系统这一章和编码关联很深。AES 加密里的 S 盒通过 GF(2^8) 上的乘法逆元构造，CRC 校验利用多项式环的同态性质。看到教材里群、环、域的层层定义，不要只记结论，可以把“GF(2^8) 上的加法是 XOR”这个具体例子写在旁边，抽象定义立刻有了落点。

5. 图论章节的工程落点：最短路径与二分图判定的两种写法

5.1 从关系矩阵切换到邻接表，别被教材的矩阵定义限制住

离散数学西电第三版图论部分通常从图的基本概念和矩阵表示开始，但实际编码时邻接表比邻接矩阵更常用。邻接矩阵适合判断两点是否直接相连，复杂度 O(1)，但空间是 O(n^2)；邻接表只存实际存在的边，空间 O(n+m)，遍历邻居更高效。教材习题规模小，两种都能算对，但算法题和工程代码里邻接表是默认选择。

graph = {
    "A": [("B", 1), ("C", 4)],
    "B": [("C", 2), ("D", 6)],
    "C": [("D", 3)],
    "D": []
}

这个字典里每个键是节点，值是由 (邻居, 权重) 组成的列表。带权图用元组，不加权的图直接存邻居字符串列表。写成这个结构后，BFS、DFS、Dijkstra 都能直接复用，不需要反复查矩阵。

5.2 Dijkstra 的懒删除堆实现

教材里通常用集合逐步扩展来演示 Dijkstra 算法，复杂度 O(n^2)。工程实现一般换成优先队列，把尚未确定最短距离的节点反复压入堆，出堆时跳过过期记录，这叫“懒删除”策略，代码简单且对大多数场景性能足够。

import heapq

def dijkstra(graph, start):
    """
    graph: dict[str, list[tuple[str, int]]]，邻接表
    start: 起始节点
    返回 dist: 各节点到 start 的最短距离
    """
    dist = {node: float("inf") for node in graph}
    dist[start] = 0
    pq = [(0, start)]
    while pq:
        d, u = heapq.heappop(pq)
        if d > dist[u]:
            continue
        for v, w in graph[u]:
            nd = d + w
            if nd < dist[v]:
                dist[v] = nd
                heapq.heappush(pq, (nd, v))
    return dist

print(dijkstra(graph, "A"))

当只求最短距离时，不需要记录前驱节点。 if d > dist[u]: continue 是懒删除的关键一步：堆里可能存在同一节点的多个历史距离，旧记录出堆时直接跳过。 heapq.heappush 每次压入的是更新后的累计距离，参数顺序是 (距离, 节点) ，这样堆顶总是当前最小距离。整体复杂度 O((V+E)log V)，比教材的 O(V^2) 在稀疏图上快很多。

5.3 二分图判定用 BFS 染色，对应教材的奇圈定理

教材里二分图的判定条件是不能含有奇环，程序实现用染色法。从一个节点出发，把它的邻居染成相反颜色，如果某个邻居已经被染成同色，就说明存在奇环，不是二分图。

from collections import deque

def is_bipartite(graph):
    """
    graph: dict[str, list[str]]，无向图的邻接表
    返回是否为二分图
    """
    color = {}
    for start in graph:
        if start in color:
            continue
        color[start] = 0
        q = deque([start])
        while q:
            u = q.popleft()
            for v in graph[u]:
                if v in color:
                    if color[v] == color[u]:
                        return False
                else:
                    color[v] = 1 - color[u]
                    q.append(v)
    return True

外层循环处理非连通图，保证每个连通分量都被染色。 1 - color[u] 把 0 变 1、1 变 0，实现颜色翻转。 if v in color and color[v] == color[u] 一旦命中就说明两个相邻节点颜色相同。这个算法对每个节点和每条边各访问一次，时间复杂度 O(V+E)，空间 O(V)。

算法/概念	时间复杂度	空间复杂度	教材对应
Warshall 传递闭包	O(n^3)	O(n^2)	关系闭包
Dijkstra 堆优化	O((V+E)log V)	O(V+E)	最短路径
BFS 二分图染色	O(V+E)	O(V)	二分图判定

图论部分还有一个高频考点是欧拉回路和哈密顿回路。欧拉回路的判定条件基于度数的奇偶性，程序里一行 all(deg[v] % 2 == 0 for v in graph) 就能验证；哈密顿回路没有多项式判定条件，教材里强调这一点本身就是重点。遇到“是否存在经过所有边一次的路径”，先想欧拉；遇到“经过所有顶点一次的路径”，别用手工穷举，这完全是两个难度层次的问题。

6. 可复用的习题自检技巧：把离散数学西电第三版的证明题改成可执行检查

课后题里有一类题是给一个二元关系，判断它是否为等价关系或偏序关系。手工证明容易遗漏反例，写一个通用检查函数，可以在几秒内把答案验证一遍。更关键的是，这个函数里的每一步都对应教材定义，运行结果能直接指出是哪里不满足。

def is_equivalence_relation(R, A):
    """
    R: set[tuple]，关系中的每个有序对
    A: list/set，集合元素
    """
    R_set = set(R)
    for a in A:
        if (a, a) not in R_set:
            return False, f"缺少自环 ({a}, {a})"
    for (a, b) in R_set:
        if (b, a) not in R_set:
            return False, f"缺少对称边 ({b}, {a})"
    for (a, b) in R_set:
        for (c, d) in R_set:
            if b == c and (a, d) not in R_set:
                return False, f"传递性被破坏: ({a}, {b}) 和 ({c}, {d}) 无法闭合"
    return True, None

这里的关键设计是把 R 转成 set ，查边操作变成 O(1)，而且重复的关系对被自动去重。用元组存储有序对，是因为元组可哈希，能放进集合；如果把关系存成列表，每次查边都要线性扫描，判断传递性的双重循环会退化成 O(n^4)。 A 的范围只用来检查自反性，对称性和传递性完全基于 R 自身。返回值里带上失败原因，比单纯返回 False 更接近教材证明题的批改逻辑——能直接看到哪一条性质不成立。

用这套方法复查作业，还能发现一个常见误用：自反性要求对 A 中每个元素都有自环，但如果人为把 (a, b) 和 (b, a) 加进去，却忘记补 (a, a)，程序会在第一轮就报出来。另一个容易忽略的陷阱是，当关系集合为空集时，传递性和对称性都天然成立，只有自反性会失败，这一点教材中的定义和程序的逻辑完全一致。

提示：集合里的元素必须是可哈希类型。字符串、整数、元组都可以；列表和字典不能直接放进集合，需要使用前先把它们转成元组。

最后一类容易卡住的题是“证明两个代数系统同构”。手工要构造双射映射并验证运算保持，程序里可以暴力搜索所有双射，但需要注意映射数量是 n!，元素数量超过 7 就可能很慢。更实用的技巧是先用阶数排除：如果两个群的阶不同，不可能同构；在同阶时先比较每个元素的阶的分布，分布不同直接否决，分布相同再找具体映射。这个筛选步骤在教材里不常写，但做完题之后用程序验证一遍，能立刻发现构造出的映射是否有遗漏。

本文还有配套的精品资源，点击获取