动态规划优化刷题

714. 买卖股票的最佳时机含手续费

class Solution:
    def maxProfit(self, prices: List[int], fee: int) -> int:
        n = len(prices)
        dp = [[0] * 2 for _ in range(n)]
        dp[0][0] = 0
        dp[0][1] = -prices[0]
        for i in range(1, n):
            idx = i % 2
            pre_idx = 1 - idx
            dp[idx][0] = max(dp[pre_idx][1] + prices[i] - fee, dp[pre_idx][0])
            dp[idx][1] = max(dp[pre_idx][1], dp[pre_idx][0] - prices[i])
        return max(dp[(n-1) % 2])

这段代码是解决一个投资问题，给定一个数组，代表在一段时期内一只股票的价格。你可以在任何一天买入和卖出股票，但是需要支付手续费。目标是最大化你的利润。

代码中使用了动态规划的方法来解决这个问题。下面是对代码的详细解释：

函数定义:

def maxProfit(self, prices: List[int], fee: int) -> int:

这个函数接受一个价格数组和一个手续费，并返回最大利润。
2. 初始化:

n = len(prices)  
dp = [[0] * 2 for _ in range(n)]

n 是价格数组的长度。dp 是一个二维数组，用于存储到达每一天的最大利润。其中，dp[i][0] 表示在第 i 天没有持有股票时的最大利润，dp[i][1]` 表示在第 i 天持有股票时的最大利润。
3. 初始化第一天的状态:

dp[0][0] = 0  
dp[0][1] = -prices[0]

第一天没有持有股票的利润是0，持有股票的利润是负的第一个价格（因为你不能在第一天卖出股票）。
4. 动态规划计算:
对于每一天 i（从1到n-1），我们有两个选择：持有或不持有股票。如果我们选择不持有股票，那么我们可以从第 i-1 天的状态转移过来，并加上当前的价格。如果我们选择持有股票，那么我们可以从第 i-1 天的状态转移过来，并减去当前的价格。在每种情况下，我们都要考虑是否要支付手续费。
5. 返回结果:

return max(dp[(n-1) % 2])

最后，我们返回第 n-1 天的最大利润。因为数组索引是从0开始的，所以我们需要对 n-1 使用模运算来确保我们访问的是正确的行。

总的来说，这个代码使用动态规划的方法来计算在给定价格数组和手续费的情况下，如何最大化你的利润。

213. 打家劫舍 II

class Solution:
    def rob(self, nums: List[int]) -> int:
        n = len(nums)
        if n == 1: return nums[0]
        dp = [[0]  * 2  for _ in range(2)]
        dp[0][1] = nums[0]
        for i in range(1, n):
            idx = i % 2
            pre_idx = 1 - idx
            dp[idx][0] = max(dp[pre_idx][1], dp[pre_idx][0])
            dp[idx][1] = dp[pre_idx][0] + nums[i]
        ans1 = dp[( n-1) % 2][0]
        dp[0][1] = 0
        dp[0][0] = 0
        for i in range(1, n):
            idx = i % 2
            pre_idx = 1 - idx
            dp[idx][0] = max(dp[pre_idx][1], dp[pre_idx][0])
            dp[idx][1] = dp[pre_idx][0] + nums[i]
        ans2 = max(dp[( n - 1) % 2])
        return max(ans1 ,ans2)

这段代码是一个经典的动态规划问题，旨在解决“打家劫舍”问题。给定一个整数数组nums，其中每个元素代表一栋房子的价值，你作为一个强盗，目标是选择连续的子数组（至少包含一栋房子），以便最大化抢劫的价值。但是，你不能抢劫相邻的房子，因为它们会触发警报。

下面是代码的详细解释：

初始化:

n = len(nums)  
if n == 1: return nums[0]

这里，我们首先获取数组的长度。如果数组只有一个元素，那么最大价值就是该元素本身。
2. 动态规划数组初始化:

dp = [[0]  * 2  for _ in range(2)]  
dp[0][1] = nums[0]

我们初始化一个2x2的二维数组dp，其中dp[i][0]表示不抢劫第i个房子时的最大价值，而dp[i][1]表示抢劫第i个房子时的最大价值。初始时，只有第一个房子被抢劫（因此dp[0][1] = nums[0]）。
3. 第一次动态规划计算:

for i in range(1, n):  
    idx = i % 2  
    pre_idx = 1 - idx  
    dp[idx][0] = max(dp[pre_idx][1], dp[pre_idx][0])  
    dp[idx][1] = dp[pre_idx][0] + nums[i]

在这个循环中，我们计算不抢劫第i个房子和抢劫第i个房子的最大价值。对于不抢劫第i个房子，我们可以选择抢劫或不抢劫前一个房子；对于抢劫第i个房子，我们可以从不抢劫该房子或抢劫前一个房子中获得价值。
4. 第一次计算结果:

ans1 = dp[( n-1) % 2][0]

这是第一次动态规划计算的结果，表示不抢劫最后一个房子的最大价值。
5. 第二次动态规划计算:

这部分是为了确保我们考虑了所有可能的抢劫方案，其中最后一个房子是被抢劫的。我们重置dp数组并重新进行计算。
6. 第二次计算结果:

ans2 = max(dp[( n - 1) % 2])

这是第二次动态规划计算的结果，表示抢劫最后一个房子的最大价值。
7. 返回结果:
最后，我们返回两次计算中的最大值作为最终结果。

总的来说，这段代码使用动态规划的方法解决了“打家劫舍”问题，并确保找到最优解。

416. 分割等和子集

class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        sum_val = sum(nums)
        if sum_val % 2: return False 
        n = len(nums)
        f = [False] * (sum_val + 1)
        f[0] = True
        tmp  = 0
        for num in nums:
            tmp += num
            for j in range(tmp, num - 1, -1):
                f[j] |= f[j - num]
        return f[sum_val // 2]
        

这段代码是一个Python类，其目的是解决一个被称为“整数划分”的问题。给定一个非负整数数组 nums，该问题要求判断是否可以将 nums 的元素分成两组，使得两组的元素之和相等。如果可以，返回 True；否则，返回 False。

下面是代码的详细解释：

sum_val = sum(nums): 计算数组 nums 中所有元素的和。

if sum_val % 2: return False: 如果总和是奇数，那么无法将数组分成两组使其和相等，因此直接返回 False。

n = len(nums): 获取数组 nums 的长度。

f = [False] * (sum_val + 1): 创建一个长度为 sum_val + 1 的布尔数组 f，并初始化为全 False。这个数组将用于存储从0到 sum_val 的值是否可以被划分。

f[0] = True: 因为0可以单独作为一个和为0的组，所以将 f[0] 设置为 True。

tmp = 0: 初始化一个变量 tmp，用于存储当前遍历的数字的和。

for num in nums:: 遍历数组 nums 中的每个数字。

tmp += num: 更新 tmp 的值，加上当前遍历的数字。

for j in range(tmp, num - 1, -1):: 对于每个从 tmp 到 num - 1 的值，执行以下操作：

f[j] |= f[j - num]: 如果 j - num 的值可以被划分（即 f[j - num] 为 True），则将 f[j] 设置为 True，表示数字 j 也能够被划分。
return f[sum_val // 2]: 最后，检查数组的总和的一半（即每组的预期和）是否可以被划分。如果是，则返回 True；否则，返回 False。

总之，这段代码使用动态规划的方法解决了整数划分问题。它通过构建一个布尔数组来存储中间结果，并利用这些结果来判断给定的总和是否可以被划分。

class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        sum_val = sum(nums)
        if sum_val % 2: return False 
        n = len(nums)
        f = [[False] * (sum_val + 1) for _ in range(2)]
        f[0][0] = True 
        for  i in range(1, n):
            idx  = i  % 2
            pre_idx  =  1 - idx
            for j in range(sum_val + 1):
                f[idx][j] = f[pre_idx][j] or f[pre_idx][j - nums[i]]
        return f[(n-1) % 2][sum_val // 2]

474. 一和零

class Solution:
    def findMaxForm(self, strs: List[str], m: int, n: int) -> int:
        length = len(strs)
        dp = [[[0] * (n + 1) for _ in range(m + 1)] for _ in range(length + 1)]
        for k in range(1, length + 1):
            counter = collections.Counter(strs[k - 1])
            for i in range(m + 1):
                for j in range(n + 1):
                    dp[k][i][j] = dp[k - 1][i][j]
                    if i < counter['0'] or j < counter['1']: continue
                    dp[k][i][j] = max(dp[k][i][j], dp[k - 1][i - counter['0']][j - counter['1']]  + 1)
        return dp[length][m][n]

这段代码是一个使用动态规划解决问题的示例。这个问题可以理解为在一个有 m x n 个格子的纸上，从上方掉落一系列的纸片（strs），每张纸片都有 ‘0’ 或 ‘1’ 的标记。你需要选择一个区域，使得区域内的纸片标记满足 ‘0’ 的数量不超过 m 且 ‘1’ 的数量不超过 n。你的目标是最大化这个区域的面积。

代码中的变量和逻辑如下：

strs 是一个字符串列表，每个字符串代表一张纸片的标记。
m 和 n 分别表示可以选取的纸片中 ‘0’ 和 ‘1’ 的最大数量。
dp 是一个三维数组，用于存储状态。其中，dp[k][i][j] 表示在考虑前 k 张纸片，且选取的纸片中 ‘0’ 的数量为 i，‘1’ 的数量为 j 的情况下，能够形成的最大区域面积。
counter 是一个计数器，用于统计当前纸片的 ‘0’ 和 ‘1’ 的数量。
在循环中，首先将 dp[k][i][j] 设置为 dp[k - 1][i][j]，表示不考虑当前纸片的情况。然后，如果当前纸片的 ‘0’ 或 ‘1’ 的数量超过了限制（即 i < counter[‘0’] 或 j < counter[‘1’]），则跳过当前情况。否则，更新 dp[k][i][j] 为考虑当前纸片后的最大面积，即 dp[k - 1][i - counter[‘0’]][j - counter[‘1’]] + 1。
最后返回 dp[length][m][n]，即在考虑所有纸片后，满足条件的最大区域面积。
注意：这段代码中使用了 collections.Counter 来统计字符串中字符的数量，该库需要单独导入。

494. 目标和

class Solution:
    def findTargetSumWays(self, nums: List[int], target: int) -> int:
        sum_val = sum(nums)
        if target >sum_val: return 0
        n = len(nums)
        if n == 1:return 1 if abs(nums[0]) == abs(target) else 0
        basis = sum_val
        dp = [[0] * (2 * sum_val + 1) for _ in range(2)]
        dp[0][0 + basis] = 1
        for i in range(0, n):
            idx = i % 2
            next_idx  =  1 - idx
            for j in range(0, 2 * sum_val + 1):
                if j + nums[i] < 2 * sum_val + 1:
                    dp[next_idx][j + nums[i]] += dp[idx][j]
                if j - nums[i] >=0:
                    dp[next_idx][j - nums[i]] += dp[idx][j]
            dp[idx] = [0] * (2 * sum_val + 1)
        return dp[n % 2][basis + target]

这段代码是一个解决给定问题的Python类，该类包含一个名为findTargetSumWays的方法。该方法接受一个整数列表nums和一个目标值target作为输入，并返回满足以下条件的整数target的方案数：通过选择nums中的一些数字并可能改变它们的正负号，得到的数字之和等于target。

代码的逻辑如下：

首先，计算列表nums中所有数字的总和，并将其存储在变量sum_val中。

如果目标值target大于总和sum_val，则返回0，因为没有可能的方案可以满足条件。

获取列表nums的长度，并将其存储在变量n中。

如果列表nums只有一个元素，则检查该元素的绝对值是否等于目标值target。如果是，则返回1（表示存在一个解决方案），否则返回0。

初始化两个动态规划数组dp[0]和dp[1]，每个数组的大小为2倍的列表总和加1。这些数组将用于存储中间结果。

将dp[0][0 + basis]设置为1，表示不选择任何数字时，和为0的方案数为1。

使用两个嵌套循环遍历列表nums中的每个数字和动态规划数组的每个元素。

对于每个数字nums[i]和每个动态规划数组的元素j，如果加上或减去该数字不会超出动态规划数组的范围，则更新动态规划数组的值。具体来说，如果加上数字后不会超出范围，则将dp[next_idx][j + nums[i]]增加dp[idx][j]。如果减去数字后不会超出范围，则将dp[next_idx][j - nums[i]]增加dp[idx][j]。
在每次循环结束后，将动态规划数组dp[idx]重置为全零数组，以便在下一次迭代中使用。
返回动态规划数组的最后一个元素，即目标值为basis + target时的方案数。

总的来说，这段代码使用动态规划的方法解决了给定问题，通过构建和更新动态规划数组来计算满足条件的方案数。

322. 零钱兑换

class Solution:
    def coinChange(self, coins: List[int], amount: int) -> int:
        dp = [-1] * (amount + 1)
        dp[0] = 0
        for coin in coins:
            for i in range(coin, amount + 1):
                if dp[i - coin] == -1: continue
                if dp[i] == -1 or dp[i] > dp[i - coin] + 1: dp[i] = dp[i - coin] + 1
                dp[i] = min(dp[i], dp[i-coin] + 1)
        return dp[amount]

这段代码是一个解决硬币找零问题的动态规划算法。给定一个硬币列表coins和一个目标金额amount，这段代码返回的是用最少数量的硬币来凑齐目标金额amount的方法数。

代码的逻辑如下：

创建一个长度为amount + 1的动态规划数组dp，并将所有元素初始化为-1。

将dp[0]设置为0，表示目标金额为0时，不需要任何硬币即可凑齐。

遍历硬币列表coins：

对于每个硬币的面值coin，从该硬币面值开始遍历到目标金额amount：
如果dp[i - coin]为-1（表示之前没有计算过使用该硬币之前的金额），则跳过此次循环。
如果dp[i]为-1或大于dp[i - coin] + 1，则更新dp[i]为dp[i - coin] + 1，表示使用该硬币可以凑齐金额i。
无论是否更新，都确保dp[i]的值不会超过使用该硬币之前的金额加1。
返回dp[amount]，即目标金额为amount时的最少数量的硬币方法数。

这个算法使用动态规划的思想，通过状态转移方程逐步计算出每个金额的最少硬币数量。其中，数组dp[i]表示凑齐金额为i的最少硬币数量。

518. 零钱兑换 II

class Solution:
    def change(self, amount: int, coins: List[int]) -> int:
        f = [0] * (amount + 1)
        f[0] = 1
        for x in coins:
            for j in range(x, amount + 1):
                f[j] += f[j - x]
        return f[amount] 

这段代码是一个解决硬币找零问题的动态规划算法。给定一个硬币面值列表coins和一个目标金额amount，这段代码返回的是用最少数量的硬币来凑齐目标金额amount的方法数。

代码的逻辑如下：

创建一个长度为amount + 1的动态规划数组f，并将所有元素初始化为0。

将f[0]设置为1，表示目标金额为0时，有1种方法（不需要任何硬币）。

遍历硬币面值列表coins：

对于每个硬币面值x，从该硬币面值开始遍历到目标金额amount：
对于每个金额j，将之前的金额计算结果累加到当前金额的计算结果中。
返回f[amount]，即目标金额为amount时的最少数量的硬币方法数。

这个算法使用动态规划的思想，通过状态转移方程逐步计算出每个金额的最少硬币数量。其中，数组f[i]表示凑齐金额为i的最少硬币数量。

377. 组合总和 Ⅳ

class Solution:
    def combinationSum4(self, nums: List[int], target: int) -> int:
        f = [0] * (target + 1)
        f[0] = 1
        for i in range(1, target + 1):
            for num in nums:
                if i < num: continue
                f[i] += f[i - num]
        return f[target]

这段代码是一个解决组合求和问题的动态规划算法。给定一个整数列表nums和一个目标值target，这段代码返回的是使用nums中的数字通过组合（不重复使用数字）得到target的方案数。

代码的逻辑如下：

创建一个长度为target + 1的动态规划数组f，并将所有元素初始化为0。

将f[0]设置为1，表示目标值为0时，有1种方案（不使用任何数字）。

使用两个嵌套循环遍历数组f和整数列表nums：

外层循环变量i从1到目标值target。
内层循环变量num遍历整数列表nums。
如果当前目标值i小于当前数字num，则跳过此次循环。
否则，将之前的目标值计算结果累加到当前目标值的计算结果中。
返回f[target]，即目标值为target时的方案数。

这个算法使用动态规划的思想，通过状态转移方程逐步计算出每个目标值的方案数。其中，数组f[i]表示凑齐目标值为i的方案数。

382. 链表随机节点

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:

    def __init__(self, head: Optional[ListNode]):
        self.head = head

    def getRandom(self) -> int:
        node = self.head 
        count = 1
        ans = 0
        while node:
            if random.randint(1, count) == count:
                ans = node.val
            count += 1
            node = node.next
        return ans 


# Your Solution object will be instantiated and called as such:
# obj = Solution(head)
# param_1 = obj.getRandom()

这段代码定义了一个名为Solution的类，该类用于解决一个特定的问题：从一个单链表中随机选择一个元素。

首先，让我们解释一下代码中的各个部分：

class ListNode: 这一部分定义了一个链表的节点类，每个节点有一个值（val）和一个指向下一个节点的指针（next）。
def init(self, val=0, next=None): 这是ListNode类的构造函数，用于创建一个新的链表节点。如果未提供值和下一个节点，它们将默认为0和None。
class Solution: 这一部分定义了Solution类，它有一个构造函数和一个名为getRandom的方法。
def init(self, head: Optional[ListNode]): 这是Solution类的构造函数，它接受一个可选的链表头节点作为参数。
def getRandom(self) -> int: 这是Solution类的主要方法，它返回链表中的一个随机整数。
接下来，我们详细解释一下getRandom方法的工作原理：

node = self.head: 初始化一个指针node，指向链表的头部。
count = 1: 初始化一个计数器，用于跟踪当前节点的位置。
ans = 0: 初始化一个变量ans，用于存储随机选择的节点的值。
while node: 循环遍历链表，直到到达链表的末尾。
if random.randint(1, count) == count: 在这个循环中，我们使用Python的random.randint()函数生成一个介于1和当前节点位置（包括当前节点位置）之间的随机数。如果这个随机数等于当前节点的位置，我们将当前节点的值存储在变量ans中。
count += 1: 增加计数器，移动到链表的下一个节点。
node = node.next: 将指针移动到链表的下一个节点。
return ans: 返回存储在变量ans中的随机节点的值。
这个算法的时间复杂度是O(n)，其中n是链表的长度。因为我们需要遍历整个链表一次来确定随机节点的位置。这个算法不是高效的随机选择算法，特别是与Fisher-Yates洗牌算法（也称为Knuth洗牌算法）相比，后者可以在O(n)时间复杂度内对链表进行随机排序。

462. 最少移动次数使数组元素相等 II

class Solution:
    def minMoves2(self, nums: List[int]) -> int:
        flag = 1
        if len(nums) % 2 != 0:
            flag = 2
            nums = nums[:] + nums[:]
        nums.sort()
        ans1 = sum(nums[: len(nums) // 2])
        ans2 = sum(nums[len(nums) // 2: ])
        return (ans2 - ans1) // flag

这段Python代码实现的是一个名为minMoves2的方法，它的目标是找到一个方法，通过这个方法可以使两个等长的子数组的和相等，并返回需要移动的最小元素数量。

下面是对代码的详细解释：

定义类和方法:

python
class Solution:
def minMoves2(self, nums: List[int]) -> int:
这定义了一个名为Solution的类，并在该类中定义了一个名为minMoves2的方法。该方法接受一个整数列表nums作为输入，并返回一个整数。
2. 处理奇数长度的情况:

python
flag = 1
if len(nums) % 2 != 0:
flag = 2
nums = nums[:] + nums[:]
如果输入的列表长度是奇数，代码首先复制这个列表（使用切片操作nums[:]）使其长度翻倍。同时设置一个标记flag，当列表长度为奇数时，将flag设为2。这样处理后，后续就可以确保我们处理的两个子列表长度相等。
3. 排序:

python
nums.sort()
对列表进行排序，确保数字从小到大排列。
4. 计算两个子列表的和:

python
ans1 = sum(nums[: len(nums) // 2])
ans2 = sum(nums[len(nums) // 2:])
通过切片操作，我们分别计算了两个等长的子列表的和。其中，ans1是前半部分子列表的和，而ans2是后半部分子列表的和。
5. 返回结果:

python
return (ans2 - ans1) // flag
最后，我们计算两个子列表和的差值，并除以flag（如果列表长度为奇数，则flag为2；否则，flag为1）。这个差值表示为了使两个子列表的和相等，需要移动的最小元素数量。然后返回这个值。

总结：这个方法的目标是找到一个方法，通过这个方法可以使两个等长的子数组的和相等，并返回需要移动的最小元素数量。

77. 组合

class Solution:
    def dfs(self, n, m, k, buff):
        if k == 0:
            self.ans.append(buff)
            return 
        for i in range(m, n + 1):
            self.dfs(n, i + 1, k - 1, buff+[i])
    def combine(self, n: int, k: int) -> List[List[int]]:
        self.ans = []
        self.dfs(n, 1, k, [])
        return self.ans 

这段代码是一个Python类，名为Solution，其中包含两个方法：dfs和combine。这个类似乎是解决一个组合问题，具体来说，它可能是在寻找从一个1到n的整数集合中选取k个不同的整数的方式。

以下是这两个方法的详细解释：

dfs(self, n, m, k, buff): 这是一个深度优先搜索（DFS）的递归方法。它采用以下参数：

n: 整数集合的上限（在这个例子中，是1到n的整数）。

m: 当前考虑的整数的起始值。

k: 需要选取的整数的数量。

buff: 一个辅助列表，用于存储已经选取的整数。该方法执行以下操作：

如果 k 为0，则将 buff（一个包含已选取整数的列表）添加到答案列表 self.ans 中，然后返回。

否则，对于从 m 到 n 的每一个整数，递归调用 dfs 方法，并减小 k 的值（表示还有更少的整数需要被选取），并将当前整数添加到 buff 中。

combine(self, n: int, k: int) -> List[List[int]]: 这是类的主方法，它接受两个参数：整数n和整数k，并返回一个列表，其中包含所有可能的从1到n中选取k个不同整数的组合。该方法执行以下操作：

初始化答案列表 self.ans 为空列表。
调用 dfs 方法来填充答案列表。
返回答案列表。
注意：这段代码似乎缺少一些上下文，例如类的初始化方法（通常是一个名为 init 的方法），以及它如何与其他代码一起使用。此外，尽管这个类名为 Solution，但它似乎没有实现一个具体的解决方案或算法，而更像是一个框架或模板，用于解决某种特定问题（可能是组合问题）。

234. 回文链表

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverse(self, head):
        newhead = ListNode(None)
        cur = head
        while cur:
            tmp = cur.next
            cur.next = newhead.next
            newhead.next = cur 
            cur = tmp
        return newhead.next
    def isPalindrome(self, head: Optional[ListNode]) -> bool:
        if not head or not head.next:
            return True 
        slow = head
        fast = head
        while fast and fast.next:
            fast = fast.next
            if not fast.next:
                break
            fast = fast.next
            slow = slow.next
        newhead = self.reverse(slow.next)
        slow.next = None
        p, q = head, newhead
        while p and q:
            if p.val != q.val: return False 
            p = p.next
            q = q.next
        return True 

这段代码是用来判断一个链表是否是回文链表。它使用了快慢指针的方法，首先找到链表的中点，然后将链表的后半部分反转，最后与前半部分逐个比较节点值是否相等。

具体来说，这段代码定义了一个名为Solution的类，其中包含两个方法：

reverse(self, head): 这个方法接受一个链表的头节点作为参数，反转链表，并返回反转后的链表的头节点。
isPalindrome(self, head: Optional[ListNode]) -> bool: 这个方法接受一个链表的头节点作为参数，判断这个链表是否是回文链表。
在isPalindrome方法中，首先检查链表是否为空或者只有一个节点，如果是，则直接返回True，因为空链表或单节点链表是回文链表。

然后使用快慢指针的方法找到链表的中点。快指针每次移动两步，慢指针每次移动一步，当快指针到达链表末尾时，慢指针指向链表的中点。

接着，调用reverse方法将链表的后半部分反转，然后断开慢指针指向的节点，将链表分成两部分。

最后，使用两个指针分别从头节点和反转后的链表的头节点开始遍历，逐个比较节点值是否相等。如果所有节点值都相等，则返回True，否则返回False。

这段代码的思路是利用快慢指针找到链表的中点，然后断开中点处的节点，将链表分成两部分。由于快指针每次移动两步，所以中点处的节点一定是偶数位置的节点。因此，可以将后半部分链表反转，然后与前半部分逐个比较节点值是否相等。如果所有节点值都相等，则说明整个链表是回文链表。