题目描述

某机构举办球票大奖赛。获奖选手有机会赢得若干张球票。

主持人拿出 N 张卡片（上面写着 1⋯N 的数字），打乱顺序，排成一个圆圈。

你可以从任意一张卡片开始顺时针数数: 1,2,3
⋯
⋯

如果数到的数字刚好和卡片上的数字相同，则把该卡片收入囊中，从下一个卡片重新数数。

直到再无法收获任何卡片，游戏结束。囊中卡片数字的和就是赢得球票的张数。

比如：

卡片排列是：1 2 3

我们从 1 号卡开始数，就把 1 号卡拿走。再从 2 号卡开始，但数的数字无法与卡片对上，很快数字越来越大，不可能再拿走卡片了。因此这次我们只赢得了 1 张球票。

还不算太坏！如果我们开始就傻傻地从 2 或 3 号卡片数起，那就一张卡片都拿不到了。

如果运气好，卡片排列是 2 1 3，那我们可以顺利拿到所有的卡片！

本题的目标：已知顺时针卡片序列，随便你从哪里开始数，求最多能赢多少张球票（就是收入囊中的卡片数字之和）

输入描述

第一行一个整数 N (N≤100)，表示卡片数目。

第二行 N 个整数，表示顺时针排列的卡片。

输出描述
输出一行，一个整数，表示最好情况下能赢得多少张球票。

输入输出样例

示例
输入

3
1 2 3

输出

1

过程解析

  假设输入的卡片数量 N = 3，每张卡片的顺序是“1，2，3”

  这时候，我们从1的位置（index == 0）开始数数，数到1时，1和卡片上的数字相等，则将卡片1从卡池中取出，取出后，将该位置的卡片号码设置为0，卡池中剩下的卡牌变成“2，3”。此时我们获得了1张球票。

  接着，再从2号卡开始，重新从1开始数数，会发现剩下的都对不上，所以从1开始取，最多只能取1张票。
  卡的顺序不变，我们从2的位置（index == 1）开始数数，会发现一张也拿不了。换个位置从3的位置开始数数，也是一张也拿不到。
  所以，在N = 3，每张卡片的顺序是“1，2，3”的条件下，最多只能拿到1张球票。

注意：每一轮都要有一张卡牌被拿走，如果没有卡牌被拿走，则跳出内层循环进入外层循环。

  假设输入的卡片数量 N = 3，每张卡片的顺序换成是“2，1，3”，看看会发生什么：

  如果我们从2的位置（index == 0）开始数数，第一次会把“3”这张卡拿走，将该位置的数字重置为0后，然后从2继续数，后面什么也拿不到。这种情况下最多只能拿到3张票。

  如果从1的位置开始数数（index == 1），第一次会把“1”这张卡拿走，并将该位置重置为0。此时获得的球票数为1.

然后在3的位置（index == 2），继续从1开始数数，数到2时，将“2”这张卡片拿走，这时候就已经拿下了1+ 2 = 3 张票，同时，将“2”这张卡片重置为0。

  最后剩下卡牌“3”，轮空两次后，数到“3”，将最后一张卡牌收入囊中，这时候所有卡牌被收下，一共获得了1+2+3=6张球票。
  所以一般情况下，如果最后只剩下一张卡牌，是肯定可以拿完全部卡牌的。

  如果我们从3的位置（index == 2）开始数数，来看看发生了什么：
  第一次数到2的时候，会把卡牌2拿走，此时获得的球票数量为2。

  接着数到“1”的时候，把卡牌1拿走，此时获得的球票数量为 2 + 1 = 3；

  最后一步，把剩下的卡牌“3”拿走，此时获得的球票数量为 2 + 1 + 3 = 6。

  所以，当卡牌的顺序是“2，1，3” 时，我们按位置顺序从前向后依次可以取得球票的数量是 [ 3, 6 , 6 ]，取得这个列表中的最大值，即为最好情况下能赢得球票的数量。

  再来看更加复杂一些的情况：假设输入的卡片数量 N = 5，每张卡片的顺序是“3、1、2、4、5”，来看看最多可以到的球票数：

当从index == 0 的位置开始数数的话，我们可以获得 4 + 5 = 9 张票；
当从index == 1 的位置开始数数的话，我们可以获得 1 张票；
当从index == 2 的位置开始数数的话，我们可以获得 0 张票；
当从index == 3 的位置开始数数的话，我们可以获得 3 + 1 = 4 张票；
当从index == 4 的位置开始数数的话，我们可以获得 0 张票；
那么，数组 [ 9, 1, 0, 4, 0 ] 中，最大的数就是9，说明该组合下最多获得9张票。

算法流程

1. 初始化：
     N 表示卡片的数量，a是一个列表，用于存储卡片上的数字。
     sum_list 是一个长度为 N 的列表，用于存储从每个位置开始数数所能获得的球票数字之和，初始值都为 0。
