青岛城市建设集团网站,教育网站制作开发,网站浏览器兼容,深圳设计网站公司网站KMP算法#xff08;Knuth-Morris-Pratt算法#xff09;
KMP算法是一种用于字符串匹配的算法#xff0c;它的时间复杂度为O(mn)。该算法的核心思想是在匹配失败时#xff0c;利用已经匹配的信息#xff0c;减少下一次匹配的起始位置。
def kmp(text, pattern):
n len(… KMP算法Knuth-Morris-Pratt算法
KMP算法是一种用于字符串匹配的算法它的时间复杂度为O(mn)。该算法的核心思想是在匹配失败时利用已经匹配的信息减少下一次匹配的起始位置。
def kmp(text, pattern):
n len(text)
m len(pattern)
lps [0] * m
j 0
compute_lps(pattern, m, lps)
i 0
while i n:
if pattern[j] text[i]:
i 1
j 1
if j m:
print(Found pattern at index str(i-j))
j lps[j-1]
elif i n and pattern[j] ! text[i]:
if j ! 0:
j lps[j-1]
else:
i 1 def compute_lps(pattern, m, lps):
length 0
lps[0] 0
i 1
while i m:
if pattern[i] pattern[length]:
length 1
lps[i] length
i 1
else:
if length ! 0:
length lps[length-1]
else:
lps[i] 0
i 1
运行示例
text ABABDABACDABABCABAB pattern ABABCABAB kmp(text, pattern) # Found pattern at index 10 动态规划Dynamic Programming
动态规划是一种用于解决复杂问题的方法它将问题分解为更小的子问题并存储这些子问题的解决方案以便在需要时可以重复使用。动态规划通常用于最优化问题如最短路径、最长公共子序列和背包问题等。
def knapsack(weights, values, W):
n len(weights)
dp [[0 for _ in range(W1)] for _ in range(n1)]
for i in range(1, n1):
for w in range(1, W1):
if weights[i-1] w:
dp[i][w] max(dp[i-1][w], dp[i-1][w-weights[i-1]] values[i-1])
else:
dp[i][w] dp[i-1][w]
return dp[n][W]
运行示例
weights [2, 3, 4, 5] values [3, 4, 5, 6] W 5 print(knapsack(weights, values, W)) # Output: 7
3.拓扑排序Topological Sort
拓扑排序是一种用于有向无环图DAG的排序算法它按照一定的顺序访问DAG的顶点使得对于任何一条有向边u, vu都出现在v之前。拓扑排序在计算机科学中有许多应用如任务调度和代码编译等。
from collections import deque def topological_sort(graph):
in_degree {u: 0 for u in graph} # 初始化所有顶点的入度为0
for u in graph:
for v in graph[u]:
in_degree[v] 1 # 计算每个顶点的入度
queue deque([u for u in graph if in_degree[u] 0]) # 将入度为0的顶点加入队列
result []
while queue:
u queue.popleft() # 从队列中取出一个顶点
result.append(u)
for v in graph[u]: # 减少v的入度
in_degree[v] - 1
if in_degree[v] 0: # 将入度为0的顶点加入队列
queue.append(v)
if len(result) len(graph): # 如果所有顶点都已被访问则返回结果否则说明图中存在环
return result
else:
return []
运行示例
graph {A: [B, C], B: [D, E], C: [E], D: [], E: []} print(topological_sort(graph)) # Output: [A, B, C, D, E]
4.最短路径算法Dijkstra算法
Dijkstra算法是一种用于解决带权重图的最短路径问题的算法。它能够找到从起点到终点的最短路径其中路径可以经过多个节点。
def dijkstra(graph, start):
n len(graph)
dist [float(inf)] * n
dist[start] 0
prev [None] * n
visited [False] * n
queue [(0, start)]
while queue:
d, u heapq.heappop(queue)
if visited[u]:
continue
visited[u] True
for v, w in graph[u]:
if not visited[v] and dist[u] w dist[v]:
dist[v] dist[u] w
prev[v] u
heapq.heappush(queue, (dist[v], v))
return dist, prev
运行示例
graph [([(1, 9), (2, 6)], [(0, 5)]), ([(2, 4), (3, 5), (4, 2)], [(1, 8)]), ([(3, 1), (4, 2)], [(2, 3)]), ([(0, 1), (2, 5)], [(1, 10), (3, 1)]) start 0 print(dijkstra(graph, start)) # Output: ([0, 5, 8, 11], [0, 1, 2, 3])
这些算法都有一定的难度需要深入理解才能正确实现。在数学建模应用中这些算法也有广泛的应用场景。
