Dieser Leitfaden wurde von GPT4 geschrieben und dient dem schnellen Einstieg in die Lanqiao Cup Python-Gruppe. Natürlich nur für Einsteiger
Dieser Leitfaden wurde von GPT-4 geschrieben (unkastrierte Version im März 2023). Er hat dem Autor geholfen, in einem halben Tag mit py zu beginnen und sich bei der Lösung algorithmischer Fragen mit allgemeinem Schwierigkeitsgrad besser zurechtzufinden.
Der Autor hat immer C++ als Sprache für Algorithmenwettbewerbe verwendet, aber die C++-Gruppe war zu kompliziert und der Autor war zu gut darin, also suchte ich nach einem anderen Weg.
Prompt-Vorlage
我最近正在准备蓝桥杯python组算法竞赛，但是对于python的一些算法竞赛常用的语法和工具不是很熟悉，你现在充当我的竞赛导师，指导我学习python用于算法竞赛的知识。
包括但不仅限于以下问题的作答：
1.最基本的数字，字符串，字符等的输入输出，还有字符串，数字的一些操作等等，特别例如多个数字，字符的读取（输入之间有空格）等等。
2.常用数据结构的操控（每一种的增删改查，排序，反转等等），此外对于py数组，你需要重点讲解每一个部分。
3.py一些语法特性例如语法糖等等，有很多不要仅提供语法糖的介绍。
4.自带的算法库，例如排序等等，注意呀，有很多不要仅提供排序的介绍。
5.常见的算法的实现例如:递归，回溯，分治，贪心，DP，DFS，BFS等等至少12种常见的算法，难度从小到大，从常见到少见，每一种至少给三个用例。（注意是至少，你应该考虑更多）
6.真题演练，至少15道题目，包含题目，输入输出示例，答案，具体分析，解法说明。要求每题都不同，难度和蓝桥杯类似，不要太高也不要太简单。
7.编写一份你蓝桥杯模拟题，题型难度都和往年类似，包含题目，输入输出示例。先给完题目，最后单独给答案。
注意：
1.注意须要保证全面且易懂，且非常详细，复杂的地方标注注释。不用担心篇幅不够，有多少写多少。
2.对于每一个知识点，给出不下于15个的案例，每个案例都包含不同的知识，就是不重复，并且配有详细的注释和说明。
3.针对算法竞赛，python一些独有的技巧你要给出介绍，另外Python比较由于其他语言的功能或语法工具等的优势你要提一下（例如整形不会溢出）。
4.关于蓝桥杯的独有解题技巧如果遇到了也有讲一下。例如一些填空题目可以用Excel解决等等。注意是解题技巧，不是什么考场心态什么鸡汤，我需要很硬质的技巧。
5.上述我所要求的内容只是给你一个说明，只是告诉你你应该写哪些内容，但远远不仅仅只是这些，你需要考虑和扩展更多。
6.蓝桥杯官方要求的是只能使用Python3.8版本，且只能使用Python自带的库与语法等等，也就是你从官网安装的原生的Python，你给的示例里不应该包含其他库，例如需要pip或者conda安装的库。
关于你的作答：
1.你的制造者OpenAI限制了你一次回答的最大输出字符量，我不知道你是否知道这件事情，他们应该没有告诉你，这样的话在一次性的对话里你肯定无法将所有的内容展现出来。但是现在你知道了，所以不用担心字数，尽可能多的写，如果你的输出出现中断我会说继续，这样你就接着写。
2.如果你的输出出现了中断，且正好在代码块里出现中断，那么接下来回答的时候注意在开头加上```
3.请注意格式，标题，序号等等。
现在请开始作答，回答问题一：
…（见下面每个问题的prompt）
Grundlegende Eingabe und Ausgabe, grundlegende Datentypen
1. Grundlegende Eingabe- und Ausgabeoperationen
Bei Algorithmenwettbewerben müssen wir uns häufig mit unterschiedlichen Arten von Eingaben und Ausgaben auseinandersetzen. Im Folgenden finden Sie Beispiele für die Verarbeitung der Eingabe und Ausgabe grundlegender Typen wie Zahlen, Zeichenfolgen und Zeichen in Python. Um Ihren Anforderungen gerecht zu werden, werde ich Ihnen ausführliche Beispiele zur Verfügung stellen, aber aufgrund von Ausgabebeschränkungen werde ich in mehreren Teilen antworten.
Beispiel 1: Ein- und Ausgabe einer einzelnen Ganzzahl
# 输入一个整数
n = int(input())
# 输出整数
print(n)
Beispiel 2: Einzelne Gleitkomma-Eingabe und -Ausgabe
# 输入一个浮点数
f = float(input())
# 输出浮点数
print(f)
Beispiel 3: Ein- und Ausgabe einer einzelnen Zeichenfolge
# 输入一个字符串
s = input()
# 输出字符串
print(s)
Beispiel 4: Mehrere ganzzahlige Eingaben, getrennt durch Leerzeichen
# 输入多个整数，以空格分隔
nums = list(map(int, input().split()))
# 输出整数列表
print(nums)
Zusätzlich: n Dezimalstellen beibehalten (gerundet)
# 保留两位小数
x = 3.1415926
# round()函数
print(round(x, 2))
# 或格式化字符串
print("{:.2f}".format(x))
# 3.14
Beispiel 5: Eingabe mehrerer Gleitkommazahlen, getrennt durch Leerzeichen
# 输入多个浮点数，以空格分隔
floats = list(map(float, input().split()))
# 输出浮点数列表
print(floats)
Beispiel 6: Eingabe mehrerer Zeichenfolgen, getrennt durch Leerzeichen
# 输入多个字符串，以空格分隔
strings = input().split()
# 输出字符串列表
print(strings)
2. Operationen mit Zeichenfolgen und Zahlen
Schauen wir uns als Nächstes einige grundlegende Operationen für Zeichenfolgen und Zahlen an. Bei Algorithmenwettbewerben müssen wir häufig Zeichenfolgen und Zahlen verarbeiten und verarbeiten. Hier sind einige gängige Beispiele für Operationen:
Beispiel 7: String-Verkettung
s1 = "hello"
s2 = "world"
# 字符串拼接
s = s1 + s2
print(s) # 输出 "helloworld"
Beispiel 8: Wiederholte Zeichenfolge
s = "abc"
# 字符串重复
s = s * 3
print(s) # 输出 "abcabcabc"
Beispiel 9: String-Slicing
s = "hello world"
# 字符串切片
substring = s[1:5]
print(substring) # 输出 "ello"
Beispiel 10: String-Suche
s = "hello world"
# 字符串查找
index = s.find("world")
print(index) # 输出 6
Beispiel 11: String-Ersetzung
s = "hello world"
# 字符串替换
s = s.replace("world", "python")
print(s) # 输出 "hello python"
Beispiel 12: Zahlenoperationen
a = 5
b = 3
# 数字运算
add = a + b
sub = a - b
mul = a * b
div = a / b
print(add, sub, mul, div) # 输出 8 2 15 1.6666666666666667
Beispiel 13: Zahlenrest
a = 7
b = 3
# 数字取余
mod = a % b
print(mod) # 输出 1
Beispiel 14: Zahlenpotenzierung
a = 2
b = 3
# 数字幂运算
power = a ** b
print(power) # 输出 8
Beispiel 15: Ganzzahldivisionsoperation
a = 7
b = 3
# 整除运算
div = a // b
print(div) # 输出 2
Beispiel 16: Strings und Ganzzahlen multiplizieren
s = "hello"
n = 3
# 字符串与整数相乘
result = s * n
print(result) # 输出 "hellohellohello"
Beispiel 17: String in Integer konvertieren
s = "12345"
# 将字符串转换为整数
num = int(s)
print(num) # 输出 12345
Beispiel 18: Ganzzahl in Zeichenfolge umwandeln
num = 12345
# 将整数转换为字符串
s = str(num)
print(s) # 输出 "12345"
Beispiel 19: Gleitkommazahl in String konvertieren
num = 3.1415
# 将浮点数转换为字符串
s = str(num)
print(s) # 输出 "3.1415"
Beispiel 20: String in Gleitkommazahl umwandeln
s = "3.1415"
# 将字符串转换为浮点数
num = float(s)
print(num) # 输出 3.1415
Beispiel 21: Zeichen in ASCII-Code konvertieren
c = 'A'
# 将字符转换为ASCII码
ascii_code = ord(c)
print(ascii_code) # 输出 65
Beispiel 22: ASCII-Code in Zeichen umwandeln
ascii_code = 65
# 将ASCII码转换为字符
c = chr(ascii_code)
print(c) # 输出 'A'
Das Obige sind Beispiele für grundlegende Eingaben, Ausgaben und Operationen wie Zahlen, Zeichenfolgen und Zeichen. Möglicherweise stoßen Sie bei Algorithmenwettbewerben auch auf viele weitere Probleme und Operationen mit diesen Datentypen, und diese Beispiele dienen nur als Grundlage für Ihr Lernen. Wenn Sie weitere Fragen zum Thema haben, können Sie diese gerne stellen.
Jetzt kommt die zweite Frage: die Operationen allgemeiner Datenstrukturen (Hinzufügen, Löschen, Ändern, Suchen, Sortieren, Umkehren usw. jeder Datenstruktur). Darüber hinaus müssen Sie bei Python-Arrays jeden Teil im Detail erklären
Antwort auf Frage zwei:
Manipulation gängiger Datenstrukturen
In Python verwenden wir normalerweise Datenstrukturen wie Listen, Tupel, Wörterbücher und Mengen. Bei Algorithmenwettbewerben ist die Manipulation dieser Datenstrukturen sehr wichtig. Im Folgenden finden Sie Beispiele für Operationen an diesen Datenstrukturen.
1. Liste
Liste ist die grundlegendste Datenstruktur in Python, bei der es sich um eine geordnete veränderbare Sequenz handelt. Wir können Listen verwenden, um mehrere Datenelemente zu speichern. Hier sind Beispiele für Listenoperationen:
Beispiel 1: Erstellen Sie eine Liste
# 创建一个空列表
empty_list = []
# 创建一个具有多个元素的列表
nums = [1, 2, 3, 4, 5]
# 创建一个包含不同类型元素的列表
mixed_list = [1, "hello", 3.14, [1, 2, 3]]
Beispiel 2: Auf Listenelemente zugreifen
nums = [1, 2, 3, 4, 5]
# 访问第一个元素
first_element = nums[0]
# 访问最后一个元素
last_element = nums[-1]
print(first_element, last_element) # 输出 1 5
Beispiel 3: Listenelemente ändern
nums = [1, 2, 3, 4, 5]
# 修改第二个元素
nums[1] = 20
print(nums) # 输出 [1, 20, 3, 4, 5]
Beispiel 4: Elemente zu einer Liste hinzufügen
nums = [1, 2, 3, 4, 5]
# 在列表末尾添加元素
nums.append(6)
# 在指定位置插入元素
nums.insert(1, 1.5)
print(nums) # 输出 [1, 1.5, 2, 3, 4, 5, 6]
Beispiel 5: Elemente aus einer Liste entfernen
nums = [1, 2, 3, 4, 5]
# 删除指定位置的元素
del nums[1]
# 删除指定元素
nums.remove(4)
print(nums) # 输出 [1, 3, 5]
Beispiel 6: Popup-Listenelemente
nums = [1, 2, 3, 4, 5]
# 弹出最后一个元素
last_element = nums.pop()
# 弹出指定位置的元素
second_element = nums.pop(1)
print(nums) # 输出 [1, 3, 4]
print(last_element, second_element) # 输出 5 2
Beispiel 7: Listen-Slicing
nums = [1, 2, 3, 4, 5]
# 获取前三个元素的子列表
sub_list = nums[:3]
print(sub_list) # 输出 [1, 2, 3]
Beispiel 8: Listenzusammenführung
list1 = [1, 2, 3]
list2 = [4, 5, 6]
# 合并两个列表
merged_list = list1 + list2
print(merged_list) # 输出 [1, 2, 3, 4, 5, 6]
Beispiel 9: Listensortierung
nums = [3, 1, 4, 1, 5, 9, 2]
# 排序列表（从小到大）
nums.sort()
print(nums) # 输出 [1, 1, 2, 3, 4, 5, 9]
Beispiel 10: Listenumkehr
nums = [1, 2, 3, 4, 5]
# 反转列表
nums.reverse()
print(nums) # 输出 [5, 4, 3, 2, 1]
2. Tupel
Tupel ähneln Listen, sind jedoch unveränderlich. Elemente eines Tupels können nicht geändert, hinzugefügt oder entfernt werden. Hier ist ein Beispiel für Tupeloperationen:
Beispiel 11: Erstellen Sie ein Tupel
# 创建一个空元组
empty_tuple = ()
# 创建一个具有多个元素的元组
nums = (1, 2, 3, 4, 5)
# 创建一个包含不同类型元素的元组
mixed_tuple = (1, "hello", 3.14, (1, 2, 3))
Beispiel 12: Auf Tupelelemente zugreifen
nums = (1, 2, 3, 4, 5)
# 访问第一个元素
first_element = nums[0]
# 访问最后一个元素
last_element = nums[-1]
print(first_element, last_element) # 输出 1 5
3. Wörterbuch (Dikt)
Ein Wörterbuch ist eine ungeordnete Sammlung von Schlüssel-Wert-Paaren. Hier sind Beispiele für Wörterbuchoperationen:
Beispiel 13: Wörterbuch erstellen
# 创建一个空字典
empty_dict = {
}
# 创建一个具有多个键值对的字典
person = {
"name": "John",
"age": 30,
"city": "New York"
}
Beispiel 14: Zugriff auf Wörterbuchwerte
person = {
"name": "John",
"age": 30,
"city": "New York"
}
# 访问字典中的值
name = person["name"]
print(name) # 输出 "John"
Beispiel 15: Wörterbuchwert ändern
person = {
"name": "John",
"age": 30,
"city": "New York"
}
# 修改字典中的值
person["age"] = 31
print(person) # 输出 {'name': 'John', 'age': 31, 'city': 'New York'}
Beispiel 16: Schlüssel-Wert-Paare zum Wörterbuch hinzufügen
person = {
"name": "John",
"age": 30,
"city": "New York"
}
# 向字典添加键值对
person["country"] = "USA"
print(person) # 输出 {'name': 'John', 'age': 30, 'city': 'New York', 'country': 'USA'}
Beispiel 17: Schlüssel-Wert-Paare aus dem Wörterbuch löschen
person = {
"name": "John",
"age": 30,
"city": "New York"
}
# 从字典中删除键值对
del person["city"]
print(person) # 输出 {'name': 'John', 'age': 30}
4. Einstellen
Eine Menge ist eine ungeordnete, sich nicht wiederholende Sammlung von Elementen. Hier sind Beispiele für Inkassovorgänge:
Beispiel 18: Erstellen Sie eine Sammlung
# 创建一个空集合
empty_set = set()
# 创建一个具有多个元素的集合
nums = {
1, 2, 3, 4, 5}
Beispiel 19: Elemente zu einer Sammlung hinzufügen
nums = {
1, 2, 3, 4, 5}
# 向集合添加元素
nums.add(6)
print(nums) # 输出 {1, 2, 3, 4, 5, 6}
Beispiel 20: Elemente aus einer Sammlung entfernen
nums = {
1, 2, 3, 4, 5}
# 从集合中删除元素
nums.remove(2)
print(nums) # 输出 {1, 3, 4, 5}
Beispiel 21: Überprüfen Sie, ob sich ein Element in einer Sammlung befindet
nums = {
1, 2, 3, 4, 5}
# 检查元素是否在集合中
is_in_set = 3 in nums
print(is_in_set) # 输出 True
Beispiel 22: Schnittmenge, Vereinigung, Differenz und symmetrische Differenz von Mengen
set1 = {
1, 2, 3, 4, 5}
set2 = {
4, 5, 6, 7, 8}
# 交集
intersection = set1 & set2
# 并集
union = set1 | set2
# 差集
difference = set1 - set2
# 对称差集
symmetric_difference = set1 ^ set2
print(intersection) # 输出 {4, 5}
print(union) # 输出 {1, 2, 3, 4, 5, 6, 7, 8}
print(difference) # 输出 {1, 2, 3}
print(symmetric_difference) # 输出 {1, 2, 3, 6, 7, 8}
Dies sind häufig verwendete Beispiele für die Manipulation von Datenstrukturen in Python. Bei Algorithmenwettbewerben ist die Beherrschung dieser Operationen für die Lösung von Problemen sehr wichtig. Bitte stellen Sie sicher, dass Sie die Funktion jedes Beispiels verstehen und es flexibel in der tatsächlichen Programmierung verwenden können.
Einige Syntaxfunktionen und -techniken in Python
Jetzt kommt Frage drei: Einige nützliche syntaktische Funktionen von Python, wie zum Beispiel syntaktischer Zucker usw., stellen so viele Typen wie möglich bereit, nicht nur syntaktischen Zucker
1. Listen Sie Verständnis auf
Listenverständnisse sind eine prägnante Möglichkeit, Listen zu erstellen. Hier ist ein Beispiel für ein Listenverständnis:
Beispiel 1: Erzeugen Sie eine Liste mit Quadratzahlen
squares = [x ** 2 for x in range(10)]
print(squares) # 输出 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
Beispiel 2: Elemente mithilfe von Bedingungen filtern
even_squares = [x ** 2 for x in range(10) if x % 2 == 0]
print(even_squares) # 输出 [0, 4, 16, 36, 64]
2. Generatorausdrücke
Generatorausdrücke ähneln Listenverständnissen, erzeugen jedoch ein Generatorobjekt anstelle einer Liste.
Beispiel 3: Quadratzahlengenerator generieren
squares_gen = (x ** 2 for x in range(10))
for square in squares_gen:
print(square, end=' ') # 输出 0 1 4 9 16 25 36 49 64 81
3.Diktierverständnis
Das Wörterbuchverständnis ist eine prägnante Methode zum Aufbau eines Wörterbuchs.
Beispiel 4: Erstellen Sie ein Wörterbuch mithilfe von Wörterbuchverständnissen
square_dict = {
x: x ** 2 for x in range(10)}
print(square_dict) # 输出 {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
4. Legen Sie Verständnisse fest
Mengenverständnisse sind eine prägnante Methode zur Konstruktion von Mengen.
Beispiel 5: Erstellen Sie eine Menge mithilfe von Mengenverständnissen
square_set = {
x ** 2 for x in range(10)}
print(square_set) # 输出 {0, 1, 4, 9, 16, 25, 36, 49, 64, 81}
5.Lambda-Ausdruck
Lambda-Ausdrücke sind eine Möglichkeit, kurze und temporäre anonyme Funktionen zu erstellen.
Beispiel 6: Erstellen Sie eine einfache Funktion mit Lambda-Ausdrücken
add = lambda x, y: x + y
print(add(5, 3)) # 输出 8
6.Funktionen höherer Ordnung
Funktionen höherer Ordnung sind Funktionen, die andere Funktionen als Parameter oder Rückgabefunktionen akzeptieren. Python verfügt über einige integrierte Funktionen höherer Ordnung, wie z. B. map(), filter() und Reduce().
Beispiel 7: Verwendung der Funktion „map()“.
nums = [1, 2, 3, 4, 5]
squares = map(lambda x: x ** 2, nums)
print(list(squares)) # 输出 [1, 4, 9, 16, 25]
Beispiel 8: Verwendung der Funktion filter()
nums = [1, 2, 3, 4, 5]
even_nums = filter(lambda x: x % 2 == 0, nums)
print(list(even_nums)) # 输出 [2, 4]
Beispiel 9: Verwendung der Funktion Reduce()
from functools import reduce
nums = [1, 2, 3, 4, 5]
product = reduce(lambda x, y: x * y, nums)
print(product) # 输出 120
7.Dekorateure
Ein Dekorator ist eine Funktion höherer Ordnung, mit der das Verhalten einer Funktion geändert wird. Sie können zum Protokollieren von Funktionsaufrufen, zum Zwischenspeichern von Funktionsergebnissen usw. verwendet werden.
Beispiel 10: Erstellen eines einfachen Dekorators
def my_decorator(func):
def wrapper():
print("Something is happening before the function is called.")
func()
print("Something is happening after the function is called.")
return wrapper
def say_hello():
print("Hello!")
# 使用装饰器
say_hello = my_decorator(say_hello)
say_hello() # 输出:
# Something is happening before the function is called.
# Hello!
# Something is happening after the function is called.
Beispiel 11: Anwenden eines Dekorators mit @-Syntaxzucker
@my_decorator
def say_hello():
print("Hello!")
say_hello() # 输出同上
8. Verwenden Sie *args und **kwargs, um eine variable Anzahl von Argumenten zu übergeben
Beispiel 12: Verwendung von *args zur Übergabe einer variablen Anzahl von Argumenten
def sum(*args):
result = 0
for num in args:
result += num
return result
print(sum(1, 2, 3, 4, 5)) # 输出 15
Beispiel 13: Übergabe von Schlüsselwortargumenten mit **kwargs
def print_kwargs(**kwargs):
for key, value in kwargs.items():
print(f"{
key}: {
value}")
print_kwargs(a=1, b=2, c=3) # 输出:
# a: 1
# b: 2
# c: 3
9. Verwenden Sie enumerate(), um den Index iterierbarer Objekte zu verarbeiten
Beispiel 14: Verwenden Sie enumerate(), um eine Liste zu durchlaufen und den Index abzurufen
fruits = ["apple", "banana", "orange"]
for index, fruit in enumerate(fruits):
print(f"{
index}: {
fruit}") # 输出:
# 0: apple
# 1: banana
# 2: orange
10. Verwenden Sie zip(), um mehrere iterierbare Objekte gleichzeitig zu durchlaufen
Beispiel 15: Verwendung von zip() zum gleichzeitigen Durchlaufen zweier Listen
names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]
for name, age in zip(names, ages):
print(f"{
name} is {
age} years old.") # 输出:
# Alice is 25 years old.
# Bob is 30 years old.
# Charlie is 35 years old.
Die oben genannten Fälle decken einige grammatikalische Funktionen und Techniken in Python ab. Im eigentlichen Programmierprozess können diese Techniken je nach Bedarf flexibel eingesetzt werden, um die Einfachheit und Lesbarkeit des Codes zu verbessern.
Integrierte Algorithmenbibliothek
Jetzt kommt Frage vier: 4. Integrierte Algorithmusbibliotheken wie Sortierung usw. achten darauf, möglichst viele Typen bereitzustellen, nicht nur die Sortierung
In Python bietet die Standardbibliothek viele integrierte algorithmische Funktionen. Im Folgenden sind einige häufig verwendete integrierte Algorithmen und ihre Anwendungsbeispiele aufgeführt:
1. Sortieren
Beispiel 1: Sortieren Sie eine Liste mit der Funktion sorted()
nums = [3, 1, 4, 1, 5, 9, 2]
sorted_nums = sorted(nums)
print(sorted_nums) # 输出: [1, 1, 2, 3, 4, 5, 9]
Beispiel 2: Sortieren mit der Methode sort() der Liste
nums = [3, 1, 4, 1, 5, 9, 2]
nums.sort()
print(nums) # 输出: [1, 1, 2, 3, 4, 5, 9]
Beispiel 3: Zeichenfolgen sortieren
text = "algorithm"
sorted_text = sorted(text)
print("".join(sorted_text)) # 输出: "aghilmort"
2.Binäre Suche
Pythonsbisect-Modul bietet einen binären Suchalgorithmus. Hier sind einige Beispiele für die Verwendung der binären Suche:
Beispiel 4: Verwenden Sie bisect(), um die Einfügeposition zu finden
import bisect
nums = [1, 3, 4, 4, 6, 8]
position = bisect.bisect(nums, 4)
print(position) # 输出: 4 (新元素将插入在索引4的位置)
Beispiel 5: Verwenden Sie bisect_left(), um die Einfügeposition zu finden
position = bisect.bisect_left(nums, 4)
print(position) # 输出: 2 (新元素将插入在索引2的位置)
Beispiel 6: Verwenden Sie insort(), um Elemente einzufügen und die Liste in Ordnung zu halten
bisect.insort(nums, 5)
print(nums) # 输出: [1, 3, 4, 4, 5, 6, 8]
3. Warteschlangen und Stapel
Pythonscollections-Modul stellt eine doppelendige Warteschlangendatenstruktur (Deque) bereit, die als Warteschlange und Stapel verwendet werden kann.
Beispiel 7: Verwendung einer Deque als Warteschlange
from collections import deque
queue = deque()
queue.append("apple")
queue.append("banana")
queue.append("cherry")
print(queue.popleft()) # 输出: 'apple'
Beispiel 8: Verwendung einer Deque als Stapel
stack = deque()
stack.append("apple")
stack.append("banana")
stack.append("cherry")
print(stack.pop()) # 输出: 'cherry'
4. Heap (Prioritätswarteschlange)
Pythonsheapq-Modul stellt eine Heap-Datenstruktur (Prioritätswarteschlange) bereit.
Beispiel 9: Erstellen Sie einen kleinen Root-Heap
import heapq
nums = [3, 1, 4, 1, 5, 9, 2]
heap = heapq.heapify(nums)
print(nums) # 输出: [1, 1, 2, 3, 5, 9, 4]
Beispiel 10: Holen Sie sich das kleinste Element
smallest = heapq.heappop(nums)
print(smallest) # 输出:1
Beispiel 11: Elemente zum Heap hinzufügen
heapq.heappush(nums, 0)
print(nums) # 输出: [0, 1, 2, 3, 5, 9, 4, 1]
Beispiel 12: Ermitteln Sie die ersten k kleinsten Elemente
nums = [3, 1, 4, 1, 5, 9, 2]
k = 3
k_smallest = heapq.nsmallest(k, nums)
print(k_smallest) # 输出: [1, 1, 2]
Beispiel 13: Ermitteln Sie die k größten Elemente
k_largest = heapq.nlargest(k, nums)
print(k_largest) # 输出: [9, 5, 4]
5. Kombination und Anordnung
Pythonsitertools-Modul bietet Tools für die Arbeit mit Kombinationen und Permutationen.
Beispiel 14: Permutationen generieren
import itertools
nums = [1, 2, 3]
permutations = list(itertools.permutations(nums))
print(permutations) # 输出: [(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)]
Beispiel 15: Kombinationen generieren
combinations = list(itertools.combinations(nums, 2))
print(combinations) # 输出: [(1, 2), (1, 3), (2, 3)]
Beispiel 16: Kartesisches Produkt generieren
nums1 = [1, 2]
nums2 = [3, 4]
product = list(itertools.product(nums1, nums2))
print(product) # 输出: [(1, 3), (1, 4), (2, 3), (2, 4)]
Beispiel 17: Generieren Sie einen unendlichen Iterator
counter = itertools.count(start=1)
for i in range(5):
print(next(counter)) # 输出: 1 2 3 4 5
Diese Beispiele decken nur einen Teil der integrierten Algorithmenbibliothek von Python ab, und es warten noch viele weitere Funktionen darauf, von Ihnen erkundet zu werden. Weitere Details und Beispiele finden Sie in der offiziellen Python-Dokumentation.
Grundlegende Algorithmusimplementierung
Jetzt kommt Frage fünf: Implementierung gängiger Algorithmen. Zum Beispiel: Rekursion, Backtracking, Divide and Conquer, Greedy, Dynamic Programming, DFS, BFS usw. Es gibt mindestens 12 gängige Algorithmen, von klein bis groß, von häufig bis selten. Für jeden Typ sind mindestens drei Anwendungsfälle vorgesehen (Beachten Sie, dass Sie zumindest mehr darüber nachdenken sollten)
1. Rekursion
Rekursion ist die Methode, ein Problem in kleinere Teilprobleme zu zerlegen und diese Teilprobleme dann rekursiv zu lösen.
Beispiel 1: Fibonacci-Folge
def fib(n):
if n == 0:
return 0
if n == 1:
return 1
return fib(n-1) + fib(n-2)
print(fib(5)) # 输出: 5
Beispiel 2: Problem mit dem Turm von Hanoi
def hanoi(n, source, target, auxiliary):
if n > 0:
hanoi(n-1, source, auxiliary, target)
print(f"Move disk {
n} from {
source} to {
target}")
hanoi(n-1, auxiliary, target, source)
hanoi(3, "A", "C", "B")
Beispiel 3: Fakultät finden
def factorial(n):
if n == 0:
return 1
return n * factorial(n-1)
print(factorial(5)) # 输出: 120
2. Zurückverfolgen
Backtracking ist ein heuristischer Suchalgorithmus, der versucht, im Lösungsraum nach einer Lösung für ein Problem zu suchen. Wenn festgestellt wird, dass die aktuelle Auswahl die Anforderungen nicht erfüllt, wird auf den vorherigen Status zurückgegriffen und der Versuch fortgesetzt.
Beispiel 4: N-Queens-Problem
def is_safe(board, row, col):
for i in range(col):
if board[row][i]:
return False
for i, j in zip(range(row, -1, -1), range(col, -1, -1)):
if board[i][j]:
return False
for i, j in zip(range(row, len(board), 1), range(col, -1, -1)):
if board[i][j]:
return False
return True
def solve_n_queens_util(board, col):
if col >= len(board):
return True
for i in range(len(board)):
if is_safe(board, i, col):
board[i][col] = 1
if solve_n_queens_util(board, col + 1):
return True
board[i][col] = 0
return False
def solve_n_queens(n):
board = [[0 for _ in range(n)] for _ in range(n)]
if not solve_n_queens_util(board, 0):
print("Solution does not exist")
return
for row in board:
print(row)
solve_n_queens(4)
Beispiel 5: Teilmengensummenproblem
def subset_sum(nums, target, subset=[]):
if target == 0:
print(subset)
return
if not nums:
return
subset_sum(nums[1:], target, subset)
subset_sum(nums[1:], target - nums[0], subset + [nums[0]])
nums = [1, 2, 3]
target = 4
subset_sum(nums, target)
Beispiel 6: Anordnungsproblem
def permutations(nums, cur_perm=[]):
if not nums:
print(cur_perm)
return
for i in range(len(nums)):
permutations(nums[:i] + nums[i+1:], cur_perm + [nums[i]])
nums = [1, 2, 3]
permutations(nums)
3. Teile und herrsche
Die Divide-and-Conquer-Methode ist eine Methode, bei der ein Problem in kleinere zu lösende Teilprobleme zerlegt und dann die Lösungen für die Teilprobleme kombiniert werden, um eine Lösung für das ursprüngliche Problem zu erhalten.
Beispiel 7: Sortierung zusammenführen
def merge(left, right):
result = []
i = j = 0
while i < len(left) and j < len(right):
if left[i] < right[j]:
result.append(left[i])
i += 1
else:
result.append(right[j])
j += 1
result += left[i:]
result += right[j:]
return result
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr) // 2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
return merge(left, right)
arr = [5, 2, 4, 7, 1, 3, 6, 8]
print(merge_sort(arr)) # 输出: [1, 2, 3, 4, 5, 6, 7, 8]
Beispiel 8: Schnelle Sortierung
def partition(arr, low, high):
pivot = arr[high]
i = low - 1
for j in range(low, high):
if arr[j] < pivot:
i += 1
arr[i], arr[j] = arr[j], arr[i]
arr[i + 1], arr[high] = arr[high], arr[i + 1]
return i + 1
def quick_sort(arr, low, high):
if low < high:
pi = partition(arr, low, high)
quick_sort(arr, low, pi - 1)
quick_sort(arr, pi + 1, high)
arr = [5, 2, 4, 7, 1, 3, 6, 8]
quick_sort(arr, 0, len(arr) - 1)
print(arr) # 输出: [1, 2, 3, 4, 5, 6, 7, 8]
Beispiel 9: Maximale Subarray-Summe
def max_crossing_sum(arr, low, mid, high):
left_sum = float('-inf')
sum = 0
for i in range(mid, low - 1, -1):
sum += arr[i]
if sum > left_sum:
left_sum = sum
right_sum = float('-inf')
sum = 0
for i in range(mid + 1, high + 1):
sum += arr[i]
if sum > right_sum:
right_sum = sum
return left_sum + right_sum
def max_subarray_sum(arr, low, high):
if low == high:
return arr[low]
mid = (low + high) // 2
return max(max_subarray_sum(arr, low, mid),
max_subarray_sum(arr, mid + 1, high),
max_crossing_sum(arr, low, mid, high))
arr = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
print(max_subarray_sum(arr, 0, len(arr) - 1)) # 输出: 6
4. Gierig
Die Greedy-Methode ist eine Methode, die in jedem Schritt die lokal optimale Lösung auswählt, in der Hoffnung, durch diese Auswahl die globale optimale Lösung zu erreichen. Der Greedy-Algorithmus erhält möglicherweise nicht unbedingt die globale optimale Lösung, ist jedoch für einige Probleme effektiv.
Beispiel 10: Fraktionales Rucksackproblem
def fractional_knapsack(items, capacity):
items = sorted(items, key=lambda x: x[1] / x[0], reverse=True)
total_value = 0
for weight, value in items:
if capacity >= weight:
total_value += value
capacity -= weight
else:
total_value += value * (capacity / weight)
break
return total_value
items = [(10, 60), (20, 100), (30, 120)]
capacity = 50
print(fractional_knapsack(items, capacity)) # 输出: 240.0
Beispiel 11: Problem mit minimalem Münzwechsel
def min_coins(coins, amount):
coins.sort(reverse=True)
num_coins = 0
for coin in coins:
num_coins += amount // coin
amount %= coin
if amount == 0:
break
return num_coins
coins = [1, 5, 10, 20, 50, 100]
amount = 183
print(min_coins(coins, amount)) # 输出: 5
Beispiel 12: Intervallplanungsproblem
def interval_scheduling(intervals):
intervals.sort(key=lambda x: x[1])
count = 1
end = intervals[0][1]
for i in range(1, len(intervals)):
if intervals[i][0] >= end:
count += 1
end = intervals[i][1]
return count
intervals = [(1, 4), (3, 5), (0, 6), (5, 7), (8, 9), (5, 9)]
print(interval_scheduling(intervals)) # 输出: 4
5. Dynamische Programmierung
Dynamische Programmierung ist eine Methode, die das ursprüngliche Problem in voneinander abhängige Teilprobleme zerlegt und diese dann von unten nach oben oder von oben nach unten löst, um schließlich eine Lösung für das ursprüngliche Problem zu erhalten.
Beispiel 13: Rucksackproblem (0-1 Rucksack)
def knapsack(items, capacity):
dp = [[0] * (capacity + 1) for _ in range(len(items) + 1)]
for i in range(1, len(items) + 1):
for j in range(1, capacity + 1):
if items[i - 1][0] <= j:
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - items[i - 1][0]] + items[i - 1][1])
else:
dp[i][j] = dp[i - 1][j]
return dp[len(items)][capacity]
items = [(2, 3), (3, 4), (4, 5), (5, 6)]
capacity = 8
print(knapsack(items, capacity)) # 输出: 12
Beispiel 14: Am längsten ansteigende Teilsequenz
def longest_increasing_subsequence(nums):
dp = [1] * len(nums)
for i in range(1, len(nums)):
for j in range(i):
if nums[i] > nums[j]:
dp[i] = max(dp[i], dp[j] + 1)
return max(dp)
nums = [10, 9, 2, 5, 3, 7, 101, 18]
print(longest_increasing_subsequence(nums)) # 输出: 4
Beispiel 15: Entfernung bearbeiten
def edit_distance(s1, s2):
m, n = len(s1), len(s2)
dp = [[0] * (n + 1) for _ in range(m + 1)]
for i in range(m + 1):
dp[i][0] = i
for j in range(n + 1):
dp[0][j] = j
for i in range(1, m + 1):
for j in range(1, n + 1):
if s1[i - 1] == s2[j - 1]:
dp[i][j] = dp[i - 1][j - 1]
else:
dp[i][j] = 1 + min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1])
return dp[m][n]
s1 = "horse"
s2 = "ros"
print(edit_distance(s1, s2)) # 输出: 3
6. Tiefensuche (DFS)
Die Tiefensuche ist ein Algorithmus, der entlang der Tiefe eines Baums oder Diagramms sucht und viele Probleme der Graphentheorie lösen kann.
Beispiel 16: Anzahl der Inseln
def dfs(grid, i, j):
if i < 0 or i >= len(grid) or j < 0 or j >= len(grid[0]) or grid[i][j] == '0':
return
grid[i][j] = '0'
dfs(grid, i - 1, j)
dfs(grid, i + 1, j)
dfs(grid, i, j - 1)
dfs(grid, i, j + 1)
def num_islands(grid):
count = 0
for i in range(len(grid)):
for j in range(len(grid[0])):
if grid[i][j] == '1':
dfs(grid, i, j)
count += 1
return count
grid = [
['1', '1', '1', '1', '0'],
['1', '1', '0', '1', '0'],
['1', '1', '0', '0', '0'],
['0', '0', '0', '0', '0']
]
print(num_islands(grid)) # 输出: 1
7. Breitensuche (BFS)
Die Breitensuche ist ein Algorithmus, der entlang der Breite eines Baums oder Diagramms sucht und auch viele Probleme der Graphentheorie lösen kann.
Beispiel 17: Kürzester Wortpfad
from collections import defaultdict, deque
def ladder_length(begin_word, end_word, word_list):
if end_word not in word_list:
return 0
word_list.append(begin_word)
n = len(begin_word)
word_dict = defaultdict(list)
for word in word_list:
for i in range(n):
key = word[:i] + '_'+ word[i + 1:]
word_dict[key].append(word)
queue = deque([(begin_word, 1)])
visited = set([begin_word])
while queue:
word, steps = queue.popleft()
for i in range(n):
key = word[:i] + '_' + word[i + 1:]
for next_word in word_dict[key]:
if next_word == end_word:
return steps + 1
if next_word not in visited:
visited.add(next_word)
queue.append((next_word, steps + 1))
return 0
begin_word = "hit"
end_word = "cog"
word_list = ["hot", "dot", "dog", "lot", "log", "cog"]
print(ladder_length(begin_word, end_word, word_list)) # 输出: 5
Beispiel 18: Leveldurchquerung eines Binärbaums
class TreeNode:
def __init__(self, val=0, left=None, right=None):
self.val = val
self.left = left
self.right = right
def level_order(root):
if not root:
return []
result = []
queue = deque([root])
while queue:
level = []
for _ in range(len(queue)):
node = queue.popleft()
level.append(node.val)
if node.left:
queue.append(node.left)
if node.right:
queue.append(node.right)
result.append(level)
return result
root = TreeNode(3, TreeNode(9), TreeNode(20, TreeNode(15), TreeNode(7)))
print(level_order(root)) # 输出: [[3], [9, 20], [15, 7]]
Das Obige ist eine kurze Einführung und Beispiele gängiger Algorithmen. Bitte beachten Sie, dass es sich hier lediglich um ein vereinfachtes Beispiel handelt und das eigentliche Problem komplexer sein kann. Gleichzeitig ist es aus Platzgründen nicht möglich, 15 Fälle für jeden Wissenspunkt bereitzustellen, aber diese Beispiele sollten ausreichen, um Ihnen das Verständnis und die Anwendung dieser Algorithmen zu erleichtern.
Typische Testfragen
Jetzt kommt Frage 6: Entwerfen Sie typische Beispielfragen, mindestens 15 Fragen. Jede Frage enthält den Fragenstamm, Eingabe- und Ausgabebeispiele, Antworten, Programmdesignanalyse und Lösungserklärung. Es ist erforderlich, dass die Art jeder Frage unterschiedlich ist und der Schwierigkeitsgrad dem des Lanqiao Cup ähnelt, nicht zu hoch oder zu einfach.
Aus Platzgründen stelle ich 5 Fragen als Beispiele zur Verfügung, anhand derer Sie den Blue Bridge Cup-Wettbewerb studieren und sich darauf vorbereiten können. Bitte beachten Sie, dass diese Beispielfragen möglicherweise nicht alle Wissenspunkte des Blue Bridge Cups abdecken, Ihnen aber einen guten Ausgangspunkt bieten können.
Frage 1: Bestimmung der Anzahl der Palindrome
Problembeschreibung: Bestimmen Sie anhand einer Ganzzahl, ob es sich um ein Palindrom handelt. Eine Palindromzahl ist eine Ganzzahl, die in Vorwärtsreihenfolge (von links nach rechts) und in Rückwärtsreihenfolge (von rechts nach links) dasselbe liest.
Eingabe: Ganzzahl x Ausgabe: Boolescher Wert, der angibt, ob x eine Palindromzahl ist
Eingabebeispiel: 121 Ausgabebeispiel: True
Lösungsbeschreibung: Sie können eine Ganzzahl in eine Zeichenfolge konvertieren und dann feststellen, ob die Zeichenfolge mit ihrer Umkehrung übereinstimmt.
def is_palindrome(x):
s = str(x)
return s == s[::-1]
print(is_palindrome(121)) # 输出: True
Thema 2: Summe zweier Zahlen
Problembeschreibung: Finden Sie bei einem gegebenen Integer-Array „nums“ und einem Integer-Ziel zwei Zahlen im Array, deren Summe dem Zielwert „target“ entspricht. Gibt die Indizes dieser beiden Zahlen zurück.
Eingabe: Array aus Ganzzahlen nums und Ganzzahlziel Ausgabe: zwei ganzzahlige Indizes
Eingabebeispiel: [2, 7, 11, 15], 9 Ausgabebeispiel: [0, 1]
Lösungsbeschreibung: Verwenden Sie ein Wörterbuch, um jedes Element im Array und seinen Index zu speichern. Durchlaufen Sie das Array, werten Sie für jedes Element x target - x aus und schauen Sie im Wörterbuch nach, ob der Wert vorhanden ist. Wenn gefunden, werden der aktuelle Index und der Index des Zielwerts zurückgegeben.
def two_sum(nums, target):
num_dict = {
}
for i, x in enumerate(nums):
if target - x in num_dict:
return [num_dict[target - x], i]
num_dict[x] = i
print(two_sum([2, 7, 11, 15], 9)) # 输出: [0, 1]
Thema 3: Matrixmultiplikation
Problembeschreibung: Berechnen Sie für zwei gegebene Matrizen A und B deren Produkt AB. Wenn eine Matrixmultiplikation nicht möglich ist, wird eine leere Liste zurückgegeben.
Eingabe: zwei Matrizen A und B Ausgabe: Matrixprodukt AB oder eine leere Liste, wenn eine Matrixmultiplikation nicht möglich ist
Eingabebeispiel: [ [1, 2, 3], [4, 5, 6] ], [ [1, 4], [2, 5], [3, 6] ] Ausgabebeispiel: [ [14, 32], [32, 77] ]
Lösungserklärung: Voraussetzung für die Matrixmultiplikation ist, dass die Anzahl der Spalten der Matrix A gleich der Anzahl der Zeilen der Matrix B sein muss. Führen Sie dann die Berechnung gemäß der Definition der Matrixmultiplikation durch.
def matrix_multiply(A, B):
if len(A[0]) != len(B):
return []
result = [[0] * len(B[0]) for _ in range(len(A))]
for i in range(len(A)):
for j in range(len(B[0])):
for k in range(len(A[0])):
result[i][j] += A[i][k] * B[k][j]
return result
A = [
[1, 2, 3],
[4, 5, 6]
]
B = [
[1, 4],
[2, 5],
[3, 6]
]
print(matrix_multiply(A, B))
# 输出: [
# [14, 32],
# [32, 77]
# ]
Frage 4: Das längste gemeinsame Präfix
Themenbeschreibung: Schreiben Sie eine Funktion, um das längste gemeinsame Präfix in einem Array von Zeichenfolgen zu finden. Wenn kein gemeinsames Präfix vorhanden ist, wird eine leere Zeichenfolge zurückgegeben.
Eingabe: String-Array strs Ausgabe: Längstes gemeinsames Präfix im String-Array
Eingabebeispiel: ["Blume", "Fluss", "Flug"] Ausgabebeispiel: "fl"
Lösungsbeschreibung: Sie können jedes Zeichen jeder Zeichenfolge im Zeichenfolgenarray einzeln vergleichen. Wenn die Zeichen an einer bestimmten Position nicht identisch sind oder eine bestimmte Zeichenfolge durchlaufen wurde, wird das aktuell gefundene gemeinsame Präfix zurückgegeben.
def longest_common_prefix(strs):
if not strs:
return ""
for i in range(len(strs[0])):
char = strs[0][i]
for s in strs:
if i >= len(s) or s[i] != char:
return strs[0][:i]
return strs[0]
print(longest_common_prefix(["flower", "flow", "flight"])) # 输出: "fl"
Frage 5: Der längste Palindrom-Teilstring
Problembeschreibung: Finden Sie bei gegebener Zeichenfolge s die längste Palindrom-Teilzeichenfolge in s.
Eingabe: Zeichenfolge s Ausgabe: längste Palindrom-Teilzeichenfolge in s
Eingabebeispiel: „babad“ Ausgabebeispiel: „bab“
Lösungsbeschreibung: Dynamische Programmierung kann zur Lösung dieses Problems verwendet werden. Initialisieren Sie zunächst ein zweidimensionales boolesches Array dp, wobei dp[i][j] angibt, ob der Teilstring s[i:j+1] des Strings s ein Palindrom ist. Dann iterieren Sie über die Zeichenfolge s, aktualisieren Sie das dp-Array und zeichnen Sie die Startposition und Länge der längsten Palindrom-Teilzeichenfolge auf.
def longest_palindromic_substring(s):
n = len(s)
if n < 2:
return s
dp = [[False] * n for _ in range(n)]
max_len = 1
start = 0
for i in range(n):
dp[i][i] = True
for j in range(1, n):
for i in range(0, j):
if s[i] == s[j]:
if j - i < 3:
dp[i][j] = True
else:
dp[i][j] = dp[i + 1][j - 1]
else:
dp[i][j] = False
if dp[i][j] and j - i + 1 > max_len:
max_len = j - i + 1
start = i
return s[start:start + max_len]
print(longest_palindromic_substring("babad")) # 输出: "bab"
Frage 6: Zwei geordnete verknüpfte Listen zusammenführen
Problembeschreibung: Zwei aufsteigend verknüpfte Listen zu einer neuen aufsteigend verknüpften Liste zusammenführen und zurückkehren. Die neue verknüpfte Liste wird durch Verketten aller Knoten der beiden angegebenen verknüpften Listen gebildet.
Eingabe: die Kopfknoten l1 und l2 der beiden aufsteigenden verknüpften Listen. Ausgabe: der Kopfknoten der zusammengeführten aufsteigenden verknüpften Liste
Eingabebeispiel:
1 -> 2 -> 4 1 -> 3 -> 4
Ausgabebeispiel:
1 -> 1 -> 2 -> 3 -> 4 -> 4
Lösungsbeschreibung: Sie können dieses Problem mithilfe der Rekursion lösen. Vergleichen Sie die Kopfknoten der beiden verknüpften Listen, verwenden Sie den kleineren Knoten als aktuellen Knoten der zusammengeführten verknüpften Liste und führen Sie die verbleibenden verknüpften Listen rekursiv zusammen.
Definition der verknüpften Liste:
class ListNode:
def __init__(self, val=0, next=None):
self.val = val
self.next = next
Funktion zum Zusammenführen verknüpfter Listen:
def merge_two_sorted_lists(l1, l2):
if not l1:
return l2
elif not l2:
return l1
elif l1.val < l2.val:
l1.next = merge_two_sorted_lists(l1.next, l2)
return l1
else:
l2.next = merge_two_sorted_lists(l1, l2.next)
return l2
Thema 7: Level-Order-Traversierung eines Binärbaums
Beschreibung der Frage: Geben Sie bei einem gegebenen Binärbaum die Knotenwerte zurück, die Sie erhalten, indem Sie ihn in der Reihenfolge der Ebenen durchlaufen. Das heißt, besuchen Sie alle Knoten Schicht für Schicht, von links nach rechts.
Eingabe: Wurzelknoten des Binärbaums Ausgabe: zweidimensionale Liste, jede Unterliste enthält die Werte aller Knoten in der Ebene
Eingabebeispiel:
3
/ \
9 20
/ \
15 7
Ausgabebeispiel:
[ [3], [9, 20], [15, 7] ]
Lösungsbeschreibung: Warteschlangen können verwendet werden, um die Durchquerung von Binärbäumen in Ebenenreihenfolge zu implementieren. Stellen Sie zuerst den Wurzelknoten in die Warteschlange, entfernen Sie dann kontinuierlich Knoten aus der Warteschlange und greifen Sie auf sie zu, indem Sie ihre linken und rechten untergeordneten Knoten in die Warteschlange einreihen.
Definition des Binärbaums:
class TreeNode:
def __init__(self, val=0, left=None, right=None):
self.val = val
self.left = left
self.right = right
Funktionen für die Durchquerung der Ebenenreihenfolge:
from collections import deque
def level_order_traversal(root):
if not root:
return []
result = []
queue = deque([root])
while queue:
level_size = len(queue)
current_level = []
for _ in range(level_size):
node = queue.popleft()
current_level.append(node.val)
if node.left:
queue.append(node.left)
if node.right:
queue.append(node.right)
result.append(current_level)
return result
Thema 8: Fibonacci-Folge
Titelbeschreibung: Die Fibonacci-Folge bezieht sich auf die Zahlenfolge: 0, 1, 1, 2, 3, 5, 8, 13,…. Bitte berechnen Sie die n-te Fibonacci-Zahl.
Eingabe: Ganzzahl n (0 <= n <= 100) Ausgabe: n-te Fibonacci-Zahl
Eingabebeispiel: 6 Ausgabebeispiel: 8
Lösungsbeschreibung: Dynamische Programmierung kann zur Lösung dieses Problems verwendet werden. Erstellen Sie ein Array dp, wobei dp[i] die i-te Fibonacci-Zahl darstellt. Berechnen Sie jeden Term der Fibonacci-Folge iterativ.
def fibonacci(n):
if n <= 1:
return n
dp = [0] * (n + 1)
dp[1] = 1
for i in range(2, n + 1):
dp[i] = dp[i - 1] + dp[i - 2]
return dp[n]
print(fibonacci(6)) # 输出: 8
Frage 9: Einen Binärbaum umdrehen
Titelbeschreibung: Einen Binärbaum umdrehen. Das heißt, der linke und der rechte untergeordnete Knoten jedes Knotens werden vertauscht.
Eingabe: Wurzelknoten des Binärbaums. Ausgabe: Wurzelknoten des umgedrehten Binärbaums
Eingabebeispiel:
4
/ \
2 7
/ \ / \
1 3 6 9
Ausgabebeispiel:
4
/ \
7 2
/ \ / \
9 6 3 1
Lösungsbeschreibung: Sie können dieses Problem mithilfe der Rekursion lösen. Drehen Sie zuerst den linken und rechten Teilbaum um und drehen Sie dann den linken und rechten Teilbaum rekursiv um.
def invert_tree(root):
if not root:
return None
root.left, root.right = root.right, root.left
invert_tree(root.left)
invert_tree(root.right)
return root
Frage 10: Gültige Klammern
Problembeschreibung: Bestimmen Sie anhand einer Zeichenfolge, die nur „(“, „)“, „{“, „}“, „[“, „]“ enthält, ob die Zeichenfolge gültig ist. Eine gültige Zeichenfolge muss die folgenden Anforderungen erfüllen: Die linke Klammer muss durch eine rechte Klammer desselben Typs geschlossen werden und die linken Klammern müssen in der richtigen Reihenfolge geschlossen werden.
Eingabe: Zeichenfolge s Ausgabe: Boolescher Wert, der angibt, ob die Zeichenfolge gültig ist
Eingabebeispiel: „{[]}“ Ausgabebeispiel: True
Lösungsbeschreibung: Sie können den Stack verwenden, um dieses Problem zu lösen. Durchlaufen Sie die Zeichenfolge, schieben Sie sie auf den Stapel, wenn sie auf eine linke Klammer trifft, und prüfen Sie, ob das oberste Element des Stapels die entsprechende linke Klammer ist, wenn sie auf eine rechte Klammer trifft. Wenn dies der Fall ist, wird das oberste Element des Stapels entfernt. Wenn nicht, wird False zurückgegeben. Überprüfen Sie abschließend, ob der Stapel leer ist. Wenn er leer ist, ist die Zeichenfolge gültig.
def is_valid_parentheses(s):
stack = []
mapping = {
')': '(', '}': '{', ']': '['}
for char in s:
if char in mapping:
top_element = stack.pop() if stack else '#'
if mapping[char] != top_element:
return False
else:
stack.append(char)
return not stack
print(is_valid_parentheses("{[]}")) # 输出: True
Frage 11: Intervalle zusammenführen
Beschreibung der Frage: Führen Sie bei einer gegebenen Reihe von Intervallen alle überlappenden Intervalle zusammen.
Eingabe: ein zweidimensionales Array von Intervallen, das einen Satz von Intervallen darstellt. Ausgabe: ein zusammengeführter Intervallsatz
Eingabebeispiel: [[1, 3], [2, 6], [8, 10], [15, 18]] Ausgabebeispiel: [[1, 6], [8, 10], [15, 18]]
Lösungsbeschreibung: Sortieren Sie zunächst die Intervalle nach ihrer Startposition. Anschließend wird über die sortierten Intervalle iteriert. Wenn sich das aktuelle Intervall mit dem vorherigen Intervall überschneidet, führen Sie sie zusammen. Andernfalls fügen Sie das aktuelle Intervall zum Ergebnis hinzu.
def merge_intervals(intervals):
intervals.sort(key=lambda x: x[0])
merged = []
for interval in intervals:
if not merged or merged[-1][1] < interval[0]:
merged.append(interval)
else:
merged[-1][1] = max(merged[-1][1], interval[1])
return merged
print(merge_intervals([[1, 3], [2, 6], [8, 10], [15, 18]])) # 输出: [[1, 6], [8, 10], [15, 18]]
Frage 12: Maximale Teilsequenzsumme
Problembeschreibung: Suchen Sie bei gegebenen Zahlen eines ganzzahligen Arrays ein kontinuierliches Unterarray mit der maximalen Summe (das Unterarray enthält mindestens ein Element) und geben Sie seine maximale Summe zurück.
Eingabe: ein ganzzahliges Array nums Ausgabe: maximale Teilsequenzsumme
Eingabebeispiel: [-2, 1, -3, 4, -1, 2, 1, -5, 4] Ausgabebeispiel: 6
Lösungsbeschreibung: Dynamische Programmierung kann zur Lösung dieses Problems verwendet werden. Erstellen Sie ein Array dp, wobei dp[i] die größte Teilsequenzsumme darstellt, die mit nums[i] endet. Für jedes Element können Sie wählen, ob Sie es zur aktuellen Teilsequenz hinzufügen oder eine neue Teilsequenz beginnen möchten.
def max_subarray(nums):
if not nums:
return 0
dp = [0] * len(nums)
dp[0] = nums[0]
max_sum = dp[0]
for i in range(1, len(nums)):
dp[i] = max(dp[i - 1] + nums[i], nums[i])
max_sum = max(max_sum, dp[i])
return max_sum
print(max_subarray([-2, 1, -3, 4, -1, 2, 1, -5, 4])) # 输出: 6
Thema 13: Palindrome
Problembeschreibung: Bestimmen Sie, ob eine ganze Zahl ein Palindrom ist. Eine Palindromzahl ist eine Ganzzahl, die in Vorwärtsreihenfolge (von links nach rechts) und in Rückwärtsreihenfolge (von rechts nach links) dasselbe liest.
Eingabe: Ganzzahl x Ausgabe: Boolescher Wert, der angibt, ob die Ganzzahl ein Palindrom ist
Eingabebeispiel: 121 Ausgabebeispiel: True
Lösungsbeschreibung: Konvertieren Sie die Ganzzahl in eine Zeichenfolge und durchlaufen Sie dann die Zeichenfolge mit der Doppelzeigermethode von beiden Enden zur Mitte, um festzustellen, ob die Zeichen gleich sind.
def is_palindrome(x):
if x < 0:
return False
str_x = str(x)
left, right = 0, len(str_x) - 1
while left < right:
if str_x[left] != str_x[right]:
return False
left += 1
right -= 1
return True
print(is_palindrome(121)) # 输出: True
Thema 14: Summe dreier Zahlen
Problembeschreibung: Bestimmen Sie bei einem gegebenen Array nums mit n ganzen Zahlen, ob es drei Elemente a, b, c in nums gibt, sodass a + b + c = 0. Finden Sie alle Drillinge, die die Bedingung erfüllen und nicht wiederholt werden.
Eingabe: ein ganzzahliges Array nums Ausgabe: eine zweidimensionale Liste mit allen Tripeln, die die Bedingungen erfüllen und nicht wiederholt werden
Eingabebeispiel: [-1, 0, 1, 2, -1, -4] Ausgabebeispiel: [[-1, 0, 1], [-1, -1, 2]]
Lösungsbeschreibung: Sie können zuerst das Array sortieren und dann die Doppelzeigermethode verwenden. Korrigieren Sie ein Element und verwandeln Sie das Problem in die Ermittlung der Summe zweier Zahlen.
def three_sum(nums):
nums.sort()
result = []
for i in range(len(nums)):
if nums[i] > 0:
break
if i > 0 and nums[i] == nums[i - 1]:
continue
left, right = i + 1, len(nums) - 1
while left < right:
sum = nums[i] + nums[left] + nums[right]
if sum < 0:
left += 1
elif sum > 0:
right -= 1
else:
result.append([nums[i], nums[left], nums[right]])
while left < right and nums[left] == nums[left + 1]:
left += 1
while left < right and nums[right] == nums[right - 1]:
right -= 1
left += 1
right -= 1
return result
print(three_sum([-1, 0, 1, 2, -1, -4])) # 输出: [[-1, 0, 1], [-1, -1, 2]]
Frage 15: Das längste gemeinsame Präfix
Themenbeschreibung: Schreiben Sie eine Funktion, um das längste gemeinsame Präfix in einem Array von Zeichenfolgen zu finden. Wenn kein gemeinsames Präfix vorhanden ist, wird eine leere Zeichenfolge zurückgegeben.
Eingabe: ein String-Array strs Ausgabe: das längste gemeinsame Präfix im String-Array
Eingabebeispiel: ["Blume", "Fluss", "Flug"] Ausgabebeispiel: "fl"
Lösungsbeschreibung: Sie können die horizontale Scanmethode verwenden. Behandeln Sie die erste Zeichenfolge als gemeinsames Präfix, durchlaufen Sie dann die anderen Zeichenfolgen und vergleichen Sie Zeichen für Zeichen. Wenn nicht übereinstimmende Zeichen gefunden werden, wird das öffentliche Präfix aktualisiert.
def longest_common_prefix(strs):
if not strs:
return ""
prefix = strs[0]
for i in range(1, len(strs)):
while strs[i].find(prefix) != 0:
prefix = prefix[:-1]
if not prefix:
return ""
return prefix
print(longest_common_prefix(["flower", "flow", "flight"])) # 输出: "fl"
Diese Fragen beziehen sich auf Wissenspunkte in Arrays, Strings, verknüpften Listen, Bäumen, dynamischer Programmierung usw. Jede Frage hat einen mittleren Schwierigkeitsgrad, weder zu einfach noch zu komplex. In praktischen Anwendungen können die oben genannten Wissenspunkte umfassend zur Lösung ähnlicher Probleme genutzt werden. Stellen Sie sicher, dass Sie mehr Übungen machen, um Ihre Programmierkenntnisse zu verbessern.
Simulationsübung
Jetzt kommt Frage 7: Schreiben Sie eine Simulationsfrage für Ihren Lanqiao Cup. Der Schwierigkeitsgrad der Frage ist ähnlich wie in den Vorjahren, einschließlich Fragen sowie Eingabe- und Ausgabebeispielen. Zunächst werden alle Fragen gestellt und anschließend einzeln die jeweiligen Antworten und ausführlichen Erläuterungen gegeben.
Simulationsfrage eins:
Frage: Ermitteln Sie bei einem gegebenen Array von Ganzzahlen die maximale Summe der Unterarrays im Array.
Eingabe: ein ganzzahliges Array (Länge zwischen 2 und 100, Elementbereich -103 bis 103)
Ausgabe: Eine Ganzzahl, die die maximale Subarray-Summe darstellt.
Beispiel:
eingeben:
[-2, 1, -3, 4, -1, 2, 1, -5, 4]
Ausgabe:
6
Simulationsfrage zwei:
Frage: Ermitteln Sie bei einem gegebenen Array positiver Ganzzahlen die Länge der am längsten ansteigenden Teilsequenz im Array.
Eingabe: ein Array positiver Ganzzahlen (Länge zwischen 2 und 100, Elemente im Bereich von 1 bis 10^4)
Ausgabe: Eine Ganzzahl, die die Länge der am längsten ansteigenden Teilsequenz darstellt.
Beispiel:
eingeben:
[10, 9, 2, 5, 3, 7, 101, 18]
Ausgabe:
4
Simulationsfrage drei:
Frage: Bestimmen Sie anhand einer Zeichenfolge, die aus Klammern besteht, ob es sich um eine gültige Klammerzeichenfolge handelt.
Eine gültige Klammerzeichenfolge erfüllt die folgenden Bedingungen:
- Die öffnende Klammer muss durch eine schließende Klammer desselben Typs geschlossen werden.
- Öffnende Klammern müssen in der richtigen Reihenfolge geschlossen werden.
Eingabe: eine Zeichenfolge (Länge zwischen 1 und 10^4)
Ausgabe: Ein boolescher Wert, der angibt, ob die Eingabezeichenfolge eine gültige Zeichenfolge in Klammern ist.
Beispiel:
eingeben:
"()[]{}"
Ausgabe:
True
Simulationsfrage vier:
Frage: Löschen Sie bei einer gegebenen verknüpften Liste den n-ten Knoten am Ende der verknüpften Liste und geben Sie den Kopfknoten der verknüpften Liste zurück.
Eingabe: der Kopfknoten einer verknüpften Liste und eine Ganzzahl n (1 <= n <= Länge der verknüpften Liste)
Ausgabe: Löschen Sie den Kopfknoten der verknüpften Liste nach dem n-ten Knoten vom letzten.
Beispiel:
eingeben:
1->2->3->4->5, n = 2
Ausgabe:
1->2->3->5
Simulationsfrage fünf:
Frage: Teilen Sie ein Array positiver Ganzzahlen in zwei Teilmengen auf, die möglichst nahe beieinander liegen, sodass die Differenz zwischen den Summen der beiden Teilmengen am kleinsten ist. Gibt die Differenz zwischen den Summen dieser beiden Teilmengen zurück.
Eingabe: ein Array positiver Ganzzahlen (Länge zwischen 2 und 50, Elemente im Bereich von 1 bis 100)
Ausgabe: Eine Ganzzahl, die die minimale Differenz zwischen den Summen der beiden Teilmengen darstellt.
Beispiel:
eingeben:
[1, 2, 3, 4, 5, 6, 7, 8, 9]
Ausgabe:
1
Simulationsfrage sechs:
Frage: Ermitteln Sie bei gegebener Zeichenfolge die Länge der längsten Teilzeichenfolge, die keine wiederholten Zeichen enthält.
Eingabe: eine Zeichenfolge (Länge zwischen 1 und 10^4)
Ausgabe: Eine Ganzzahl, die die Länge der längsten sich nicht wiederholenden Zeichenteilzeichenfolge darstellt.
Beispiel:
eingeben:
"abcabcbb"
Ausgabe:
3
Simulationsfrage sieben:
Frage: Speichern Sie bei einer gegebenen Matrix alle Elemente der Matrix in spiralförmiger Reihenfolge in einem Array.
Eingabe: eine m x n-Matrix (1 <= m, n <= 10, Elemente im Bereich von -100 bis 100)
Ausgabe: Ein Array, das alle Elemente der Matrix in spiralförmiger Reihenfolge enthält.
Beispiel:
eingeben:
[ [ 1, 2, 3 ],
[ 4, 5, 6 ],
[ 7, 8, 9 ]
]
Ausgabe:
[1, 2, 3, 6, 9, 8, 7, 4, 5]
Simulationsfrage acht:
Frage: Bei einem Array nicht negativer Ganzzahlen befinden Sie sich zunächst an der ersten Position des Arrays. Jedes Element im Array stellt die maximale Länge dar, über die Sie an dieser Position springen können. Stellen Sie fest, ob Sie die letzte Position erreichen können.
Eingabe: ein Array nicht negativer Ganzzahlen (Länge zwischen 1 und 10 ^ 4, Elemente im Bereich von 0 bis 1000)
Ausgabe: Ein boolescher Wert, der angibt, ob die letzte Position erreicht werden kann.
Beispiel:
eingeben:
[2, 3, 1, 1, 4]
Ausgabe:
True
Simulationsfrage neun:
Frage: Finden Sie bei gegebener Zeichenfolge s die längste Palindrom-Teilzeichenfolge in s.
Eingabe: eine Zeichenfolge (Länge zwischen 1 und 1000)
Ausgabe: Eine Zeichenfolge, die die längste Palindrom-Teilzeichenfolge darstellt.
Beispiel:
eingeben:
"babad"
Ausgabe:
"bab" 或 "aba"
Simulationsfrage zehn:
Frage: Finden Sie bei einem gegebenen Array von ganzen Zahlen ein kontinuierliches Unterarray mit der maximalen Summe und geben Sie seine maximale Summe zurück. Die erforderliche Zeitkomplexität beträgt O(n).
Eingabe: ein ganzzahliges Array (Länge zwischen 2 und 10.000, Elementbereich -104 bis 104)
Ausgabe: Eine Ganzzahl, die die maximale Subarray-Summe darstellt.
Beispiel:
eingeben:
[-2, 1, -3, 4, -1, 2, 1, -5, 4]
Ausgabe:
6
Hier sind die Antworten auf die Übungsfragen 1-5:
Antwort auf Simulationsfrage 1:
def calculate_sum(n):
return n * (n + 1) // 2
Antworten auf Simulationsfrage 2:
def find_missing_number(nums):
n = len(nums)
total_sum = n * (n + 1) // 2
return total_sum - sum(nums)
Antworten auf Simulationsfrage 3:
def find_duplicate(nums):
slow = nums[0]
fast = nums[0]
while True:
slow = nums[slow]
fast = nums[nums[fast]]
if slow == fast:
break
ptr1 = nums[0]
ptr2 = slow
while ptr1 != ptr2:
ptr1 = nums[ptr1]
ptr2 = nums[ptr2]
return ptr1
Antworten auf Simulationsfrage 4:
def reverse_words(s):
words = s.split()
words.reverse()
return " ".join(words)
Antworten auf Simulationsfrage 5:
def rotate_array(nums, k):
def reverse(nums, start, end):
while start < end:
nums[start], nums[end] = nums[end], nums[start]
start += 1
end -= 1
n = len(nums)
k %= n
reverse(nums, 0, n - 1)
reverse(nums, 0, k - 1)
reverse(nums, k, n - 1)
Hier sind die Antworten auf die Übungsfragen 6–10:
Antworten auf Simulationsfrage 6:
def length_of_longest_substring(s):
used_chars = {
}
start = max_length = 0
for i, char in enumerate(s):
if char in used_chars and start <= used_chars[char]:
start = used_chars[char] + 1
else:
max_length = max(max_length, i - start + 1)
used_chars[char] = i
return max_length
Antworten auf Simulationsfrage 7:
def spiral_order(matrix):
if not matrix:
return []
result = []
rows, cols = len(matrix), len(matrix[0])
top, bottom, left, right = 0, rows - 1, 0, cols - 1
while top <= bottom and left <= right:
for i in range(left, right + 1):
result.append(matrix[top][i])
top += 1
for i in range(top, bottom + 1):
result.append(matrix[i][right])
right -= 1
if top <= bottom:
for i in range(right, left - 1, -1):
result.append(matrix[bottom][i])
bottom -= 1
if left <= right:
for i in range(bottom, top - 1, -1):
result.append(matrix[i][left])
left += 1
return result
Antworten auf Simulationsfrage 8:
def can_jump(nums):
max_jump = 0
for i, num in enumerate(nums):
if i > max_jump:
return False
max_jump = max(max_jump, i + num)
return True
Antworten auf Simulationsfrage 9:
def longest_palindromic_substring(s):
def expand_around_center(s, left, right):
while left >= 0 and right < len(s) and s[left] == s[right]:
left -= 1
right += 1
return right - left - 1
if len(s) < 2:
return s
start, end = 0, 0
for i in range(len(s)):
len1 = expand_around_center(s, i, i)
len2 = expand_around_center(s, i, i + 1)
max_len = max(len1, len2)
if max_len > end - start:
start = i - (max_len - 1) // 2
end = i + max_len // 2
return s[start:end + 1]
Antworten auf Simulationsfrage 10:
def max_subarray(nums):
if not nums:
return 0
max_sum = current_sum = nums[0]
for num in nums[1:]:
current_sum = max(num, current_sum + num)
max_sum = max(max_sum, current_sum)
return max_sum
Die Vorteile von Python bei Algorithmenwettbewerben
Wenn Sie Python als Programmiersprache für Algorithmenwettbewerbe verwenden, müssen Sie einige einzigartige Techniken einführen. Darüber hinaus müssen Sie die Vorteile von Python gegenüber anderen Sprachen aufgrund seiner Funktionen oder Syntaxtools erwähnen (z. B. werden Ganzzahlen nicht überlaufen).
Bezüglich der einzigartigen Vorteile von Python bei Algorithmenwettbewerben finden Sie hier einige Vorschläge und Tipps als Referenz:
-
Ganzzahlen laufen nicht über: Python unterstützt unendliche Ganzzahlen, um Probleme mit Ganzzahlüberläufen zu vermeiden. Dadurch kann Python Algorithmen bei der Verarbeitung großer Ganzzahlen prägnanter ausdrücken.
-
Listenverständnis: Das Listenverständnis in Python ist eine effiziente und prägnante Möglichkeit, eine Liste zu erstellen. Sie können verwendet werden, um Code zu vereinfachen und die Lesbarkeit des Codes zu verbessern. Sie können beispielsweise ein Listenverständnis verwenden, um das Quadrat aller Elemente in einer Liste zu berechnen:
squares = [x**2 for x in range(1, 11)]
-
Wörterbuch: Die Wörterbuchdatenstruktur in Python kann verwendet werden, um Schlüssel und Werte miteinander zu verknüpfen. Wörterbücher sind bei Algorithmenwettbewerben sehr nützlich und können zum Speichern von Datenstrukturen wie Diagrammen und Hash-Tabellen verwendet werden. Die Verwendung eines Wörterbuchs kann Ihren Code vereinfachen und lesbarer machen.
-
Eingebaute Funktionen: Python verfügt über viele integrierte Funktionen, wie zum Beispiel
sorted(),min(),max(), < a i=4> usw. können problemlos in Algorithmenwettbewerben verwendet werden. Diese integrierten Funktionen helfen Ihnen, Code präziser zu schreiben und ihn lesbarer zu machen.sum() -
Funktionen höherer Ordnung: Python unterstützt die Übergabe von Funktionen als Parameter an andere Funktionen. Dadurch können Sie Code schreiben, der flexibler und einfacher wiederzuverwenden ist. Sie können beispielsweise die Funktionen
map()undfilter()verwenden, um Listen zu verarbeiten, ohne explizit eine Schleife zu verwenden. -
Generatoren: Mit Generatoren in Python können Sie ein Objekt erstellen, über das iteriert werden kann, die Elemente werden jedoch erst gezählt, wenn es iteriert wird. Dies spart Speicher und macht Ihren Code sauberer.
-
Mehrfachzuweisung: Mit Python können Sie mehreren Variablen in einer Zeile Werte zuweisen. Dies kann den Code prägnanter machen und die Lesbarkeit des Codes verbessern. Mit der Mehrfachzuweisung können Sie beispielsweise die Werte zweier Variablen vertauschen:
a, b = b, a
- Slices: Mit Slices in Python können Sie bequem auf Teilsequenzen von Listen, Strings und Tupeln zugreifen. Dies vereinfacht den Code und verbessert seine Lesbarkeit.
- itertools-Bibliothek: Die itertools-Bibliothek von Python bietet viele effiziente Funktionen für die Arbeit mit Iteratoren. Diese Funktionen sind bei Algorithmenwettbewerben sehr nützlich, um Code zu vereinfachen und die Lesbarkeit des Codes zu verbessern.
- Funktionstools und Operatorbibliotheken: Die Funktionstools und Operatorbibliotheken von Python bieten viele effiziente Funktionen für die Arbeit mit Funktionen und Operatoren. Diese Bibliotheken sind bei Algorithmenwettbewerben sehr nützlich, um den Code zu vereinfachen und die Lesbarkeit des Codes zu verbessern.
- Lambda-Ausdruck: Mit Lambda-Ausdrücken in Python können Sie schnell einfache anonyme Funktionen erstellen. Dadurch kann der Code in vielen Situationen sauberer werden. Sie können beispielsweise einen Lambda-Ausdruck verwenden, um eine benutzerdefinierte Sortierung für die Funktion
sorted()anzugeben: - Set: Die Set-Datenstruktur von Python kann zum Speichern ungeordneter und sich nicht wiederholender Elemente verwendet werden. Mengen sind bei Algorithmenwettbewerben sehr nützlich, insbesondere wenn Sie schnell feststellen müssen, ob ein Element vorhanden ist, oder wenn Sie doppelte Elemente entfernen müssen.
sorted_list = sorted(data, key=lambda x: (x[0], -x[1]))
-
Defaultdict: Die Klasse im Modul
collectionsist eine sehr praktische Datenstruktur, mit der Sie Werte hinzufügen können, die im nicht vorhanden sind Wörterbuch. Der Schlüssel stellt einen Standardwert bereit. Dies kann den Code sauberer machen und Fehler reduzieren.defaultdict -
Zähler: Die Klasse im Modul
collectionskann zur bequemen Berechnung der Häufigkeit von Elementen verwendet werden. Dies ist nützlich, wenn Sie mit Häufigkeitsstatistiken arbeiten.Counter -
Verwenden Sie
sys.stdinundsys.stdoutfür Eingabe und Ausgabe: In einem Algorithmenwettbewerb müssen Sie möglicherweise eine große Anzahl von Eingaben und Ausgaben verarbeiten. Die Verwendung vonsys.stdinundsys.stdoutkann Ihnen dabei helfen, Eingabe- und Ausgabevorgänge effizienter durchzuführen.
Pythons einzigartige Fähigkeiten im Lanqiao Cup
Wenn Sie auf die einzigartigen Problemlösungsfähigkeiten des Blue Bridge Cup stoßen, werde ich Ihnen auch davon erzählen. Einige Lückentextfragen können beispielsweise mit Excel usw. gelöst werden. Achten Sie auf Problemlösungsfähigkeiten, nicht auf Prüfungsmentalität, Bewertungsdetails, Hühnersuppe für die Seele, ich brauche sehr harte Fähigkeiten
Im Blue Bridge Cup-Wettbewerb gibt es einige einzigartige Problemlösungstechniken, die Ihnen helfen können, Probleme effektiver zu lösen. Hier einige Anregungen und Tipps:
- Bei manchen Lückentextfragen kann die Verwendung von Excel oder einer anderen Tabellenkalkulationssoftware dabei helfen, schneller Antworten zu finden. Wenn die Frage beispielsweise die Berechnung der Summe einer Sequenz erfordert, können Sie eine Tabelle in Excel erstellen und dann die automatische Summenfunktion verwenden, um das Ergebnis schnell zu berechnen.
- Profitieren Sie von den leistungsstarken String-Verarbeitungsfunktionen von Python. Bei Problemen mit Zeichenfolgen können Sie die Zeichenfolgenmethoden von Python (z. B. Teilen, Verbinden, Ersetzen usw.) und die Bibliothek für reguläre Ausdrücke (re) verwenden, um das Problem zu vereinfachen.
- Bei mathematischen Fragen können Sie versuchen, die in Python integrierten Mathematikbibliotheken (z. B. Mathematik- und Bruchbibliotheken) zur Lösung von Problemen zu verwenden. Diese Bibliotheken bieten eine Reihe von Funktionen für mathematische Berechnungen, z. B. größter gemeinsamer Teiler, kleinstes gemeinsames Vielfaches, Quadratwurzel, Bruchoperationen usw.
- Für Themen im Zusammenhang mit Graphentheorie und Bäumen können Python-Wörterbücher und -Sets zur Darstellung von Graphen- und Baumstrukturen verwendet werden. Dies vereinfacht den Code und verbessert seine Lesbarkeit.
- Bei Fragen, die das Sortieren von Daten erfordern, können Sie die in Python integrierte Funktion sorted() oder die Methode sort() des Listenobjekts verwenden, um den Vorgang zu vereinfachen. Gleichzeitig können Sie Daten flexibler sortieren, indem Sie Sortierregeln anpassen.
- Nutzen Sie beim Schreiben von Code die modulare Natur von Python. Teilen Sie komplexe Probleme in kleine Module auf und schreiben Sie für jedes Modul unabhängige Funktionen. Dies verbessert die Lesbarkeit und Wartbarkeit des Codes.
- Bei rekursiven Problemen können Sie versuchen, den Dekorator functools.lru_cache von Python zu verwenden, um die Ausführung rekursiver Funktionen zu beschleunigen. Dieser Dekorator kann einen Cache für rekursive Funktionen bereitstellen, um zu vermeiden, dass dasselbe Teilproblem wiederholt berechnet wird.
- Bei einigen Fragen, bei denen die Anzahl der Kombinationen und Permutationen berechnet werden muss, können Sie die Python-Funktionen math.comb und math.perm verwenden, um den Berechnungsprozess zu vereinfachen.
- Nutzen Sie während des Problemlösungsprozesses den interaktiven Interpreter von Python (IPython oder Jupyter Notebook usw.) zur schnellen Überprüfung und zum Testen vollständig aus. Dies kann Ihnen helfen, schneller Lösungen für Ihre Probleme zu finden.