1156. 单字符重复子串的最大长度；1497. 检查数组对是否可以被 k 整除；1510. 石子游戏 IV

**1156. 单字符重复子串的最大长度**

### 题目描述给定一个字符串 `s` 和一个整数 `k`,请找到 `s` 中最长的连续子串，其长度为 `k`且只包含一个字符。

### 示例* 输入:`s = "ababbbbaabba"`, `k =2`
* 输出:`9`

### 解决方案我们可以使用滑动窗口算法来解决这个问题。具体来说，我们可以维护两个指针 `left` 和 `right` 来表示当前的子串范围。

def characterReplacement(s: str, k: int) -> int:
 left =0 max_length =0 char_count = {}
 for right in range(len(s)):
 # 将当前字符添加到哈希表中 char_count[s[right]] = char_count.get(s[right],0) +1 # 如果子串长度大于 k，尝试缩小左边界 while (right - left +1) > max_length:
 max_length = max(max_length, right - left)
 char_count[s[left]] -=1 if char_count[s[left]] ==0:
 del char_count[s[left]]
 left +=1 return max(max_length, len(s) - left)

###代码注释* 我们首先初始化两个指针 `left` 和 `right` 来表示当前的子串范围。
* 然后，我们维护一个哈希表 `char_count` 来记录每个字符在当前子串中的出现次数。
* 当我们移动右边界时，我们将当前字符添加到哈希表中，并检查是否需要缩小左边界以保持子串长度不超过 `k`。
* 如果子串长度大于 `max_length`，我们更新 `max_length` 并尝试缩小左边界。
* 最后，我们返回 `max_length` 或剩余子串的长度（如果 `left` 超出范围）。

**1497. 检查数组对是否可以被 k 整除**

### 题目描述给定一个整数数组 `nums` 和一个整数 `k`,请检查是否存在两个元素 `a` 和 `b`，使得 `a + b = k`。

### 示例* 输入:`nums = [1,2,3,4,5]`, `k =9`
* 输出:`True`

### 解决方案我们可以使用哈希表来解决这个问题。具体来说，我们可以将数组元素作为键，将其出现次数作为值。

def canPartitionKSubsets(nums, k):
 total_sum = sum(nums)
 # 如果总和不能被 k 整除，则返回 False if total_sum % k !=0:
 return False target_sum = total_sum // k nums.sort(reverse=True)
 def dfs(index):
 if index == len(nums):
 return True for i in range(k):
 # 如果当前数字大于目标和，则跳过 if nums[index] > target_sum:
 continue # 如果当前数字等于目标和，则尝试分配剩余数字 if nums[index] == target_sum:
 if dfs(index +1):
 return True else:
 break # 如果当前数字小于目标和，则尝试分配剩余数字 if i >0 and nums[index] != target_sum:
 continue # 将当前数字添加到哈希表中 temp = [x for x in nums]
 temp[index] += (target_sum - nums[index])
 # 如果所有数字都被分配，则返回 True if dfs(index +1):
 return True return False return dfs(0)

###代码注释* 我们首先计算总和并检查是否能被 `k` 整除。
* 然后，我们将数组元素按降序排序，并尝试分配数字到哈希表中。
* 当我们移动索引时，我们尝试分配当前数字到哈希表中，并检查是否所有数字都被分配。
* 如果所有数字都被分配，则返回 `True`，否则返回 `False`。

**1510. 石子游戏 IV**

### 题目描述给定一个整数数组 `piles`,表示石子的数量。玩家 A 和 B 将轮流取石子，每次取一堆石子。玩家 A 先取石子。每个玩家都必须取至少一堆石子。

### 示例* 输入:`piles = [2,7,6]`
* 输出:`8`

### 解决方案我们可以使用贪心算法来解决这个问题。具体来说，我们可以先将所有石子分配给玩家 A 和 B，然后再进行调整。

def stoneGameIV(piles):
 n = len(piles)
 # 将所有石子分配给玩家 A 和 B total_sum = sum(piles)
 dp = [[0] * (total_sum +1) for _ in range(n +1)]
 for i in range(1, n +1):
 for j in range(total_sum +1):
 # 如果当前堆数小于或等于 i，则将所有石子分配给玩家 A if i <= j:
 dp[i][j] = piles[i -1]
 else:
 # 否则，尝试分配石子到玩家 A 和 B 中 for k in range(i):
 dp[i][j] = max(dp[i][j], dp[k][j - i + k] + piles[i -1])
 return total_sum - dp[n][total_sum //2]

###代码注释* 我们首先计算总和，并将所有石子分配给玩家 A 和 B。
* 然后，我们使用动态规划来尝试分配石子到玩家 A 和 B 中。
* 当我们移动堆数时，我们尝试分配当前堆数的石子到玩家 A 和 B 中，并检查是否所有石子都被分配。
* 如果所有石子都被分配，则返回总和减去动态规划结果。

以上是对三个问题的解决方案。