目录
- [元素和最小的山形三元组 I](#元素和最小的山形三元组 I)
- [元素和最小的山形三元组 II](#元素和最小的山形三元组 II)
- 合法分组的最少组数
- [得到 K 个半回文串的最少修改次数](#得到 K 个半回文串的最少修改次数)
元素和最小的山形三元组 I
给你一个下标从 0 开始的整数数组 nums 。
如果下标三元组 (i, j, k) 满足下述全部条件，则认为它是一个山形三元组 ：
i < j < k
nums[i] < nums[j] 且 nums[k] < nums[j]
请你找出nums中元素和最小的山形三元组，并返回其 元素和 。如果不存在满足条件的三元组，返回 -1 。
示例 1：
输入：nums = [8,6,1,5,3]
输出：9
解释：三元组 (2, 3, 4) 是一个元素和等于 9 的山形三元组，因为：
- 2 < 3 < 4
- nums[2] < nums[3] 且 nums[4] < nums[3]
这个三元组的元素和等于 nums[2] + nums[3] + nums[4] = 9 。可以证明不存在元素和小于 9 的山形三元组。
示例 2：
输入：nums = [5,4,8,7,10,2]
输出：13 解释：三元组 (1, 3, 5) 是一个元素和等于 13 的山形三元组，因为：
- 1 < 3 < 5
- nums[1] < nums[3] 且 nums[5] < nums[3]
这个三元组的元素和等于 nums[1] + nums[3] + nums[5] = 13 。可以证明不存在元素和小于 13 的山形三元组。
示例 3：
输入：nums = [6,5,4,3,4,5]
输出：-1
解释：可以证明 nums 中不存在山形三元组。
提示：
3 < = n u m s . l e n g t h < = 50 3 <= nums.length <= 50 3<=nums.length<=50
1 < = n u m s [ i ] < = 50 1 <= nums[i] <= 50 1<=nums[i]<=50
分析：
因为数据范围很小，所以可以直接按照题目意思进行模拟，遍历每一个三元组，维护一个最小三元组的和即可。时间复杂度 O ( n 3 ) O(n^3) O(n3)。
代码：
cpp
class Solution {
public:
int minimumSum(vector<int>& nums) {
int n=nums.size();
int ans=INT_MAX;
for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++){
for(int k=j+1;k<n;k++){
if(nums[i]<nums[j]&&nums[k]<nums[j])ans=min(ans,nums[i]+nums[j]+nums[k]);
}
}
}
if(ans==INT_MAX)ans=-1;
return ans;
}
};元素和最小的山形三元组 II
给你一个下标从 0 开始的整数数组 nums 。
如果下标三元组 (i, j, k) 满足下述全部条件，则认为它是一个山形三元组 ：
i < j < k
nums[i] < nums[j] 且 nums[k] < nums[j]
请你找出nums中元素和最小的山形三元组，并返回其 元素和 。如果不存在满足条件的三元组，返回 -1 。
示例 1：
输入：nums = [8,6,1,5,3]
输出：9
解释：三元组 (2, 3, 4) 是一个元素和等于 9 的山形三元组，因为：
- 2 < 3 < 4
- nums[2] < nums[3] 且 nums[4] < nums[3]
这个三元组的元素和等于 nums[2] + nums[3] + nums[4] = 9 。可以证明不存在元素和小于 9 的山形三元组。
示例 2：
输入：nums = [5,4,8,7,10,2]
输出：13 解释：三元组 (1, 3, 5) 是一个元素和等于 13 的山形三元组，因为：
- 1 < 3 < 5
- nums[1] < nums[3] 且 nums[5] < nums[3]
这个三元组的元素和等于 nums[1] + nums[3] + nums[5] = 13 。可以证明不存在元素和小于 13 的山形三元组。
示例 3：
输入：nums = [6,5,4,3,4,5]
输出：-1
解释：可以证明 nums 中不存在山形三元组。
提示：
3 < = n u m s . l e n g t h < = 1 0 5 3 <= nums.length <= 10^{5} 3<=nums.length<=105
1 < = n u m s [ i ] < = 1 0 8 1 <= nums[i] <= 10^{8} 1<=nums[i]<=108
分析：
本题为第一题的加强版，数据范围扩大，使用题一的 O ( n 3 ) O(n^3) O(n3)的方法会TLE，所以我们仔细思考题意，不难想到，要使得一个三元组的和最小，那么对于山顶i，找到i左边的最小值pre[i]，和i右边的最小值suf[i] ，只要pre[i]和suf[i]同时都小于nums[i]的值，那么这就是以i为山顶的三元组的和的最小值。
所以我们可以先进行预处理，遍历一遍数组，维护一个前缀最小值和后缀最小值。时间复杂度为 O ( n ) O(n) O(n)
代码：
cpp
class Solution {
public:
int minimumSum(vector<int>& nums) {
//对每个数找到其前面的最小数和后面的最小数
int n = nums.size();
vector<int>pre(n+1),suf(n+1);
pre[0]=nums[0];
suf[n-1]=nums[n-1];
for(int i=1;i<n;i++)pre[i]=min(nums[i],pre[i-1]);
for(int i=n-2;i>=0;i--)suf[i]=min(nums[i],suf[i+1]);
int ans=INT_MAX;
for(int i=0;i<n;i++){
if(nums[i]>pre[i]&&nums[i]>suf[i])ans=min(ans,pre[i]+nums[i]+suf[i]);
}
if(ans==INT_MAX)ans=-1;
return ans;
}
};合法分组的最少组数
给你一个长度为 n 下标从 0 开始的整数数组 nums 。
我们想将下标进行分组，使得 [0, n - 1] 内所有下标 i 都 恰好 被分到其中一组。
如果以下条件成立，我们说这个分组方案是合法的：
对于每个组 g ，同一组内所有下标在 nums 中对应的数值都相等。
对于任意两个组 g1 和 g2 ，两个组中 下标数量 的 差值不超过 1 。
请你返回一个整数，表示得到一个合法分组方案的 最少 组数。
示例 1：
输入：nums = [3,2,3,2,3]
输出：2
解释：一个得到 2 个分组的方案如下，中括号内的数字都是下标：
组 1 -> [0,2,4]
组 2 -> [1,3]
所有下标都只属于一个组。 组 1 中，nums[0] == nums[2] == nums[4]，所有下标对应的数值都相等。
组 2 中，nums[1] == nums[3] ，所有下标对应的数值都相等。
组 1 中下标数目为 3 ，组2 中下标数目为 2 。
两者之差不超过 1 。
无法得到一个小于 2 组的答案，因为如果只有 1 组，组内所有下标对应的数值都要相等。
所以答案为 2 。
示例 2：
输入：nums = [10,10,10,3,1,1]
输出：4
解释：一个得到 2 个分组的方案如下，中括号内的数字都是下标：
组 1 ->[0]
组 2 -> [1,2]
组 3 -> [3]
组 4 -> [4,5]
分组方案满足题目要求的两个条件。 无法得到一个小于 4组的答案。
所以答案为 4 。
提示：
1 < = n u m s . l e n g t h < = 1 0 5 1 <= nums.length <= 10^{5} 1<=nums.length<=105
1 < = n u m s [ i ] < = 1 0 9 1 <= nums[i] <= 10^{9} 1<=nums[i]<=109
分析：
首先我们需要统计每个数字出现的次数，维护在cnt中。
如何判断一个数字可以拆分为k和k+1的组合呢？
比如说cnt[x]=13，k=4，那么13=4+4+4+1，多出来的这一个1可以丢进前面的某一个4中，同理11=4+4+3，不能由k和k+1构成 ，14=4+4+4+2=5+5+4，15=4+4+4+3=5+5+5，而16=4+4+4+4，不能由5表示了，可以想到，只要cnt[x]/k的值大于等于cnt[x]%k的值，那么其就可以由k和k+1来构成。
那么如何计算最小的分组呢？
不难理解，只要分出的k+1越多，那么分出的组数肯定就越少，即最少可以分出 ⌈ c n t [ x ] k + 1 ⌉ \lceil \frac{cnt[x]}{k+1} \rceil ⌈k+1cnt[x]⌉个组。
因为我们已经确定了能够拆分为k和k+1的组合，p=cnt[x]/k，v=cnt[x]%k，先拆成了p个k，剩下数字v，其实就是v有几个，那么就可以将多少个v个k加一变成k+1。所以直接除以k+1即可得到组数，上取整是因为如果除以k+1有余数，那么这个余数需要补充到有k个数，即组数会多一个。
比如15=5+5+5，16=5+5+5+1=4+4+4+4，13=5+5+3=5+4+4。
最后只需要从min(cnt[x])开始往下枚举k，找到一个满足要求的k即可返回结果。
时间复杂度：枚举cnt中最小的数为k，cnt的size为m， m k ≤ n mk \le n mk≤n，循环的次数最多为km，所以时间复杂度为 O ( n ) O(n) O(n)。
代码：
cpp
class Solution {
public:
int minGroupsForValidAssignment(vector<int>& nums) {
int n = nums.size();
unordered_map<int, int>mp;
vector<int>cnt;
for(int i = 0; i < n ; i++){
mp[nums[i]]++;
}
for(auto &[k,v]:mp)cnt.push_back(v);
sort(cnt.begin(),cnt.end());
int min_num=cnt[0];//枚举最小的组
do{
int ans = 0;
if(min_num==0)break;
for(auto x:cnt){
int p = x / min_num;
int v = x % min_num;
if(p >= v)ans += (x + min_num) / (min_num + 1);
else{
ans = 0;
break;
}
}
if(ans)return ans;
}while(min_num--);
return 0;
}
};得到 K 个半回文串的最少修改次数
给你一个字符串 s 和一个整数 k ，请你将 s 分成 k 个 子字符串 ，使得每个 子字符串 变成 半回文串 需要修改的字符数目最少。
请你返回一个整数，表示需要修改的 最少 字符数目。
注意：
如果一个字符串从左往右和从右往左读是一样的，那么它是一个 回文串 。
如果长度为 len 的字符串存在一个满足 1 <= d < len 的正整数 d ，len % d == 0 成立且所有对 d 做除法余数相同的下标对应的字符连起来得到的字符串都是 回文串 ，那么我们说这个字符串是 半回文串 。比方说 "aa" ，"aba" ，"adbgad" 和 "abab" 都是 半回文串 ，而 "a" ，"ab" 和 "abca" 不是。
子字符串 指的是一个字符串中一段连续的字符序列。
示例 1：
输入：s = "abcac", k = 2
输出：1
解释：我们可以将 s 分成子字符串 "ab" 和 "cac" 。子字符串 "cac"已经是半回文串。如果我们将 "ab" 变成 "aa" ，它也会变成一个 d = 1 的半回文串。 该方案是将 s 分成 2个子字符串的前提下，得到 2 个半回文子字符串需要的最少修改次数。所以答案为 1 。
示例 2:
输入：s = "abcdef", k = 2
输出：2
解释：我们可以将 s 分成子字符串 "abc" 和 "def" 。子字符串
"abc" 和 "def" 都需要修改一个字符得到半回文串，所以我们总共需要 2 次字符修改使所有子字符串变成半回文串。 该方案是将 s分成 2 个子字符串的前提下，得到 2 个半回文子字符串需要的最少修改次数。所以答案为 2 。
示例 3：
输入：s = "aabbaa", k = 3
输出：0
解释：我们可以将 s 分成子字符串 "aa" ，"bb" 和 "aa" 。 字符串"aa" 和 "bb" 都已经是半回文串了。所以答案为 0 。
提示：
2 < = s . l e n g t h < = 200 2 <= s.length <= 200 2<=s.length<=200
1 < = k < = s . l e n g t h / 2 1 <= k <= s.length / 2 1<=k<=s.length/2
s 只包含小写英文字母。
分析：
该题如果直接暴力枚举所有的处理方案，即枚举所有划分为k个子串的可能方案，单单是枚举所有的子串，其时间复杂度都为 O ( n k ) O(n^{k}) O(nk)，更不用说判断如何变成半回文串的操作次数了，很明显会时间超限。那么我们可以从哪些方面对时间进行优化呢？
首先进行预处理：
- 对于每一个长度len的因数，可以提前计算出来其因数有多少个，在后续计算最少变成半回文串的操作数时，可以减少时间的开销。
- 可以提前维护好，从l到r的字符串，变成半回文串最少需要操作多少次，在后续计算整体情况时，可以减少时间开销。
- 记忆化搜索，因为对于字符串s，可以维护一个dp[i][j]，表示将0~j个字符串划分为i个半回文串的操作次数，在不断搜索的过程中，dp[i]][j]是可以反复利用的。
具体的操作可见代码。
代码：
cpp
const int M = 205;
vector<vector<int>>divisors(M);
//记忆化搜索dp[i][j]表示的是从0-j的子串分成i+1个子字符串，每个子字符串都是半回文串的最少修改次数
//表示向量的第二维的大小是M，并且所有元素都被初始化为M。
vector<vector<int>> dp(M / 2, vector<int>(M));
vector<vector<int>> plalindrome_modify_num(M, vector<int>(M));//第一维大小是n,第二维大小是n
class Solution {
public:
void init(int n){//处理出每个数字的因子
for(int i = 1; i < n + 1 ; i++){
for(int j = 1; j <= sqrt(i); j++){
if(i % j == 0){
divisors[i].push_back(j);
if(j == 1)continue;
if(i % (i / j) != i / j)divisors[i].push_back(i / j);
}
}
}
for(int i = 0; i < n/2; i++){
for(int j = 0;j < n; j++){
dp[i][j] = M;
}
}
}
int get_modify_num(string s){//修改成半回文串的最小次数
int n = s.length();
int res = n;//n次是肯定能改成功的,相当于每个位置都改了一遍
for(int d:divisors[n]){//枚举其所有因数
int cnt = 0;
for(int i = 0;i < d ;i++){
for(int j = i, k = n - d + i; j < k; j += d, k -= d){//这是一个子串
cnt += s[j] != s[k];
}
}
res = min(res,cnt);
}
return res;
}
int dfs(int i,int j){
if(i == 0)return plalindrome_modify_num[0][j];
int &ans = dp[i][j];
if(ans != M)return ans;//计算过了,记忆化搜索
//没算过
for(int L = i * 2;L < j; L++){//从L到j当成一块进行修改,前L-1项继续分开去修改
//L = i * 2是因为要给前面的字符串足够的可以拆成子串的空间
ans = min(ans, dfs(i - 1,L - 1) + plalindrome_modify_num[L][j]);
}
return ans;
}
int minimumChanges(string s, int k) {
int n = s.length();
init(n);
//预处理出每一个字串修改为半回文串所需要的次数
for(int l = 0; l < n - 1 ; l++){//题目中要求的子串
for(int r = l + 1; r < n; r++){
plalindrome_modify_num[l][r] = get_modify_num(s.substr(l,r - l + 1));
}
}
return dfs(k - 1, n - 1);
}
};