尺取和枚举 python

october_ocean

已于 2024-03-19 22:24:58 修改

阅读量422

点赞数 9

分类专栏：备战蓝桥杯文章标签： python 开发语言

于 2024-03-15 22:11:46 首次发布

本文链接：https://blog.csdn.net/m0_59553037/article/details/136750300

版权

备战蓝桥杯专栏收录该内容

18 篇文章 0 订阅

订阅专栏

本文介绍了尺取法在寻找无重复字符子串中的应用，以及枚举法，包括指数枚举、排列枚举和组合枚举的概念和在Python中使用itertools模块实现的示例。

摘要由CSDN通过智能技术生成

一、尺取

尺取法：通常用于在序列中寻找满足特定条件的子序列。尺取法通过维护两个指针（即"尺取"），根据题目要求调整指针的位置，从而找到符合条件的解。
def two_pointers_template(nums):
    # 初始化左右指针位置
    left, right = 0, 0
    
    while right < len(nums):
        # 增加右指针并更新状态
        
        # while条件，根据题目需要判断是否需要收缩窗口
        while #需要收缩窗口条件:
            # 收缩左指针并更新状态
        
        # 更新结果或其他操作
        
        # 增加左指针并更新状态
    
    return result

尺取法例子：

无重复字符的最长子串，即给定一个字符串，找到最长的子串长度，其中不包含重复字符。

使用两个指针 left 和 right 分别表示子串的左右边界，初始化为 0。
使用一个字典或集合来存储已经遍历过的字符及其对应的索引位置。
遍历字符串，每次移动右指针，并更新最长子串长度，直到遇到重复字符。
当遇到重复字符时，移动左指针，并更新字典中的字符位置，直到滑动窗口内再次没有重复字符。
不断重复上述过程，直到右指针到达字符串末尾。

"""
实现：
通过维护左右指针和一个字典（用于记录字符出现的位置），可以在一次遍历中完成。
在遇到重复字符时，我们更新左指针位置到重复字符的下一个位置，保持窗口内没有重复字符。
最终得到最长无重复字符子串的长度。
"""
def length_of_longest_substring(s):
    if not s:
        return 0
    
    char_index_map = {}
    max_length = 0
    left = 0
    
    for right in range(len(s)):
        if s[right] in char_index_map:
            # 如果遇到重复字符，更新左指针位置
            left = max(left, char_index_map[s[right]] + 1)
        
        char_index_map[s[right]] = right
        max_length = max(max_length, right - left + 1)
    
    return max_length

# 测试用例
input_str = "abcabcbb"
result = length_of_longest_substring(input_str)
print(result)  # 输出：3

二、枚举

枚举法：通过逐个检查所有可能的情况来解决问题。

def enumeration_algorithm(input_data):
    # 初始化结果变量
    result = None

    # 枚举所有可能的情况
    for case in all_cases:
        # 检查当前情况是否满足条件
        if satisfies_condition(case, input_data):
            result = process_result(case)

    return result

# 示例函数：判断情况是否符合条件
def satisfies_condition(case, input_data):
    # 这里是判断条件的具体逻辑，根据实际情况编写

# 示例函数：处理结果
def process_result(case):
    # 这里是处理结果的具体逻辑，根据实际情况编写

1.指数枚举：

枚举法的一种特殊形式，通常用于穷举所有可能的组合或排列

"""
假设我们要找到列表中所有元素的所有子集：
通过指数枚举的方法生成了给定列表 nums 的所有子集。
使用了位运算来表示子集的选取情况，遍历了所有可能的情况并将符合条件的子集加入到结果中。
"""
def generate_subsets(nums):
    subsets = []
    n = len(nums)

    for i in range(1 << n):
        subset = [nums[j] for j in range(n) if (i & (1 << j))]
        subsets.append(subset)

    return subsets

# 测试
nums = [1, 2, 3]
result = generate_subsets(nums)
print(result)    # [[], [1], [2], [1, 2], [3], [1, 3], [2, 3], [1, 2, 3]]

