目录
前言
接着上一篇文章，我已经坚持刷了八天的题和更新了八天的博客，八天一共刷了25题，有难有易，坚持一周对我来说已经是很大的一个进步了，但是这个活动昨天才开始哦！第一届LeetCode刷题打卡赢现金活动，其他小伙伴快来和我们一起卷起来吧！！！！
肝就完事，不说了我要上号了！！
2021-10-16
题目·
1.链表相交
2.两数相加
3.反转链表2
题解
1.链表相交
这个链表相交其实就是相交的地方是相同的地址，所以我们可以遍历，然后在判定两个链表是否相等。
如果两个链表长度相等的话，就直接可以使用循环判断来判断是否四相同的链表，如果链表不是等长的话，先求出两个链表的长度，然后取两者的差值，然后链表较长的那个向前移动差值个单位，然后在开始for循环比较！！
2.两数相加
思路：我们可以先遍历链表，然后把链表里面的值存取到数组中，然后在从数组里面取出相加获得所得值，并转换为字符串的形式，然后创建一个新的指针，指向每一个字符串，并输出这个链表。
3. 反转链表：二
思路：
先把指定区域的链表给拆出来，定义一个如反转链表第一题一样的函数，然后把指定区域的链表给传参到这个数组，反转后在传出，并给外面的链表链接！！
下面我花了一个简图，大家凑合着看看嘿嘿嘿嘿。
代码
1.链表相交
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
struct ListNode *p1 = headA;
struct ListNode *p2 =headB;
int i = 0 , j = 0 ,sum ;
p1 = headA;
p2 = headB;
while (p1 != NULL){
p1 = p1 -> next;
++i;
}
while ( p2 != NULL){
p2 = p2 -> next;
j++;
}
p1 = headA;
p2 = headB;
if ( i > j){
sum = i - j;
while (sum> 0){
p1 = p1->next;
--sum;
}}else{
sum = j - i;
while (sum ){
p2 = p2 -> next;
--sum;
}
}
while (p1 && p2 ){
if (p1 == p2 ){
return p1;
}
p1 = p1 -> next ;
p2 = p2 -> next ;}
return NULL;
}2.两数相加
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
def ltn(listnode):
# 将ListNode转换为list，并储存到listTemp里
listTemp=[]
temp=0
while temp<100:
try:
listTemp.append(listnode.val)
listnode=listnode.next
except:
break
temp+=1
# 将list翻转并转换成数字（string形式）
listTemp.reverse()
string=""
for item in listTemp:
string+=str(item)
return string
class Solution:
def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
temp=0
num1=ltn(l1)
num2=ltn(l2)
# 利用上述函数将l1和l2转换为数字
sum=str(int(num1)+int(num2))
# 转为数字，相加
sumlist=ListNode(int(sum[0]))
try:
for order in range(1,len(sum)):
sumlist=ListNode(int(sum[order]),sumlist)
except:
pass
return(sumlist)3.反转链表二
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
void reverse( struct ListNode *head){
struct ListNode *pre = NULL;
struct ListNode *cur = head;
while (cur != NULL) {
struct ListNode *next = cur->next;
cur->next = pre;
pre = cur;
cur = next;
}
}
struct ListNode* reverseBetween(struct ListNode* head, int left, int right){
struct ListNode * dump = malloc(sizeof(struct ListNode));
dump -> val = -1;
dump -> next = head;
struct ListNode * res = dump;
for ( int i = 0; i < left -1; i++){
res = res -> next ;}
struct ListNode * right1 = res;
for ( int j = 0 ; j < right - left + 1; j++ ){right1 = right1 -> next ;}
struct ListNode *leftNode = res->next;
struct ListNode *curr = right1->next;
res->next = NULL;
right1->next = NULL;
reverse(leftNode);
res->next = right1;
leftNode->next = curr;
return dump->next;
}
总结
又到了每天的总结时刻嘿嘿嘿嘿！！！
今天是第九天写算法题，我今天看了我总共刷的力扣有50道题嘿嘿。
虽然mid和hard还是很少，但是我还在进步，我相信慢慢的我掌握的算法知识储备会越来越多，对一些算法题也会越来越熟练的，十分期待那个时候的我会变成什么样子，就先从小目标慢慢的开始吧，相信自己，坚持住！！！！
看一下今天的手稿嘿嘿嘿嘿嘿！！！
2021-10-17
题目
1.回文数
2.二叉树的中序遍历
3.二叉树中搜索第k个最小的元素
4.字符串的排列
题解
1.回文数：
这个我们可以通过题意了解到，如果是负数的话，直接不用判断就是返回false，所以我们可以先不用考虑负数，直接对大于0的数进行判断是否为回文数，如果是就返回true，如果不是就返回false，用双指针fast指向最后一个数，slow慢指针指向第一个数，然后向中间移动！如果途中有不相等就直接返回false，反之true。
2.二叉树的中序遍历：
中序遍历就是，左-根-右，我们可以写一个递归函数，然后先把左子树添加，然后在来右子树，大家看代码就可以直接懂了哦!
3.二叉树中搜索第k个最小的元素：
这个题说实话我最开始还有看懂是什么意思，然后看评论才知道实在前k个找最小的，我们可以知道中序遍历是有序的，我们直接找第k个元素不就是这个最小了的吗！
4.字符串的排列
怎么来形容这个题呢，看它的难度是mid但是我没有学过回溯这个算法，我最开始以为用双指针很快就能做出来，但是！用双指针会超时，所以我看了题解，题解是用的回溯去来解这个题，我看了一下这个解法，开始我不是很能理解这个回溯法，然后我足足看了一个小时，差点崩溃，最后晚上吃完饭回来才看懂的题解，真是把我折磨的死死的，还真是自己实力不够呜呜呜。
题解大家可以去官方看哦，我还不能很好的表达出来。。。。。
代码
1.回文数
class Solution:
def isPalindrome(self, x: int) -> bool:
if x < 0:
return False
x = str(x)
slow = 0
fast = len(x) -1
while slow < len(x)//2:
if x[fast] != x[slow] :
return False
fast -= 1
slow +=1
return True2.二叉树的中序遍历
class Solution:
def inorderTraversal(self, root: TreeNode) -> List[int]:
stack =[]
def a(root):
if root:
a(root.left)
stack.append(root.val)
a(root.right)
a(root)
return stack3.二叉树中搜索第k个最小的元素
class Solution:
def kthSmallest(self, root: Optional[TreeNode], k: int) -> int:
stack = []
while root or stack:
while root:
stack.append(root)
root = root.left
root = stack.pop()
k -= 1
if k == 0:
return root.val
root = root.right4.字符串的排列
class Solution:
def permutation(self, s: str) -> List[str]:
slow = 0
fast = 1
lst = []
lst.append(s)
while slow<len(s)-1:
y = s
if fast < len(s):
temp =y[slow]
y = y.replace(y[slow],y[fast])
y = y.replace(y[fast],temp)
fast += 1
lst.append(y)
else:
slow += 1
fast =slow + 1
return lst总结
深夜总结开始，请你说出今天的经历！！！
怎么来表达今天的痛苦呢，有时候很舒服，当不到两分钟写出来第一题，有时候超级崩溃的，就是花两个小时看最后一题，直接让我当场去世。。。。但是最后还是给写出来了，今天坚持打卡的第十天哦，对我来所算是过了三分之一了嘿嘿嘿嘿嘿，我相信，坚持就会有收获哦，加油，为了自己的目标而奔跑吧骚年！！！
2021-10-18
题目
1.二进制的加法
2.数字的补数
3.字串能表示从1到N数字的二进制串
4.负二进制转换
题解
1.二进制的加法：
首先可以先把二进制的数字转化为十进制，然后十进制相加后在把十进制的数转化为二进制，这样就可以实现该题的解法。
2.数字的补数：
首先我们可以先把十进制数转化为二进制存入到栈中，然后对出栈的数字进行判断把 0 和 1 位置进行交换，然后把二进制数在转化为十进制数，即可解题成功！，
3.字串能表示从1到N数字的二进制串
本题我们可以把从1到N的数字的二进制数都表示出来，如果有一个数的字符串的二进制的字符串形式不属于s就可以直接返回False，循环结束直接返回True。
4.负二进制转换
这个说说实话我半天没有看懂这个说的意思，所以我就直接引用一个大佬的笔记给大家看吧
代码
1.二进制的加法
class Solution:
def addBinary(self, a, b) -> str:
return '{0:b}'.format(int(a, 2) + int(b, 2))
2.数字的补数：
class Solution:
def findComplement(self, num: int) -> int:
stack = []
string = ""
while num != 0:
y = num % 2
stack.append(y)
num = num// 2
while len(stack) >0:
x= stack.pop()
if x == 1:
string = string + str(0)
elif x == 0:
string = string + str(1)
return int(string,2)3.字串能表示从1到N数字的二进制串
class Solution:
def queryString(self, s: str, n: int) -> bool:
for x in range(1,n+1):
if bin(x)[2:] not in s:
return False
return True4.负二进制转换
class Solution:
def baseNeg2(self, N: int) -> str:
if N == 0:
return "0"
res = ""
while N != 0:
cur_bit = str(N % 2)
N = - (N >> 1)
res = cur_bit + res
return res
总结
最后还是来总结今天的刷题过程吧，感觉今天刷题没有最开始那股劲了，慢慢的回归了平静，可能就是新鲜感后的一种不知所措，刷题现在现在每天已经是我每天的一部分了，有的时候我会花费大量的时间来刷题，有时候会觉得这样会耽误专业的成绩，可能接下来的几天我就减少刷题量了，每天就三题，不多刷了，先把功课给提上去，加油！！！
2021-10-19
题目
1.相交链表
2.最大数
3.最小操作次数使数组元素相等
题解
1.相交链表
这个题解我之前写过，大家可以去看我之前的，今天换了一个语言写的，我就不多说了！
2.最大数
这个我们可以用相加判断来是a+b大还是b+a大，然后在进行排序，这题我写本子上面了，今天太累了而且几天快到时间了我就不废话了。
3.最小操作次数使数组元素相等
直接看我本子上写的吧。
代码
1.相交链表
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
s1 = 0
s2 = 0
p1 = headA
p2 = headB
while p1:
p1=p1.next
s1 += 1
while p2:
p2=p2.next
s2 += 1
p1 ,p2 = headA , headB
if s1 > s2:
for i in range(s1 - s2):
p1 = p1.next
if s2 > s1 :
for i in range(s2 - s1):
p2 = p2.next
while p1 and p2 and p1 != p2:
p1 = p1.next
p2 = p2.next
return p12.最大数
class Solution:
def largestNumber(self, nums: List[int]) -> str:
n = len(nums)
nums = list(map(str , nums))
for i in range(n):
for j in range(i+1,n):
if nums[i] + nums[j] < nums[j] + nums[i]:
nums[i],nums[j] = nums[j] , nums[i]
return str(int(''.join(nums)))3.最小操作次数使数组元素相等
class Solution:
def minMoves(self, nums: List[int]) -> int:
return sum(nums) - len(nums) * min(nums) if len(nums) != 1 else 0
总结
先欠着！！！！
2021-10-20
题目
1.有效的括号
题解
1.有效的括号
这个题是一个easy的题，他主要是用一个栈就可以解决这个问题，然后在对每个字符串进行匹配，首先我们可以用for循环遍历每一个字符串，然后对每个字符串进行判断，如果左括号进栈，如果是右括号就对栈尾元素进行一个判断，如果是和他匹配，就把栈尾元素出栈，如果不匹配就把右括号入栈，最后来判断这个栈的长度，如果长度为0就返回true，反之返回false。
代码
1.有效的括号
class Solution:
def isValid(self, s: str) -> bool:
stack = []
for i in s:
if i =='(':
stack.append('(')
elif i =='[':
stack.append('[')
elif i == '{':
stack.append('{')
elif i == ')' and len(stack)>0:
if stack[-1] == '(':
stack.pop()
else : stack.append(i)
elif i == ']' and len(stack)>0:
if stack[-1] == '[':
stack.pop()
else:stack.append(i)
elif i == '}' and len(stack)>0:
if stack[-1] == '{':
stack.pop()
else :stack.append(i)
else:
stack.append(i)
if len(stack) == 0:
return True
else:
return False总结
五味杂陈来形容今天，今天就刷了一题，我今天思考了最近我所做和发生的事情，因为今天我因为好奇投了简历，而且明天还有一个就要面试，我发现我最近都不知都在干嘛了，课本课本上面的知识还没弄懂，就一直想着一步登天，感觉自己有点好高骛远了，想转行java去大厂并证明自己，但是又想了想，进大厂的难度不亚于考研，我今天感到挺累的，我晚上就出去滑了一会板子，放松一下自己，然后调整心态明天就脚踏实地的做好每一件事！！
2021-20-21
题目
1.字符串相加
2.同构字符串
3.重复的子字符串
4.反转字符串中的元音字母
5.字符串解码
题解
1.字符串相加
本题太过简单我就不说了
2.同构字符串
本题用的是一个哈希表，然后判断两者是否相对应。
利用字典实现，因为对应的字母不能重复，所以一样的操作弄两遍
3.重复的子字符串
本题有很多种解法，最难的是kmp解法，这个我还没弄懂，我是直接用的函数，所以这题就先等我熟练kmp在来写题解！
4.反转字符串中的元音字母
我们可以先把，元音字母的大写小写都放在一个列表里面
5.字符串解码
本题是一个栈的问题，我们可以先对字符串进行判断，如果是数字，则记录下来，除‘】’外都入栈，然后直到‘】’出现然后进行运算就直接可以总体加在string并返回！
代码
1.字符串相加
class Solution:
def addStrings(self, num1: str, num2: str) -> str:
return str(int(num1)+int(num2))2.同构字符串
class Solution:
def isIsomorphic(self, s: str, t: str) -> bool:
dit = {}
for i in range(len(s)):
if s[i] in dit:
if dit[s[i]] != t[i]:
return False
else :
dit[s[i]] = t[i]
dit1 = {}
for i in range(len(t)):
if t[i] in dit1:
if dit1[t[i]]!=s[i]:
return False
else:
dit1[t[i]] = s[i]
return True3.重复的子字符串
class Solution:
def repeatedSubstringPattern(self, s: str) -> bool:
return (s + s).find(s, 1) != len(s)
4.反转字符串中的元音字母
class Solution:
def reverseVowels(self, s: str) -> str:
l = list(s)
x = ['a','A','e','E','i','I','o','O','u','U']
i , j = 0 , len(s)-1
while i< j:
while i<len(s)-1 and l[i] not in x:
i += 1
while s[j] not in x and j>0:
j -= 1
if i < j:
l[i] , l[j] = l[j] , l[i]
i += 1
j -= 1
return ''.join(l)5.字符串解码
class Solution:
def decodeString(self, s: str) -> str:
stack = []
num = 0
string = ''
for i in s:
if i.isdigit():
num = num*10 + int(i)
elif i == '[':
stack.append((string,num))
string , num = '' , 0
elif i ==']':
temp = stack.pop()
string = temp[0] + temp[1]*string
else:
string = string + i
return string总结
可算把昨天欠的题今天给补回来了，今天也慢慢的找到了一些方向，心也在慢慢的静下来，先把基础给学好然后在向前努力的奔跑，今天不知道为啥涨了很多粉丝，可能官方大大的扶持吧，也有一些小伙伴的支持，所以我要不辜负大家对我的期待，认真写出好文章！！！
未来的你会感谢现在拼搏的你！
2021-10-22
题目
1.字符串相加 ||
2.求众数
3.字符串相乘
题解
1.字符串相加 ||
这个是昨天的一个题，但是昨天我没有看清楚要求，直接用的转化然后，今天重写的解题。
这个题解等有时间在更新吧。
2.求众数
我用了两种方法来写这个题但是效率好像都不是很高，准备下次在研究研究。
两种方法在下面的代码中，大家可以直接看！
3.字符串相乘
目前用的转换，还没理解！
代码
1.字符串相加 ||
class Solution:
def addStrings(self, num1: str, num2: str) -> str:
i , j ,c =len(num1)-1,len(num2)-1,0
res = ''
while i>=0 or j>=0:
x1 = int(num1[i]) if i>=0 else 0
x2 = int(num2[j]) if j>=0 else 0
temp = x1 + x2 +c
c = temp //10
res = str(temp%10) +res
i -= 1
j -=1
return '1'+res if c else res2.求众数
1. 暴力解法
class Solution:
def majorityElement(self, nums: List[int]) -> List[int]:
x = []
count = 0
for i in set(nums):
for j in nums:
if j == i:
if count >= len(nums)//3:
x.append(i)
break
else : count += 1
count = 0
return x2. 哈希表
class Solution:
def majorityElement(self, nums: List[int]) -> List[int]:
x = []
dit = {}
for i in nums :
if i in dit:
dit[i] += 1
else : dit[i] = 0
for i in dit:
if dit[i] >= len(nums)//3:
x.append(i)
return x3.字符串相乘
class Solution:
def multiply(self, num1: str, num2: str) -> str:
return str(int(num1) *int((num2)))总结
现在生活慢慢的步入正轨，也慢慢的直到自己要干什么，也不在慢慢的迷茫了，看着他人表面的光鲜亮丽，却没有看见他人的拼搏和努力，每个人都有自己最难熬的那段日子，告诉自己在坚持坚持，就快胜利了！！！我觉得做一件事，要么做到底，要么就别做，不然中途放弃浪费时间和精力！！
2021-10-23
题目
1.字符串的最短距离
2.字符串的单词数
3.构造矩阵
4.删除数组中的重复项
5.买卖股票的最佳时机
题解
1.字符串的最短距离
这个我刚开始以为用双指针就可以很轻松的写出来，但是到后面就是发现会有一些有一些缺陷，比如指针走过了，就不会在回来，导致一些最短的数值出错，然后我刚开始直接是暴力，但是我觉得暴力就很没意思，所以我就参考了一些大佬的代码，我能理解大佬们的代码，但是目前我还真不好表达出来，
2.字符串的单词数
这个我是用先把非空字符加起来然后放到一个数组里面，最后返回一个数组的长度！！
我们可以用sqrt这个函数求出w的最大范围，
3.构造矩阵
本题就是一个贪心算法，先求出最大能被整除的w然后在返回另外一个L就可以了。
4.删除数组中的重复项
本题，今天是找出数组中的每个不同的数字，返回长度就可以。
5.买卖股票的最佳时机
借用了一个大佬的图，我们只需要计算出上升的差值，不用计算亏损，这个就直接出来了！！！
代码
1.字符串的最短距离
1.
class Solution:
def shortestToChar(self, s: str, c: str) -> List[int]:
b = []
a = []
for k , i in enumerate(s):
for f,j in enumerate(s):
if j == c :
a.append(abs(f - k))
b.append(min(a))
a = []
return b2.
2.字符串的单词数
1.
class Solution:
def countSegments(self, s: str) -> int:
x = []
string = ''
for i in s:
if i == ' ':
if string != '':
x.append(string)
string = ''
else:string = string + i
if string !='':
x.append(string)
return len(x)2.
class Solution:
def countSegments(self, s):
segment_count = 0
for i in range(len(s)):
if (i == 0 or s[i - 1] == ' ') and s[i] != ' ':
segment_count += 1
return segment_count
3.构造矩阵
class Solution:
def constructRectangle(self, area: int) -> List[int]:
w = int(sqrt(area))
while area % w:
w -= 1
return [area // w,w]4.删除数组中的重复项
1.以前的题解：
class Solution(object):
def removeDuplicates(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
for i in range(len(nums)):
try:
while nums[i] == nums[i+1]:
del nums[i+1]
except:
continue
return len(nums)2.
class Solution:
def removeDuplicates(self, nums: List[int]) -> int:
if not nums:
return 0
n = len(nums)
fast = slow = 1
while fast < n:
if nums[fast] != nums[fast - 1]:
nums[slow] = nums[fast]
slow += 1
fast += 1
return slow
5.买卖股票的最佳时机
1.
class Solution(object):
def maxProfit(self, prices):
"""
:type prices: List[int]
:rtype: int
"""
sum = 0
for i in range(len(prices)):
try:
if prices[i+1]>prices[i]:
sum += prices[i+1]-prices[i]
else:
sum += 0
except:
break
return sum
2.
class Solution(object):
def maxProfit(self, prices):
"""
:type prices: List[int]
:rtype: int
"""
sum = 0
for i in range(len(prices)-1,0,-1):
if prices[i]>prices[i-1]:
sum += prices[i]-prices[i-1]
else:
sum += 0
return sum
总结
今天的收获还是很满足的，我觉得我慢慢的可以对mid发起挑战了，周日已经到来，我要发起总攻！！！向着明天出发！！！！！！
2021-10-24
题目
1.01背包问题
2.罗马数字转整数
3.整数转罗马数字
4.移除元素
5.加一
题解
1.01背包问题
本题的核心就是状态转移方程
key[y][x] = max(key[y-1][x] , key[y-1][x - weight]+value)对比第x的元素的值和第x-weight的值，然后给矩阵赋值，最后返回矩阵右下角的值，这个就是最优值。
可能我讲的不是很好理解，大家可以先参考其他大佬的博客哦！！
2.罗马数字转整数
本题我们可以判断字符都是从大到小的顺序排列，如果是就直接相加，如果不是加减去那个排在前面的小数！！!本题用一个字典，然后判断前一个和后一个是否是顺序排序！！！
3.整数转罗马数字
本题是先分析一些比较特殊的罗马数字，然乎给他放在一个字典里面，用的时候在给他取出来,本题的主要思路就是模拟法！！！
4.移除元素
这个题比较特殊，他不能直接删除val中目标元素，应为列表在空间是连续的，而本题的目的就是直接用数字替代val元素，返回除val以外的元素，所以我们用一个排序把val的元素给他排序到后面，返回数组前面的元素本题就可以写出来了，可以用双指针，也可以用暴力解法！！！
5.加一
本题可以先把字符串给转化为int类型，然后在相加，接着在把int转化为字符串的类型，这个题是之前字符相加的基础题，所以先把这个弄懂再去看最后面的字符串相加！！！
代码
1.01背包问题
def a(item,cap):
key = [[0 for _ in range(cap + 1)] for _ in range(len(item) + 1)]
for y in range(1,len(item) +1):
value = item[y-1][0]
weight = item[y-1][1]
for x in range(cap+1):
if x >= weight:
key[y][x] = max(key[y-1][x] , key[y-1][x - weight]+value)
else:key[y][x] = key[y-1][x]
return key[-1][-1]
item = [[1,2],[4,3],[5,6],[6,7]]
cap = 10
print(a(item,cap))2.罗马数字转整数
class Solution:
dit = {
'I':1,
'V':5,
'X':10,
'L':50,
'C':100,
'D':500,
'M':1000
}
def romanToInt(self, s: str) -> int:
ans = 0
n = len(s)
for i ,j in enumerate(s):
value = self.dit[j]
if i<n-1 and value < self.dit[s[i+1]]:
ans -= value
else : ans += value
return ans
3.整数转罗马数字
class Solution:
VALUE_SYMBOLS = [
(1000, "M"),
(900, "CM"),
(500, "D"),
(400, "CD"),
(100, "C"),
(90, "XC"),
(50, "L"),
(40, "XL"),
(10, "X"),
(9, "IX"),
(5, "V"),
(4, "IV"),
(1, "I"),
]
def intToRoman(self, num: int) -> str:
roman = list()
for value, symbol in Solution.VALUE_SYMBOLS:
while num >= value:
num -= value
roman.append(symbol)
if num == 0:
break
return "".join(roman)4.移除元素
class Solution:
def removeElement(self, nums: List[int], val: int) -> int:
a = 0
b = 0
while a < len(nums):
if nums[a] != val:
nums[b] = nums[a]
b += 1
a += 1
return b5.加一
class Solution(object):
def plusOne(self, digits):
"""
:type digits: List[int]
:rtype: List[int]
"""
nums = []
a = str(digits[0])
for i in range(1,len(digits)):
a += str(digits[i])
a= str(int(a)+1)
for i in a:
nums.append(int(i))
return nums
总结
又是一周的周末了，现在是半夜11.40我已经把今天的题解给写完了，明天就是一个新的一周，我又要开始更新新的blog了，今天也是1024——程序员的节日，也在这里祝大家节日快乐！！！
每日一语：
生活不止眼前的苟且，还有诗和远方！！！
116
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
