<think>嗯，用户想用分治算法找到数组中的第二大元素。首先，我需要回忆一下分治算法的基本思想。分治是将问题分解成更小的子问题，解决后再合并结果。对于找第二大元素，可能需要将数组分成两部分，分别找出每部分的最大和第二大，然后合并比较这些值。
比如，数组分成左右两部分，左边最大的L1和第二大L2，右边最大的R1和第二大R2。然后合并的时候，总的最大值肯定是L1和R1中的较大者，而第二大的就需要比较这四个数中的次大值。例如，如果L1是最大的，那么第二大的可能是R1或者L2，反之亦然。但具体怎么实现呢？
可能需要设计一个结构体或者返回两个值，每个分治步骤返回当前区间的最大和第二大。然后合并时比较左右的最大，再确定新的最大和次大。例如，当左最大大于右最大时，新的最大是左最大，次大可能是左次大或右最大中的较大者。反之亦然。
那递归的终止条件是什么呢？当数组只有一个元素时，最大是这个元素，次大不存在或者设为负无穷。当有两个元素时，比较这两个，返回最大和次大。
接下来需要考虑如何编写代码。可以用递归函数，每次返回两个值：当前区间的最大值和第二大值。合并的时候比较左右的最大值，然后确定新的最大和次大。例如，假设左边返回max1和second1，右边返回max2和second2。如果max1 > max2，那么新的最大是max1，次大是max(max2, second1)。否则，新的最大是max2，次大是max(max1, second2)。
这样递归下去，最终得到的次大就是整个数组的第二大元素。需要注意处理数组长度为奇数的情况，可能需要拆分到只剩一个或两个元素。
然后验证一下这个方法是否正确。例如，测试数组[3,1,4,2]，分成左右两半[3,1]和[4,2]。左边返回max1=3，second1=1；右边返回max2=4，second2=2。合并时，max是4，次大是max(3,2)=3，正确。
另一个测试数组[5,5,4,3]，分半后左边是[5,5]，右边是[4,3]。左边返回max1=5，second1=5；右边max2=4，second2=3。合并时max是5，次大是max(5,4)=5，但正确次大应该是4。这时候发现问题，当左半部分的最大和次大都是5时，合并后的次大应为5和右半部分的max2比较，得到5，但实际正确结果应该是4。这说明这种方法有问题。
哪里出错了？因为如果原数组中有多个相同的最大值，比如[5,5,4,3]，最大的元素是5，第二大是4。但按照上述方法，合并时次大是max(5,4)=5，导致错误。所以需要调整合并策略。
当max1等于max2的时候，次大应该取max(second1, second2)。例如，在例子中，max1=5，max2=4，所以合并后的max是5，次大应该是max(second1=5, max2=4)=5，但实际上正确的次大是4。这说明这种方法无法处理最大值重复的情况。
因此，问题在于当左右的最大值相同时，次大可能被错误地取到更高的值。需要重新考虑合并逻辑。或许应该比较所有可能的候选值，而不仅仅是左右的最大和次大。
比如，当合并左右部分时，最大的两个数可能来自左的两个候选，右的两个候选，或者左的最大和右的最大中的一个。因此，合并后的两个候选应该是所有这四个数中的前两位。例如，将左max，左second，右max，右second四个数排序，取最大的两个，其中最大的作为新的max，次大的作为新的second。
但这样做的话，可能时间复杂度会增加，因为每次合并需要排序四个数。不过对于分治来说，每个层级的处理时间是线性的，总体复杂度应该是O(n log n)，和归并排序类似。
或者，可以更高效地比较这四个数。例如，先比较左max和右max，得到较大的那个作为新max，然后剩下的三个数（较小的那个max，左second，右second）中的最大值作为新second。例如：
如果左max >右max，则新max=左max，新second=max(右max, 左second)
否则，新max=右max，新second=max(左max,右second)
但之前的例子中，当左max=5，左second=5，右max=4，右second=3时，新max=5，新second=max(4,5)=5，但正确的second是4。这说明这种合并方式在存在重复最大值时会出错。
所以问题出在这种情况下，如何处理重复的最大值。比如，当数组中有多个最大值时，第二大的元素可能出现在另一个子数组中。例如，原数组是[5,5,4,3]，最大的两个都是5，但第二大是4。此时，合并时应该考虑在左右部分中找到除了最大值之外的最大值。
或者，可能需要同时记录最大值出现的次数，但这会增加复杂度。或者，在分治的过程中，当左右的最大值相等时，合并后的最大值是它们中的一个，而次大则要考虑它们的次大中的较大者，以及另一个子数组的次大中的较大者？
或许，正确的合并策略应该是：
当合并左右两个部分时，最大的两个数可能是：
1. 左max和右max中的一个作为最大，另一个作为候选
2. 左max和右max中的另一个作为候选，或者左second或右second中的一个
例如，合并后的次大应该是所有候选中的最大值，排除最大的那个。因此，合并后的次大是 max(左second, 右second, min(左max, 右max))。
例如，左max=5，左second=5；右max=4，右second=3。合并后的max是5，次大是max(5,3,4)=5？显然不正确。正确的次大应该是4，但这里得到的是5。
这说明上述方法不可行。那应该如何正确计算次大？
或许，正确的合并策略是，当合并两个部分时，最大的数是两部分的max中的较大者，次大数是：在两部分的max中的较小者，和两部分的second中的较大者，这三者中的最大值？
例如，在左max=5，左second=5；右max=4，右second=3的情况下：
合并后的max是5，次大是max(4,5,3)=5，这仍然错误。
那这种情况下，正确的次大应该是4，但根据合并策略无法得到。这说明分治的这种方法可能无法正确处理重复的最大值的情况。可能需要调整分治的方式，或者考虑其他方法。
或者，是否在分治的过程中，不仅要记录最大值和次大值，还要记录它们的出现次数？例如，当左max和右max相等时，合并后的max是它们的值，次数相加。次大则可能是两边的次大中的最大值。例如，如果左max是5（出现2次），右max是5（出现1次），那么合并后的max是5，出现3次。这时候，次大应该是左右次大的较大者，或者当max出现次数足够多时，次大可能还是max自己？
但用户的问题是要找到第二大的元素，即整个数组中第二大的不同值？或者是否允许重复？例如，原题中用户的问题可能要求的是，数组中的第k个最大的元素，允许重复。例如，数组[5,5,4,3]中的第二大元素是5还是4？根据问题描述中的引用，题目中的第k大元素是排序后的第k个元素，允许重复。例如，数组排序后的第2大元素在[5,5,4,3]中是5。所以在这种情况下，原问题的第2大元素是5，而不是4。那用户的问题中的“第二大元素”是否允许重复？比如，如果原数组是[5,5,4]，则第二大的元素是5，第三大是4。如果用户的问题中的“第二大”指的是排序后的第二个元素，那么即使重复，也取该值。这时候，上面的分治方法返回的次大是正确的。比如，例子中的数组[5,5,4,3]，分治后的次大是5，而正确的第2大元素确实是5。所以用户的问题中的“第二大”可能允许重复的情况下，分治方法是正确的。
因此，当原题中的第二大元素是排序后的第二个元素，允许重复时，分治方法中的合并策略是正确的。例如，在数组[5,5,4,3]中，分治方法得到的次大是5，而正确的第二大元素是5，所以此时方法正确。
那之前的测试案例中的例子是否错误？
比如，假设数组是[5,5,4,3]，分治后的第二大元素应该是5，而用户可能期望的是4，这时候可能用户的问题中的“第二大”是不同的元素中的第二大，即不同的元素中的次大。所以需要明确问题的定义。根据引用中的问题描述，“数组中的第K个最大的元素”是排序后的第k个元素，包括重复的情况。例如，在[3,2,3,1,2,4,5,5,6]中，第4大的元素是4，而排序后的数组是[6,5,5,4,3,3,2,2,1]，第4大是4。所以此时，第二大元素如果是k=2的话，就是5。而原问题中的分治方法在这种情况下，如果允许重复，那么分治方法返回的次大是正确的。
因此，用户的问题中的“第二大元素”应该按照排序后的第2大的元素，允许重复的情况。因此，分治方法的合并策略是正确的，之前的例子中的次大返回5是正确的，而用户可能没有正确理解问题定义。但假设用户的问题中确实需要允许重复的情况下，那么分治方法是可行的。
现在，回到分治方法的实现。在合并时，当左max和右max比较后，确定合并后的max和second。例如：
如果左max >右max：
- 合并后的max是左max
- 合并后的second是max(右max, 左.second)
否则 if 右max >左max：
- 合并后的max是右max
- 合并后的second是 max(左max, 右.second)
如果左max等于右max：
- 合并后的max是左max（或右max，一样）
- 合并后的second是 max(left.second, right.second)
这可能更合理。例如，在左max=5，left.second=5；右max=5，right.second=3的情况下，合并后的second是max(5,3)=5，这样是正确的，因为原数组中的第二大元素是5。如果在另一个例子中，左max=5，left.second=4；右max=5，right.second=3，合并后的second是4，而原数组中的第二大元素是5（因为有多个5），所以此时分治方法得到的second是4，是错误的。这说明当左右max相等时，合并后的second应该取left.second和 right.second中的较大者，再加上当前max的值可能多次出现，所以次大仍然是max本身？
这可能无法处理某些情况。例如，数组是[5,5,5]，那么分治后的second应该是什么？按照上述方法，当左右max都为5，并且各自的second为5，那么合并后的second是5，这正确，因为整个数组的第二大元素是5。但如果原数组是[5,5,4,5]，则分治后的second应该还是5。
所以，当左右max相等时，合并后的second应该取max(left.second, right.second)，但这样是否足够？
假设数组是[5,4,5,3]，分治后左max=5，left.second=4；右max=5，right.second=3。合并后的max=5，second=max(4,3)=4。但整个数组中的第二大元素应该是5吗？因为排序后的数组是[5,5,4,3]，所以第2大的元素是5，而分治方法返回的second是4，这样是错误的。
这说明上述合并策略在左右max相等的情况下无法正确处理。这时候的次大应该是max（left.second, right.second, left.max）？因为当左右max相等时，合并后的max是其中一个，而次大可能还是该max的另一个出现，或者可能其他值。例如，当左右max都是5时，次大应该是5，只要存在至少两个5。因此，在合并时，当左右max相等时，次大应该至少是5（即max本身），而不是取left.second和right.second中的较大者。此时，正确的次大应该是max(left.second, right.second, left.max)? 但left.max等于合并后的max，所以这样会得到max(4,3,5)=5，此时合并后的second是5，正确。
所以，当左右max相等时，合并后的second应该是max(left.second, right.second, left.max)中的次大？或者说，合并后的max是5，而次大是5，因为存在多个5，此时次大应该是5？
这可能涉及到问题定义中的第k大是否允许重复。例如，在数组[5,5,4,3]中，第二大元素是5，第三大是4。所以当分治方法合并时，当左右max都是5时，次大应该取5，而不是left.second或right.second中的较大者。那如何调整合并策略？
或许，当左右max相等时，合并后的second应该是max(left.second, right.second, left.max)。但是，left.max等于合并后的max，所以此时需要考虑合并后的max是否出现多次。例如，当左右max相等时，合并后的max出现至少两次，所以次大应该是合并后的max本身？
这时候，合并后的second应该取合并后的max和左右second中的较大者。例如，当左右max相等时，合并后的second是max(left.max, left.second, right.second)。因为当left.max等于合并后的max时，若存在多个该max值，则次大应为该max值。
例如，左max=5，left.second=4；右max=5，right.second=3。合并后的max=5，合并后的second是max(5,4,3)=5。此时正确，因为数组中有两个5，所以次大是5。
另一个例子，左max=5，left.second=5；右max=5，right.second=5。合并后的second是5，正确。
而当左max=5，left.second=4；右max=5，right.second=5。合并后的second是5，正确。
所以，正确的合并策略应该是：
当合并左右两部分时：
如果左max > 右max：
合并后的max = 左max
合并后的second = max(右max, 左.second)
elif 右max > 左max：
合并后的max = 右max
合并后的second = max(左max, 右.second)
else:
合并后的max = 左max （或右max）
合并后的second = max(left.second, right.second, left.max) → 但left.max等于right.max，所以这等价于max(left.second, right.second, left.max)
但此时，合并后的max是left.max，而合并后的second应为max(left.second, right.second, left.max)。不过，left.max是最大的，所以此时合并后的second应为max(left.second, right.second)，因为 left.max已经作为max了，所以次大应该在left.second和 right.second中选最大的？
或者，当左右max相等时，次大应该是两个max中的一个，即等于max，因为存在至少两个max。比如，数组中有两个5，那么次大是5。但如果是三个5，次大还是5。这种情况下，合并后的second应该还是max本身？
这时候，当左右的max相等时，次大应该是max（因为存在多个max值），所以合并后的second应该取max(left.max, left.second, right.second)。但left.max等于合并后的max，所以次大应该是max(max, left.second, right.second)中的次大。比如，max是5，left.second是4，right.second是3，那么合并后的second是5？
但这样在数组[5,4,5,3]的情况下，合并后的second是5，而排序后的数组是[5,5,4,3]，所以正确。
所以，正确的合并策略当左右max相等时，合并后的second应该取max(left.second, right.second, left.max)。因为当left.max和right.max相等时，合并后的数组中有至少两个该max值，因此次大应该是max值本身。例如：
对于数组[5,4,5,3]，合并后的max是5，合并后的second是max(4,3,5)=5，正确。
对于数组[5,5,4,3]，合并后的max是5，second是max(5,3,5)=5，正确。
对于数组[5,5,5]，合并后的second是5，正确。
而如果原数组是[5,6,6,3]，分治后的左右max分别为6和6，left.second可能是5，right.second是3。合并后的max是6，second是max(5,3,6)=6，正确，因为原数组的第二大是6。
这样，合并策略在左右max相等的情况下，将合并后的second设置为max(left.second, right.second, max)，这样就能正确得到次大值。
那么，调整后的合并逻辑应该是：
当 left_max > right_max:
合并后的最大是 left_max，次大是 max(right_max, left_second)
elif right_max > left_max:
合并后的最大是 right_max，次大是 max(left_max, right_second)
else:
合并后的最大是 left_max (或 right_max，相等)
合并后的次大是 max(left_second, right_second, left_max)
这似乎能够处理各种情况。现在需要验证几个测试案例：
案例1：[3,1,4,2]
分治步骤：
分成左[3,1]和右[4,2]
左部分：max=3，second=1
右部分：max=4，second=2
合并：left_max=3 < right_max=4 → 合并后的max=4，次大=max(3,2)=3 → 所以最终次大是3？但原数组排序是[4,3,2,1]，第二大是3，正确。
案例2：[5,5,4,3]
分治步骤：
左[5,5] → max=5，second=5
右[4,3] → max=4，second=3
合并：left_max=5 > right_max=4 → 合并后的max=5，次大= max(4,5)=5 → 正确，原数组第二大是5.
案例3：[5,4,5,3]
分治步骤：
分左[5,4]和右[5,3]
左部分：max=5，second=4
右部分：max=5，second=3
合并时 left_max == right_max → 合并后的max=5，次大= max(4,3,5)=5 → 正确，数组第二大是5.
案例4：[6,5,6,3]
分治步骤：
左[6,5] → max=6，second=5
右[6,3] → max=6，second=3
合并时 left_max等于 right_max → 次大=max(5,3,6)=6 → 正确，原数组排序后的第二大是6.
案例5：[5,5,5,5]
分治步骤：
分左右各两个5 → 每个返回max=5，second=5
合并后的次大是5 → 正确.
案例6：[5,3,2,8,6]
分治步骤：
拆分到更细粒度。比如，假设分割成左[5,3,2]和右[8,6]。或者，可能需要递归地将数组分成两部分，直到只剩1或2个元素。
假设分治是二分法，比如每次将数组分成左右两半。
例如，数组[5,3,2,8,6]分成左[5,3,2]和右[8,6]。然后处理左边：
左[5,3,2] → 分成左[5]和右[3,2].
左[5] → max=5，second=-∞（假设初始时次大为负无穷）
右[3,2] → max=3，second=2 → 合并后的左半部分max=5，次大= max(3, -∞)=3 → 合并后的左半部分max=5，second=3.
右半部分[8,6] → max=8，second=6.
合并整体： left_max=5 < right_max=8 → 合并后的max=8，次大= max(5,6)=6 → 正确，原数组排序后的第二大是6.
这样，合并策略是正确的。
现在，编写代码。递归函数返回当前区间的最大值和第二大值。对于数组的拆分，可以使用起始和结束索引，每次分成两半。递归终止条件是：
当数组长度为1时，返回（max=该元素， second=-∞）
当数组长度为2时，返回（max(a,b), min(a,b)）
否则，拆分成左右两部分，递归处理，然后合并。
例如，Python代码：
def find_second_largest(arr, start, end):
if start == end:
return (arr[start], -float('inf'))
elif end - start == 1:
if arr[start] > arr[end]:
return (arr[start], arr[end])
else:
return (arr[end], arr[start])
else:
mid = (start + end) // 2
left_max, left_second = find_second_largest(arr, start, mid)
right_max, right_second = find_second_largest(arr, mid+1, end)
if left_max > right_max:
current_max = left_max
current_second = max(right_max, left_second)
elif right_max > left_max:
current_max = right_max
current_second = max(left_max, right_second)
else:
current_max = left_max
current_second = max(left_second, right_second, left_max)
return (current_max, current_second)
测试这个函数：
例如，数组[3,1,4,2]的调用：
函数返回的second应该是3，正确。
数组[5,5,4,3]返回的second是5.
数组[6,5,6,3]返回的second是6.
但需要处理当左右max相等时，如何合并的情况。比如，在函数中，当left_max等于right_max时，current_second的计算是否正确？
在上述代码中，当left_max == right_max时，current_second = max(left_second, right_second, left_max)。但是，在代码中的合并逻辑中，else块中的current_second被设置为max(left_second, right_second, left_max)？
或者，原代码中的else块是否考虑了这种情况？
看代码中的合并逻辑：
当left_max > right_max时：
current_second = max(right_max, left_second)
当right_max > left_max时：
current_second = max(left_max, right_second)
否则（即left_max == right_max）:
current_second = max(left_second, right_second, left_max)
是的，当left_max等于right_max时，current_second取三者中的最大值。例如，left_second=4，right_second=3，left_max=5 → current_second = max(4,3,5)=5。
这样处理是正确的，因为当左右max相等时，合并后的次大应该是max(left_second, right_second, left_max)。其中，left_max等于right_max，所以取其中最大的那个，即left_max。这样，合并后的次大就是left_max，从而正确反映数组中有多个最大值的情况。
综上，这段代码应该能够正确找到数组中的第二大元素。用户的问题中的示例可能需要考虑数组是否允许重复元素，而根据引用中的问题描述，允许重复的情况下，该方法是正确的。
现在，用户需要示例代码。根据上述分析，可以提供一个分治算法的Python实现。并分析其时间复杂度和空间复杂度。
时间复杂度方面，每次递归将数组分成两半，合并操作的时间是常数时间，所以总的时间复杂度是O(n)，因为每个层级的处理时间是O(n)（每一层处理所有元素，但合并操作是O(1) per node），但实际可能类似于归并排序的O(n log n)。或者，需要重新计算时间复杂度。例如，每次递归处理两个子问题，每个子问题规模是n/2，合并时间O(1)。根据主定理，时间复杂度为T(n) = 2T(n/2) + O(1)，解得O(n)。因为每个递归层级的总操作是O(1)*O(n)？或者需要更仔细的分析。可能实际的时间复杂度是O(n)，因为每个元素被处理的次数为O(log n)次？或者每个层级的处理时间总和是O(n)，因为每个元素参与一次合并操作，每次合并操作是O(1)。所以总时间复杂度是O(n)，因为总共有log n层级，每层处理n个元素，但每个元素在每个层级仅被处理一次？或者可能不是这样。比如，对于每个元素，在每一层级的递归中，都会被比较两次？可能分治的时间复杂度是O(n)，因为合并操作是常数时间，而递归深度是log n，每个层级的处理时间是O(n)吗？
或者，每个元素参与log n次合并操作，每个合并操作是常数时间，总时间复杂度是O(n)？例如，在每一层递归中，每个元素所在的区间被合并一次，合并操作是O(1)。所以总共有O(n)次合并操作？或者可能总共有O(n)次合并操作。例如，对于n个元素，递归树有O(n)个节点？不太确定。但根据常规分治算法的时间复杂度分析，比如归并排序的时间复杂度是O(n log n)，因为每个层级的合并操作是O(n)，总共有log n层。但在这个分治算法中，每个层级的合并操作是O(1) per split，所以总时间可能是O(n)。或者，每个递归调用处理一个区间，总共有O(n)个递归调用？可能不是，因为分治的递归树深度是log n，每层有2^k个节点，总共有O(n)个节点。每个节点处理的时间是O(1)，所以总时间复杂度是O(n)。这可能正确，因为每个节点处理的时间是常数，总节点数是O(n)（因为每次分治将数组分成两半，总共有n + n/2 + n/4 + ... ≈ 2n个节点）。因此，总时间复杂度是O(n)，空间复杂度是O(log n)（递归栈深度）。
综上，分治算法的时间复杂度是O(n)，空间复杂度是O(log n)。
示例代码：
def find_second_largest(arr):
def helper(start, end):
if start == end:
return (arr[start], -float('inf'))
elif end - start == 1:
a, b = arr[start], arr[end]
return (max(a, b), min(a, b))
else:
mid = (start + end) // 2
left_max, left_second = helper(start, mid)
right_max, right_second = helper(mid+1, end)
if left_max > right_max:
current_max = left_max
current_second = max(right_max, left_second)
elif right_max > left_max:
current_max = right_max
current_second = max(left_max, right_second)
else:
# 当左右最大值相等时，次大值取左右次大和当前max中的最大
current_max = left_max
current_second = max(left_second, right_second, left_max)
return (current_max, current_second)
if len(arr) < 2:
return None # 数组元素不足，无法确定第二大元素
max_val, second_val = helper(0, len(arr)-1)
return second_val
测试案例：
arr = [3,1,4,2]
print(find_second_largest(arr)) # 应输出3
arr = [5,5,4,3]
print(find_second_largest(arr)) # 应输出5
arr = [6,5,6,3]
print(find_second_largest(arr)) # 应输出6
arr = [5,3,2,8,6]
print(find_second_largest(arr)) # 应输出6
这样，代码应该能够正确返回结果。
最后，用户可能还需要分析该方法的优缺点。比如，分治算法的时间复杂度为O(n)，而空间复杂度为O(log n)（递归栈）。而其他方法，如遍历数组两次，第一次找最大，第二次找次大，时间复杂度O(n)，空间O(1)。分治方法可能在效率上不如线性扫描，但可能适用于并行计算，或者作为分治思想的练习。</think>### 分治算法求数组中第二大元素的实现
#### 分治策略设计
分治算法通过递归地将数组划分为左右两部分，分别求解各子数组的**最大值**和**次大值**，再通过合并策略得到全局的第二大元素。合并时需比较左右子数组的最大值，并综合计算次大值[^3]。
#### 合并规则
1. **左子数组最大值 > 右子数组最大值**
全局最大值取左子数组最大值，次大值为右子数组最大值与左子数组次大值的较大者。
2. **右子数组最大值 > 左子数组最大值**
全局最大值取右子数组最大值，次大值为左子数组最大值与右子数组次大值的较大者。
3. **左右子数组最大值相等**
全局最大值取任意一侧的最大值，次大值为左右子数组次大值与当前最大值的最大者（确保重复最大值的情况正确处理）。
#### 代码实现
```python
def find_second_largest(arr):
def helper(start, end):
if start == end:
return (arr[start], -float('inf'))
elif end - start == 1:
a, b = arr[start], arr[end]
return (max(a, b), min(a, b))
else:
mid = (start + end) // 2
left_max, left_second = helper(start, mid)
right_max, right_second = helper(mid + 1, end)
if left_max > right_max:
current_max = left_max
current_second = max(right_max, left_second)
elif right_max > left_max:
current_max = right_max
current_second = max(left_max, right_second)
else:
current_max = left_max
current_second = max(left_second, right_second, left_max)
return (current_max, current_second)
if len(arr) < 2:
return None # 数组元素不足，无法确定第二大元素
max_val, second_val = helper(0, len(arr) - 1)
return second_val
```
#### 复杂度分析
- **时间复杂度**：$O(n)$
递归深度为$O(\log n)$，每层合并操作的时间总和为$O(n)$，总时间复杂度为$O(n)$。
- **空间复杂度**：$O(\log n)$
递归栈的深度为$O(\log n)$。
#### 示例验证
1. **输入**：`[3, 1, 4, 2]`
**输出**：`3`
**解释**：最大值为4，次大值为3。
2. **输入**：`[5, 5, 4, 3]`
**输出**：`5`
**解释**：最大值为5，次大值为5（允许重复值）。
---
###
最低0.47元/天 解锁文章
扫一扫
2070
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
