里氏替换原则指出，如果用子类替换超类（解释），那么一段代码应该仍然正确。我不明白的是，我们为什么要关心这个属性？它能让我们的代码更可重用、更灵活或更易于维护吗？
在解释替换属性的相关性时，我希望提供一个遵循该原则和违反该原则的代码示例。
给定一个包含任意嵌套级别的嵌套列表的 python 列表，目标是返回一个完全扁平的列表，即对于样本输入[1, [2], [[[3]]], 1]，输出应该是[1, 2, 3, 1]。
我的解决方案：
def flatten(lst):
stack = [[lst, 0]]
result = []
while stack:
current_lst, start_index = stack[-1]
for i in range(start_index, len(current_lst)):
if isinstance(current_lst[i], list):
# Update the start_index of current list
# to the next element after the nested list
stack[-1][1] = i + 1
# Add nested list to stack
# and initialize its start_index to 0
stack.append([current_lst[i], 0])
# Pause current_lst traversal
break
# non list item
# add item to result
result.append(current_lst[i])
else:
# no nested list
# remove current list from stack
stack.pop()
return result
如果正确的话，我想知道我的解决方案的时间和空间复杂度（辅助空间）。
我的想法
时间复杂度：
我相信解决方案的时间复杂度为O（m + n），其中m是所有级别的嵌套列表的总数，n是所有级别的原子元素（非列表元素）的总数
空间复杂度：
我相信空间复杂度是O(d)，其中d是最嵌套列表的深度。这是因为堆栈跟踪遍历的当前状态，其大小与嵌套深度成正比
解决方案正确吗？
时间和空间的分析正确吗？
给定一个包含数字的Python列表，即lists = [ [1, 2], [2, 1], [3, 4] ]，问题是从输入列表中返回所有唯一列表的列表。如果可以通过重新排序列表中的项目从另一个列表生成列表，则该列表被视为重复。即 是 的[2, 1]重复 [1, 2].给定输入 [ [1, 2], [2, 1], [3, 4] ]，输出应该是[ [1, 2], [3, 4]]。 的任何重新排序 [ [1, 2], [3, 4]] 也是正确的，即 [1, 2], [4, 3]],
我的方法是首先对输入列表中的所有列表进行排序，将列表转换为元组，使用集合数据结构过滤掉重复的元组，最后将唯一元组转换回列表。对所有列表进行排序的时间复杂度为，O(m*nlogn)其中 m 是列表的数量，n 是每个列表的大小（假设列表大小相同）。将列表转换为元组需要O(mn)时间，从元组创建一个集合需要O(mn)，将唯一元组的集合转换回列表也需要，O(mn) 使总时间复杂度为(mnlogn + mn + mn + mn) = O(mnlogn)O。
我们还能做得更好吗O(mnlogn)？
代码：
def find_unique(lists):
sorted_lists = [ sorted(lst) for lst in lists]
tuples = [tuple(lst) for lst in sorted_lists]
unique_tuples = set(tuples)
return list(unique_tuples)