2.排列枚举：

是指在所有可能的排列中逐个检查并找到满足特定条件的解。与指数枚举不同，排列枚举只考虑元素的顺序而不考虑元素的选择。排列枚举是通过不同元素的排列顺序来生成所有可能的情况。

"""
找到给定字符串的所有排列：
使用 itertools 模块中的 permutations 函数来生成给定字符串的所有排列
将每个排列转换为字符串，并将它们存储在结果列表 perms 中
"""

from itertools import permutations

def generate_permutations(string):
    perms = [''.join(p) for p in permutations(string)]
    return perms

# 测试
string = "abc"
result = generate_permutations(string)
print(result)    # ['abc', 'acb', 'bac', 'bca', 'cab', 'cba']

3.组合枚举：

是指从给定的一组元素中，按照一定的规则和条件，列举出所有可能的组合方式。通常用于解决排列组合、优化问题等。

"""
使用 itertools 模块中的 combinations() 函数来实现组合枚举:
"""
import itertools

# 定义原始集合
items = ['A', 'B', 'C']

# 生成所有可能的两个元素的组合
combs = list(itertools.combinations(items, 2))

# 打印所有组合
print(combs)    # [('A', 'B'), ('A', 'C'), ('B', 'C')]

* 介绍 itertools模块

在 Python 中，可以使用 itertools 模块来实现组合枚举。itertools 模块提供了一些用于高效处理迭代器的函数，其中包括生成各种组合的函数。最常用的是 itertools.combinations() 函数，它可以用来生成给定集合的所有可能组合。

"""
附上itertools 模块的简单介绍：
itertools 模块是 Python 标准库中的一部分
提供了一系列用于处理迭代器和生成各种组合的函数。
"""

"""
1.count(start, step): 从 start 开始生成无限递增的整数，步长为 step。
使用 count 函数生成无限递增的整数序列，从 1 开始，步长为 2。通过 for 循环进行迭代，并在 i 大于等于 10 时退出循环。
"""
from itertools import count

for i in count(1, 2):
    print(i)
    if i >= 10:
        break
# 输出
1
3
5
7
9
11

"""
2.cycle(iterable): 无限重复迭代一个可迭代对象。
使用 cycle 函数无限重复迭代 colors 列表中的元素。
通过 for 循环和 next 函数进行迭代，打印出前 5 个元素
"""
from itertools import cycle

colors = ['red', 'green', 'blue']
color_cycle = cycle(colors)

for _ in range(5):
    print(next(color_cycle))
# 输出
red
green
blue
red
green

"""
3.chain(*iterables): 将多个可迭代对象连接起来，返回一个单一的迭代器。
使用 chain 函数将多个列表连接起来，返回一个单一的迭代器。
通过将多个列表作为参数传递给 chain 函数，得到一个包含所有元素的组合列表
"""
from itertools import chain

list1 = [1, 2, 3]
list2 = [4, 5, 6]
list3 = [7, 8, 9]

combined_list = list(chain(list1, list2, list3))
print(combined_list)
# 输出 
[1, 2, 3, 4, 5, 6, 7, 8, 9]

"""
4.combinations(iterable, r): 生成 iterable 中长度为 r 的所有可能组合。
使用 combinations 函数生成 items 列表中长度为 2 的所有可能组合。
结果以元组的形式返回，并被转换为列表
"""
from itertools import combinations

items = ['A', 'B', 'C']

combs = list(combinations(items, 2))
print(combs)

# 输出
[('A', 'B'), ('A', 'C'), ('B', 'C')]

"""
5.permutations(iterable, r=None): 生成 iterable 中长度为 r（默认为可迭代对象的长度）的所有排列。
使用 permutations 函数生成 items 列表中长度为 2 的所有排列。
结果以元组的形式返回，并被转换为列表。
"""
from itertools import permutations

items = ['A', 'B', 'C']

perms = list(permutations(items, 2))
print(perms)
# 输出
[('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'C'), ('C', 'A'), ('C', 'B')]