2. 外层循环
     使用 for i in range(N)遍历从每个位置开始数数的情况
     对于每个起始位置 i，进行如下操作:
     k表示当前正在操作的卡片位置，初始化为i。
     l 表示正在数的数字，初始化为 1。
     b是 a的副本，用于操作而不影响原始的a 列表。
3. 内层循环：
     进入 while True 无限循环，只要满足一定条件才会跳出。
     首先使用 while b[k] == 0 来找到下一个未被拿走的卡片位置（因为 b[k] == 0 表示该位置卡片已被拿走）。
     若 b[k] == l：
       说明数到的数字和当前位置的卡片数字相同，将该卡片数字添加到 sum_list[i] 中。
       重置 l 为 1，表示重新开始数数。
       将 b[k] 置为 0，表示该卡片已被拿走。
       检查 b 列表是否所有元素都为 0，如果是，说明所有卡片都已被拿走，结束该位置的循环。
     若 b[k]!= l：
       l 加 1，继续数下一个数字。
       无论是否匹配，都将 k 移动到下一个位置，使用 k = (k + 1) % N 实现循环计数。
       若 l > N，说明数的数字已经超过卡片数量，结束该位置的循环。
4. 结果输出：

  使用 max(sum_list) 找出 sum_list 中的最大值，即为从不同位置开始数数所能获得的最多球票数。

代码实现

这是晏世琪同学提供的代码，注释掉print()语句后可以通过OJ：

# 获取卡片数量 N
N = int(input())
# 存储卡片上数字的列表
a = list(map(int, input().split()))
# 用于存储从每个位置开始数能获得的球票数字之和，初始化为长度为 N 的全 0 列表
sum_list = [0] * N


for i in range(N):
    print(f"从位置 {i} 开始：")
    # 记录当前数数的起始位置
    k = i
    # 初始化数数的数字为 1
    l = 1
    # 创建一个与 a 列表相同的列表 b，用于操作，避免直接修改原列表 a
    b = a.copy()
    while True:
        print(f"当前位置 k：{k}，数数数字 l：{l}，列表 b：{b}")
        while b[k] == 0:
            # 如果当前位置的数字为 0，说明该位置的卡片已被拿走，将位置移动到下一个位置
            k = (k + 1) % N
        if b[k] == l:
            # 如果数到的数字与当前位置的卡片数字相同
            sum_list[i] += b[k]
            print(f"在位置 {k} 找到匹配，将 {b[k]} 加到 sum_list[{i}] 中")
            l = 1
            b[k] = 0
            # 标记是否所有卡片都被拿走
            all_zero = True
            for n in range(N):
                if b[n]!= 0:
                    all_zero = False
                    break
            if all_zero:
                # 若所有卡片都被拿走，结束该位置的循环
                print(f"所有卡片都已拿走，结束位置 {i} 的循环")
                break
        else:
            l += 1
        k = (k + 1) % N
        if l > N:
            # 若数数数字超过卡片数量，结束该位置的循环
            print(f"数数数字超过 N，结束位置 {i} 的循环")
            break
# 找到最大的球票数字之和
max_sum = max(sum_list)
print(max_sum)
# print(sum_list.index(max_sum))

这是另外一份通过OJ的：

import os
import sys

def max_tickets(N, cards):
    # 初始化sum数组，用于记录从每个起始位置开始数数能获得的球票总数
    sum_tickets = [0] * N
    
    # 遍历所有可能的起始位置
    for i in range(N):
        k = i  # 把i复制给k，因为数数一直在动，保存i的位置
        l = 1  # l表示数数，从1开始数
        
        # 创建一个临时数组b来跟踪哪些卡片已经被取走
        b = cards[:]
        
        while True:
            # 跳过已经取走的卡片（即b[k] == 0）
            while b[k] == 0:
                k = (k + 1) % N
            
            # 如果找到对应数字，累加到sum_tickets数组的sum_tickets[i]元素
            if b[k] == l:
                sum_tickets[i] += b[k]
                l = 1  # 每找到对应数字，将l置为1
                b[k] = 0  # 将该位置置为0
                
                # 判断数组里是否全部置为0
                all_zero = True
                for n in range(N):
                    if b[n] != 0:
                        all_zero = False
                        break
                
                # 如果数组元素全部为0，停止本次i位置的查找
                if all_zero:
                    break
            else:
                # 如果没找到对应数字，将l+1
                l += 1
            
            k = (k + 1) % N  # k每次查找都要循环+1
            
            # 如果l大于N，停止本次i位置的查找
            if l > N:
                break
    
    # 寻找最大值
    max_sum = -1
    for i in range(N):
        if max_sum < sum_tickets[i]:
            max_sum = sum_tickets[i]
    
    return max_sum

# 输入处理
N = int(input().strip())
cards = list(map(int, input().strip().split()))

# 输出结果
print(max_tickets(N, cards))