- 博客(166)
- 收藏
- 关注
RSS订阅原创 89.格雷编码 python
生成 n 位格雷码序列的一种常用方法是使用反射（或镜像）构造法。这种方法的基本思想是从一个已知的较小位数的格雷码开始，通过反射和前缀添加来构建更大的格雷码。[0,1,3,2] 的二进制表示是 [00,01,11,10]。给你一个整数 n ，返回任一有效的 n 位格雷码序列。第一个 和 最后一个 整数的二进制表示 恰好一位不同。每对 相邻 整数的二进制表示 恰好一位不同 ，且。一个整数在序列中出现 不超过一次。n 位格雷码序列 是一个由。每个整数都在范围 [0,输出：[0,1,3,2]
2025-01-22 09:15:28
1647
原创 88.合并两个有序数组 python
输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3。合并结果是 [1,2,2,3,5,6] ，其中斜体加粗标注的为 nums1 中的元素。输入：nums1 = [0], m = 0, nums2 = [1], n = 1。输入：nums1 = [1], m = 1, nums2 = [], n = 0。解释：需要合并 [1,2,3] 和 [2,5,6]。解释：需要合并的数组是 [] 和 [1]。输出：[1,2,2,3,5,6]
2025-01-21 10:38:03
1080
原创 87.扰乱字符串 python
使用下面描述的算法可以扰乱字符串 s 得到字符串 t ：如果字符串的长度为 1 ，算法停止如果字符串的长度 > 1 ，执行下述步骤：在一个随机下标处将字符串分割成两个非空的子字符串。即，如果已知字符串 s ，则可以将其分成两个子字符串 x 和 y ，且满足 s = x + y 。随机 决定是要「交换两个子字符串」还是要「保持这两个子字符串的顺序不变」。即，在执行这一步骤之后，s 可能是 s = x + y 或者 s = y + x 。在 x 和 y 这两个子字符串上继续从步骤 1 开始递归执行此算
2025-01-21 09:28:25
786
原创 86.分隔链表 python
给你一个链表的头节点head和一个特定值x，请你对链表进行分隔，使得所有小于x的节点都出现在大于或等于x的节点之前。然后，我们将这两个链表连接起来，以保持原始链表中每个分区内的相对顺序。要解决这个问题，我们可以创建两个新的链表：一个用于存储所有小于。输入：head=[1,4,3,2,5,2],x=3。输入：head=[2,1],x=2。链表中节点的数目在范围[0,200]内。的节点，另一个用于存储所有大于或等于。输出：[1,2,2,4,3,5]
2025-01-20 10:57:50
366
原创 85.最大矩形 python
这个问题被称为“最大矩形问题”，它可以通过将每一行视为柱状图的底，然后计算每个柱状图中最大的矩形面积来解决。具体来说，我们可以使用动态规划（DynamicProgramming,DP）的方法来构建高度数组，并利用之前提到的“柱状图中最大的矩形”算法来计算每行的最大矩形面积。输入：matrix=[[“1”,“0”,“1”,“0”,“0”],[“1”,“0”,“1”,“1”,“1”],[“1”,“1”,“1”,“1”,“1”],[“1”,“0”,“0”,“1”,“0”]]解释：最大矩形如上图所示。
2025-01-20 09:20:19
380
原创 84.柱状图中最大的矩形 python
这个问题被称为“柱状图中最大的矩形”问题，可以通过使用单调栈（monotonic stack）的方法来高效地解决。该方法的时间复杂度为 O(n)，其中 n 是柱子的数量。：对于每个从栈中弹出的柱子，其宽度是从它左边第一个比它矮的柱子到右边第一个比它矮的柱子之间的距离减去 1。：为了简化代码逻辑，在原始数组两端各添加一个高度为 0 的柱子，这样可以确保所有柱子都能被正确处理，包括最后一个柱子。：我们维护一个递增的栈，用于存储柱子的索引。求在该柱状图中，能够勾勒出来的矩形的最大面积。
2025-01-17 11:51:05
713
原创 83.删除排序链表中的重复元素 python
要解决这个问题，我们可以使用一个指针遍历链表，并在遍历过程中删除重复的节点。由于链表已经是排序的，所以任何重复的元素都会连续出现在链表中。我们只需要保留每个值的第一个出现，并移除后续相同值的所有节点。给定一个已排序的链表的头 head ， 删除所有重复的元素，使每个元素只出现一次。返回 已排序的链表。输入：head = [1,1,2,3,3]链表中节点数目在范围 [0, 300] 内。输入：head = [1,1,2]题目数据保证链表已经按升序 排列。输出：[1,2,3]
2025-01-17 09:19:06
344
原创 82.删除排序链表中的重复元素Ⅱ python
要解决这个问题，我们可以使用一个哑节点（dummy node）和两个指针来遍历链表。哑节点的目的是简化某些边界条件的处理，比如当头节点需要被删除时。两个指针中，一个用于追踪当前正在检查的节点（给定一个已排序的链表的头 head ， 删除原始链表中所有重复数字的节点，只留下不同的数字。返回 已排序的链表。通过这种方法，我们可以有效地删除排序链表中的所有重复元素，只留下那些唯一的数字。输入：head = [1,2,3,3,4,4,5]输入：head = [1,1,1,2,3]输出：[1,2,5]
2025-01-16 12:01:47
779
原创 81.搜索旋转数组Ⅱ python
在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转 ，使数组变为 [nums[k], nums[k+1], …, nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,4,4,5,6,6,7] 在下标 5 处经旋转后可能变为 [4,5,6,6,7,0,1,2,4,4]。输入：nums = [2,5,6,0,0,1,2], target = 0。输入：nums = [2,5,6,0,0,1,2], target = 3。
2025-01-16 09:22:21
1158
原创 80.删除有序数组中的重复项Ⅱ python
解释：函数应返回新长度 length = 7, 并且原数组的前七个元素被修改为 0, 0, 1, 1, 2, 3, 3。解释：函数应返回新长度 length = 5, 并且原数组的前五个元素被修改为 1, 1, 2, 2, 3。给你一个有序数组 nums ，请你原地删除重复出现的元素，使得出现次数超过两次的元素只出现两次 ，返回删除后数组的新长度。输入：nums = [0,0,1,1,1,1,2,3,3]输出：7, nums = [0,0,1,1,2,3,3]输入：nums = [1,1,1,2,2,3]
2025-01-15 15:54:10
1533
原创 79.单词搜索 python
输入：board = [[“A”,“B”,“C”,“E”],[“S”,“F”,“C”,“S”],[“A”,“D”,“E”,“E”]], word = “ABCCED”输入：board = [[“A”,“B”,“C”,“E”],[“S”,“F”,“C”,“S”],[“A”,“D”,“E”,“E”]], word = “ABCB”输入：board = [[“A”,“B”,“C”,“E”],[“S”,“F”,“C”,“S”],[“A”,“D”,“E”,“E”]], word = “SEE”
2025-01-15 09:22:23
593
原创 78.子集 python
两种方法都能有效地生成所有子集，并且在最坏情况下的时间复杂度都是 O(2^n)，其中 n 是输入数组的长度，因为每个元素都有两种选择——要么在子集中，要么不在子集中。回溯法是一种通过构建所有可能的解决方案并逐步排除不符合条件的方案来解决问题的技术。对于子集问题，我们可以从空集开始，逐步添加元素，直到我们遍历了所有的元素。每次迭代时，我们将当前数字添加到现有的每个子集上，以创建新的子集。输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]输出：[[],[0]]
2025-01-14 18:05:01
878
原创 77.组合 python
回溯是一种递归算法，它尝试构建所有的解，并在发现当前路径不能形成一个完整的解时撤销选择（即回溯）。对于组合问题，回溯法非常适合，因为它允许我们探索所有可能的选项。给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。这段代码实现了上述的回溯算法，用来生成所有可能的 k 个数的组合。找到一个完整的组合时，它会将其复制并添加到最终的结果列表。是内部定义的辅助函数，用于执行实际的回溯逻辑。输入：n = 4, k = 2。输入：n = 1, k = 1。列表而导致结果被改变的问题。
2025-01-14 09:14:24
322
原创 76.最小覆盖子串 python
这个方法可以在 O(m + n) 的时间复杂度内解决问题，其中 m 是字符串 s 的长度，n 是字符串 t 的长度。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 “”。解释：最小覆盖子串 “BANC” 包含来自字符串 t 的 ‘A’、‘B’ 和 ‘C’。对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。输入：s = “ADOBECODEBANC”, t = “ABC”输入: s = “a”, t = “aa”输入：s = “a”, t = “a”
2025-01-13 15:50:51
861
原创 75.颜色分类 python
这种方法的时间复杂度为 O(n)，其中 n 是数组的长度，因为我们只遍历了一次数组。空间复杂度为 O(1)，因为我们只使用了常数级别的额外空间。给定一个包含红色、白色和蓝色、共 n 个元素的数组 nums ，原地 对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。这种方法确保了所有 0 都被移到数组的前面，所有 2 都被移到数组的后面，而所有 1 自然位于中间。输入：nums = [2,0,2,1,1,0]输入：nums = [2,0,1]输出：[0,0,1,1,2,2]
2025-01-13 09:17:36
789
原创 74.搜索二维矩阵 python
这种方法的时间复杂度为 O(log(m * n))，因为我们将二维矩阵视为一个一维的有序数组进行二分查找。输入：matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 13。输入：matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 3。由于矩阵具有每行和每列都是有序的特点，可以将二维矩阵视为一个一维的有序数组。否则，返回 false。每行的第一个整数大于前一行的最后一个整数。
2025-01-10 10:24:01
1950
原创 73.矩阵置零 python
为了在不使用额外空间的情况下完成这个任务，我们可以利用矩阵的第一行和第一列来记录哪些行和列需要被置零。请使用 原地 算法。这种方法确保了我们只使用常数级别的额外空间（O(1)），并且有效地完成了原地算法的要求。输入：matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]输入：matrix = [[1,1,1],[1,0,1],[1,1,1]]输出：[[0,0,0,0],[0,4,5,0],[0,3,1,0]]输出：[[1,0,1],[0,0,0],[1,0,1]]
2025-01-10 09:30:28
715
原创 72.编辑距离 python
我们可以构建一个二维数组。给你两个单词 word1 和 word2， 请返回将 word1 转换成 word2 所使用的最少操作数。输入：word1 = “intention”, word2 = “execution”inention -> enention (将 ‘i’ 替换为 ‘e’)enention -> exention (将 ‘n’ 替换为 ‘x’)exention -> exection (将 ‘n’ 替换为 ‘c’)horse -> rorse (将 ‘h’ 替换为 ‘r’)
2025-01-09 18:20:18
519
原创 71.简化路径 python
给你一个字符串 path ，表示指向某一文件或目录的 Unix 风格 绝对路径 （以 ‘/’ 开头），请你将其转化为 更加简洁的规范路径。此外，路径仅包含从根目录到目标文件或目录的路径上的目录（即，不含 ‘.’ 或 ‘…输入：path = “/home/user/Documents/…任意多个连续的斜杠（即，‘//’ 或 ‘///’）都被视为单个斜杠 ‘/’。’）均被视为有效的文件/目录名称。path 由英文字母，数字，‘.’，‘/’ 或 ‘_’ 组成。输入：path = “/home//foo/”
2025-01-09 09:12:49
990
原创 70.爬楼梯 python
这种方法的时间复杂度为 O(n)，因为我们只需要遍历一次从 2 到 n 的所有整数。而空间优化后的版本更是将空间复杂度降到了常数级别，非常适合处理较大的输入值（如题目提示中的 1 <= n <= 45）。，因此可以进一步优化空间复杂度为 O(1)，只使用两个变量来存储这两个状态值。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？需要 n 阶你才能到达楼顶。注意到在上面的实现中，我们只需要前两个状态值。解释：有两种方法可以爬到楼顶。解释：有三种方法可以爬到楼顶。
2025-01-08 10:47:20
487
原创 69.x的平方根 python
这种方法的时间复杂度为 O(log(min(x, 46340)))，即对数级别的时间复杂度，非常高效。空间复杂度为 O(1)，因为我们只使用了常数级别的额外空间。（因为 ( \sqrt{2^{31}-1} \approx 46340 )）。注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5。, 由于返回类型是整数，小数部分将被舍去。由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去。给你一个非负整数 x ，计算并返回 x 的 算术平方根。
2025-01-08 09:29:41
322
原创 68.文本左右对齐 python
输入:words = [“Science”,“is”,“what”,“we”,“understand”,“well”,“enough”,“to”,“explain”,“to”,“a”,“computer.”,“Art”,“is”,“everything”,“else”,“we”,“do”]，maxWidth = 20。输入: words = [“This”, “is”, “an”, “example”, “of”, “text”, “justification.”], maxWidth = 16。
2025-01-07 12:06:00
884
原创 67.二进制求和 python
给你两个二进制字符串 a 和 b ，以二进制字符串的形式返回它们的和。输入:a = “11”, b = “1”输出：“100”输入：a = “1010”, b = “1011”输出：“10101”1 <= a.length, b.length <= 10410^4104a 和 b 仅由字符 ‘0’ 或 ‘1’ 组成字符串如果不是 “0” ，就不含前导零为了实现两个二进制字符串的加法，我们可以模拟手工计算二进制加法的过程。具体步骤如下：初始化变量：逐位相加：处理最后的进位：构建最终结果：代码解释
2025-01-07 09:31:12
611
原创 66.加一 python
空间复杂度为 O(1)，因为我们只使用了常数级别的额外空间（除了可能需要在最前面插入一个 1 的情况）。根据题目数据范围（1 <= digits.length <= 100），这种解法是高效且可行的。给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。输入：digits = [4,3,2,1]输入：digits = [1,2,3]因此，结果应该是 [1,0]。输出：[4,3,2,2]输出：[1,2,4]
2025-01-06 11:55:18
243
原创 65.有效数字 python
例如，下面的都是有效数字：“2”, “0089”, “-0.1”, “+3.14”, “4.”, “-.9”, “2e10”, “-90E3”, “3e+7”, “+6e-1”, “53.5e93”, “-123.456e789”，而接下来的不是：“abc”, “1a”, “1e”, “e3”, “99e2.5”, “–6”, “-+3”, “95a54e53”。一个 整数 定义为一个 可选符号 ‘-’ 或 ‘+’ 后面跟着 数字。指数 定义为指数符号 ‘e’ 或 ‘E’，后面跟着一个 整数。
2025-01-06 10:27:42
1066
原创 64.最小路径和 python
这种方法的时间复杂度为 O(m * n)，空间复杂度为 O(1)（因为我们直接在原数组上进行修改）。根据题目数据范围（1 <= m, n <= 200），这种解法是高效且可行的。给定一个包含非负整数的 m x n 网格 grid ，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。输入：grid = [[1,3,1],[1,5,1],[4,2,1]]输入：grid = [[1,2,3],[4,5,6]]解释：因为路径 1→3→1→1→1 的总和最小。，即到达右下角的最小路径和。
2025-01-03 11:34:04
394
原创 63.不同路径Ⅱ python
一个机器人初始位于 左上角（即 grid[0][0]）。机器人尝试移动到 右下角（即 grid[m - 1][n - 1]）。这种方法的时间复杂度为 O(m * n)，空间复杂度同样为 O(m * n)。根据题目数据范围（1 <= m, n <= 100），这种解法是高效且可行的。网格中的障碍物和空位置分别用 1 和 0 来表示。输入：obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]输入：obstacleGrid = [[0,1],[0,0]]
2025-01-03 10:26:19
740
原创 62.不同路径 python
这两种方法的时间复杂度均为 O(m * n)，但组合数学方法的空间复杂度更低，为 O(1)，而动态规划方法的空间复杂度为 O(m * n)。根据题目数据范围（1
2025-01-02 17:32:37
477
原创 61.旋转链表 python
这种方法的时间复杂度为 O(n)，其中 n 是链表的长度，因为我们只需要遍历链表几次。空间复杂度为 O(1)，因为我们只使用了常数级别的额外空间。给你一个链表的头节点 head ，旋转链表，将链表每个节点向右移动 k 个位置。输入：head = [1,2,3,4,5], k = 2。输入：head = [0,1,2], k = 4。链表中节点的数目在范围 [0, 500] 内。输出：[4,5,1,2,3]输出：[2,0,1]
2025-01-02 11:05:34
404
原创 60.排列序列 python
对于题目给定的 n 范围 (1 <= n <= 9)，这种方法是非常高效的。该方法的核心思想是利用阶乘数系统（Factorial Number System），通过逐步确定每一位数字，从而直接构造出第。由于 n 的范围是 1 到 9，暴力法虽然可行但效率不高，因此推荐使用数学方法来高效解决问题。个排列，可以使用两种主要方法：暴力法（生成所有排列然后选择第。给定 n 和 k，返回第 k 个排列。输入：n = 3, k = 3。输入：n = 4, k = 9。输入：n = 3, k = 1。
2024-12-31 10:33:07
612
原创 59.螺旋矩阵Ⅱ python
生成一个 n x n 的螺旋矩阵可以通过模拟顺时针填充的过程来实现。我们从矩阵的左上角开始，按照“向右 -> 向下 -> 向左 -> 向上”的顺序循环地填充数字，直到所有位置都被填满。给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix。这种方法保证了矩阵按顺时针方向螺旋填充，并且适用于任意大小为 n x n 的矩阵，其中 1 <= n <= 20。输出：[[1,2,3],[8,9,4],[7,6,5]]
2024-12-31 09:40:18
471
原创 通义千问QvQ-72B-Preview模型部署
HuggingFace Space体验：https://huggingface.co/spaces/Qwen/QwQ-72B-preview。Modelscope创空间体验：https://modelscope.cn/studios/Qwen/QwQ-32B-preview。Modelscope开源地址：https://modelscope.cn/models/Qwen/QwQ-72B-Preview。本次实验在4090上进行测试，为了顺利加载模型，下载的是量化版本的模型。
2024-12-30 17:21:11
1872
原创 58.最后一个单词的长度 python
中最后一个单词的长度。根据题目描述，单词是由字母组成的、不包含任何空格字符的最大子字符串。我们可以从字符串的末尾开始向前遍历，这样可以有效地找到最后一个单词并计算其长度。的长度，因为我们最多只需要遍历整个字符串一次。给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中 最后一个 单词的长度。解释：最后一个单词是长度为 6 的“joyboy”。解释：最后一个单词是“World”，长度为 5。解释：最后一个单词是“moon”，长度为 4。输入：s = “Hello World”
2024-12-30 10:48:26
817
原创 57.插入区间 python
给你一个 无重叠的 ，按照区间起始端点排序的区间列表 intervals，其中 intervals[i] = [starti, endi] 表示第 i 个区间的开始和结束，并且 intervals 按照 starti 升序排列。输入：intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]解释：这是因为新的区间 [4,8] 与 [3,5],[6,7],[8,10] 重叠。输出：[[1,2],[3,10],[12,16]]
2024-12-30 09:36:32
838
原创 56.合并区间 python
然后遍历这些排序后的区间，尝试将相邻的区间合并，如果它们之间有重叠或恰好相连（即一个区间的结束等于下一个区间的开始）。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间。这一步骤对于后续的合并过程至关重要，因为它保证了当我们处理到一个新的区间时，它要么可以与前面的某个区间合并，要么它就是新的非重叠区间的开始。输入：intervals = [[1,3],[2,6],[8,10],[15,18]]输出：[[1,6],[8,10],[15,18]]输出：[[1,5]]
2024-12-27 10:18:42
803
原创 55.跳跃游戏 python
核心思想是跟踪我们能够到达的最远位置，并随着遍历数组不断更新这个最远位置。如果在遍历过程中，当前索引超过了能够到达的最远位置，则说明无法到达最后；如果最远位置达到了或超过了数组的最后一个下标，则可以提前返回。数组中的每个元素代表你在该位置可以跳跃的最大长度。解释：无论怎样，总会到达下标为 3 的位置。解释：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。判断你是否能够到达最后一个下标，如果可以，返回 true；来记录能到达的最大索引位置，初始值为 0。
2024-12-27 09:23:32
294
原创 54.螺旋矩阵 python
要以顺时针螺旋顺序遍历一个矩阵，我们可以使用一个循环来逐步剥去矩阵的外层，并在每一轮迭代中按顺序添加元素到结果列表。给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]输出：[1,2,3,4,8,12,11,10,9,5,6,7]随着每一圈的完成，更新边界条件，直到所有的元素都被访问过。
2024-12-26 11:50:49
393
原创 53.最大子数组和 python
每当我们在数组中移动到下一个元素时，我们就决定是否将这个元素加到当前的最大和上，还是重新开始一个新的子数组。给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。进阶：如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的 分治法 求解。输入：nums = [-2,1,-3,4,-1,2,1,-5,4]解释：连续子数组 [4,-1,2,1] 的和最大，为 6。输入：nums = [5,4,-1,7,8]），另一个用于存储到目前为止发现的最大和（
2024-12-26 09:42:51
419
原创 52.N皇后Ⅱ python
与求解所有n皇后问题的解决方案类似，这里的目标是计算有多少种不同的方法可以放置皇后，而不是实际生成这些布局。因此，我们可以简化原始的n皇后求解算法，只关注于计数。此方法的时间复杂度主要取决于递归树的大小，最坏情况下需要探索所有可能的皇后配置，但通过提前剪枝（即尽早发现冲突），可以大大减少不必要的计算。n 皇后问题 研究的是如何将 n 个皇后放置在 n × n 的棋盘上，并且使皇后彼此之间不能相互攻击。给你一个整数 n ，返回 n 皇后问题 不同的解决方案的数量。的值，即不同解决方案的数量。
2024-12-25 10:22:28
425
原创 51.N皇后 python
对于n皇后问题，这意味着尝试在棋盘上的每一行放置一个皇后，并检查该位置是否会导致冲突（即两个皇后在同一列或同一对角线上）。每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 ‘Q’ 和 ‘.’ 分别代表了皇后和空位。n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。给你一个整数 n ，返回所有不同的 n 皇后问题 的解决方案。输出：[[“Q”]]
2024-12-25 09:19:16
907
空空如也
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人