高效查找布尔数组中下一个True值的位置：预计算优化方案

def find_next_true_naive(arr, start_index):
    """
    朴素方法：从指定索引开始查找下一个True值。
    """
    for i in range(start_index, len(arr)):
        if arr[i]:
            return i
    return -1 # 如果未找到，返回-1

# 示例
test_dict = [False, False, True, False, False, True]
print(f"从索引 0 开始，下一个True在：{find_next_true_naive(test_dict, 0)}") # 输出 2
print(f"从索引 3 开始，下一个True在：{find_next_true_naive(test_dict, 3)}") # 输出 5
print(f"从索引 5 开始，下一个True在：{find_next_true_naive(test_dict, 5)}") # 输出 5
print(f"从索引 6 开始，下一个True在：{find_next_true_naive(test_dict, 6)}") # 输出 -1

def preprocess_next_true_positions(arr):
    """
    预计算函数：生成一个辅助数组，存储每个位置之后下一个True值的索引。
    """
    n = len(arr)
    # 辅助数组，true_pos[i] 存储从索引 i 开始的下一个True值的索引
    true_pos = [-1] * n
    last_true_pos = -1 # 记录当前遍历位置之后最近的True值索引

    # 从数组末尾向前遍历
    for i in reversed(range(n)):
        if arr[i]:
            last_true_pos = i # 如果当前位置是True，则更新最近的True值索引
        true_pos[i] = last_true_pos # 存储从当前位置i开始的下一个True值索引
    return true_pos

# 示例布尔数组
test_dict = [False, False, True, False, False, True]

# 执行预计算
precomputed_indices = preprocess_next_true_positions(test_dict)

print("原始数组:", test_dict)
print("预计算结果 (索引 -> 下一个True的索引):")
for i, next_idx in enumerate(precomputed_indices):
    print(f"  从索引 {i} 开始，下一个True在: {next_idx}")

# 预计算结果示例输出：
#   从索引 0 开始，下一个True在: 2
#   从索引 1 开始，下一个True在: 2
#   从索引 2 开始，下一个True在: 2
#   从索引 3 开始，下一个True在: 5
#   从索引 4 开始，下一个True在: 5
#   从索引 5 开始，下一个True在: 5

def query_next_true(precomputed_arr, start_index):
    """
    查询函数：从预计算结果中获取下一个True值的索引。
    """
    if 0 <= start_index < len(precomputed_arr):
        return precomputed_arr[start_index]
    return -1 # 如果起始索引超出范围，返回-1

# 结合预计算和查询的完整示例
test_dict = [False, False, True, False, False, True]
precomputed_indices = preprocess_next_true_positions(test_dict)

# 模拟多次查询
queries = [0, 1, 2, 3, 4, 5, 6] # 6是一个越界查询，用于测试边界情况
print("\n执行查询:")
for position in queries:
    result = query_next_true(precomputed_indices, position)
    if result != -1:
        print(f"从索引 {position} 开始，下一个True值在 {result}th 位置。")
    else:
        print(f"从索引 {position} 开始，未找到下一个True值。")

# 模拟原始问题中的查询场景
dict_sample = {"1": "2", "11":"3"} # 假设这些是需要转换为整数的起始位置
print("\n原始问题场景模拟:")
for position_str, val in dict_sample.items():
    start_pos = int(position_str) - 1 # 假设position_str是1-based索引，转换为0-based
    if 0 <= start_pos < len(test_dict):
        result = query_next_true(precomputed_indices, start_pos)
        if result != -1:
            print(f"从索引 {start_pos} 开始，下一个True值在 {result}th 位置。")
        else:
            print(f"从索引 {start_pos} 开始，未找到下一个True值。")
    else:
        print(f"起始索引 {start_pos} 超出数组范围。")