6470.既不是最大值也不是最小值

• 同一数组遍历两遍，时间复杂度还是O(n)
• erase操作会增加额外的时间开销

给你一个整数数组 nums ，数组由 不同正整数 组成，请你找出并返回数组中 任一 既不是 最小值 也不是 最大值 的数字，如果不存在这样的数字，返回 -1 。

返回所选整数。

示例 1：

输入：nums = [3,2,1,4]
输出：2
解释：在这个示例中，最小值是 1 ，最大值是 4 。因此，2 或 3 都是有效答案。

示例 2：

输入：nums = [1,2]
输出：-1
解释：由于不存在既不是最大值也不是最小值的数字，我们无法选出满足题目给定条件的数字。因此，不存在答案，返回 -1 。

完整版

• 主要是注意，这种删除nums元素的写法，删除了max的索引之后，min的索引值也会变化，因此需要进行前后索引值的判断！
• erase的用法是nums.erase(nums.begin()+maxIndex);传入的是迭代器

class Solution {
public:
    int findNonMinOrMax(vector<int>& nums) {
        int max = nums[0];
        int maxIndex = 0;
        int min = nums[0];
        int minIndex = 0;
        
        //测试用例输入[1]的时候，预期输出是-1，后期修改
        if(nums.size()==1){
            return -1;
        }
        
        for(int i=0; i<nums.size(); i++){
            if(nums[i] > max){
                max = nums[i];
                maxIndex = i;
            }
            if(nums[i] < min){
                min = nums[i];
                minIndex = i;
            }
        }

        // 如果最大值在最小值之前，先删除最大值，然后再删除最小值，注意删除最大值后最小值索引需要减一
        if(maxIndex < minIndex) {
            nums.erase(nums.begin() + maxIndex);
            nums.erase(nums.begin() + minIndex - 1);
        } 
        else {
            // 如果最小值在最大值之前，先删除最小值，然后再删除最大值
            nums.erase(nums.begin() + minIndex);
            nums.erase(nums.begin() + maxIndex - 1);
        }

        if(!nums.empty()){
            return nums[0];
        }
        else
            return -1;    
        
    }
};

这种写法还是写复杂了，时间复杂度是O(n)，实际上用两个for循环时间复杂度也是O(n)

class Solution {
public:
    int findDifferentNumber(vector<int>& nums) {
        int min_val = INT_MAX;
        int max_val = INT_MIN;
        for (int num : nums) {
            min_val = min(min_val, num);
            max_val = max(max_val, num);
        }
        for (int num : nums) {
            if (num != min_val && num != max_val) {
                return num;
            }
        }
        return -1;
    }
};

为什么两个for循环时间复杂度还是不变的

两种方法在时间复杂度上都是O(n)，因为它们都需要遍历整个数组。这里的n表示数组的大小。两次遍历数组并不会改变时间复杂度的大O标记，因为O(2n)仍然等于O(n)。因此同一个数组遍历两遍，时间复杂度依然是O(n)。

空间复杂度上，两种方法也都是O(1)，因为它们都只使用了有限数量的变量，且这个数量与输入数组的大小无关。

但是，就实际运行时间而言，第二种方法可能会更快一些。原因有两个：

• 没有使用erase操作，erase操作会导致数组中剩余的元素移动，从而增加额外的时间开销。
• 第二种方法在找到一个不是最小或最大的数字后就立即返回，而不是总是遍历整个数组。

所以在最好的情况下，第二种方法的时间复杂度实际上可能比O(n)更低。

6465.执行子串操作后的字典序最小字符串

• ASCII码字符的加减可以直接’b’+1=‘c’，但是a的减法是特殊情况。‘a’-1是不可打印字符，需要单独赋值。
• 这道题重点在于题意理解。子字符串并没有规定长度，但是我们需要操作一个子字符串。
• 尽量减少字典序的方式就是字符串中**'a’尽可能多**。但是，如果原本的字符串全是a，也必须进行一次操作。

给你一个仅由小写英文字母组成的字符串 s 。在一步操作中，你可以完成以下行为：

• 选则 s 的任一非空子字符串，可能是整个字符串，接着将字符串中的每一个字符替换为英文字母表中的前一个字符。例如，‘b’ 用 ‘a’ 替换，‘a’ 用 ‘z’ 替换。

返回执行上述操作 恰好一次 后可以获得的 字典序最小 的字符串。

子字符串 是字符串中的一个连续字符序列。

现有长度相同的两个字符串 x 和 字符串 y ，在满足 x[i] != y[i] 的第一个位置 i 上，如果 x[i] 在字母表中先于 y[i] 出现，则认为字符串 x 比字符串 y 字典序更小 。

示例 1：

输入：s = "cbabc"
输出："baabc"
解释：我们选择从下标 0 开始、到下标 1 结束的子字符串执行操作。 
可以证明最终得到的字符串是字典序最小的。

示例 2：

输入：s = "acbbc"
输出："abaab"
解释：我们选择从下标 1 开始、到下标 4 结束的子字符串执行操作。
可以证明最终得到的字符串是字典序最小的。

示例 3：

输入：s = "leetcode"
输出："kddsbncd"
解释：我们选择整个字符串执行操作。
可以证明最终得到的字符串是字典序最小的。

提示：

• 1 <= s.length <= 3 * 105
• s 仅由小写英文字母组成

思路

这道题题意感觉不太好理解，首先选择的是子字符串，子字符串的长度并没有规定。

另外，恰好一次指的是只操作一个子字符串。并且必须操作，不能不操作原样返回。

在这个问题中，一个关键的点是如果字符串中有’a’，我们应该尽可能地避免改变它前面的字符，因为’a’已经是最小的字符，不能再被减小。

所以我们可以找到第一个’a’字符，并将其前面的所有字符减一。如果字符串中没有’a’，那么我们只需简单地减少整个字符串的每个字符。

最开始的写法

class Solution {
public:
    string smallestString(string s) {
        if(s.size() == 1 && s[0] == 'a'){
            return "z";
        }
        int n = s.size();
        for(int i = 0; i < n; ++i) {
            if(s[i] != 'a') {
                while(i < n && s[i] != 'a') {
                    s[i] = s[i] - 1 == 'a' - 1 ? 'z' : s[i] - 1;
                    ++i;
                }
                break;
            }
        }
        return s;
        
    }
};

这个写法存在的问题在于，当输入"aa"的时候，预期输出是"az"，而不是"aa"。

题意理解的问题

输入"aa"的时候，字典序最小的字符串确实还是"aa"。但是，题目要求我们必须执行恰好一次操作，这就意味着我们必须选择字符串中的至少一个字符进行替换。

在这种情况下，最好的策略就是尽可能保留字典序较小的字符，也就是只将最后一个’a’替换为’z’，得到"az"。因为’z’在字母表中的位置较后，所以"az"是在执行一次操作后能得到的字典序最小的字符串。

修改版

• 保证每一个非’a’字符都会被减小，使得结果字符串尽可能地小。同时，遇到’a’就停止替换，保证了不会无意义地增大字符串。

class Solution {
public:
    string smallestString(string s) {
        //特殊测试用例，后来添加
        if(s.size()==1&&s[0]=='a'){
            return "z";
        }
        
        int n = s.size();
        int i = 0;
        //"a"的部分不动
        while(i < n && s[i] == 'a') {
            i++;
        }
        if(i == n) {  // 如果所有的字符都是 'a'，我们还是需要进行一次操作
            s[n-1] = 'z';
        } 
        else {
            //遇到a的时候，停止替换
            while(i < n && s[i] != 'a') {
                s[i] = s[i] - 1;
                i++;
            }
        }
        return s;  
    }
};

'a’必须单独拿出来的原因

'a' - 1 在ASCII码中是不可打印字符，所以用 s[i] - 1 == 'a' - 1 是在判断 s[i] 是否是字符 ‘a’。如果是 ‘a’，将其替换为 ‘z’ （因为题目中说 ‘a’ 需要替换为 ‘z’）；否则，字符 s[i] 就被替换为它的前一个字符，即 s[i] - 1。

ASCII码字符的加减可以直接’b’+1=‘c’，但是a的减法是特殊情况

6449.收集巧克力

• 注意本题的重点是，由于给出的限制条件nums长度在1000以内，所以可以考虑O(n^2)的算法！

给你一个长度为 n 、下标从 0 开始的整数数组 nums ，表示收集不同巧克力的成本。每个巧克力都对应一个不同的类型，最初，位于下标 i 的巧克力就对应第 i 个类型。

在一步操作中，你可以用成本 x 执行下述行为：

• 同时对于所有下标 0 <= i < n - 1 进行以下操作， 将下标 i 处的巧克力的类型更改为下标 (i + 1) 处的巧克力对应的类型。如果 i == n - 1 ，则该巧克力的类型将会变更为下标 0 处巧克力对应的类型。

假设你可以执行任意次操作，请返回收集所有类型巧克力所需的最小成本。

示例 1：

输入：nums = [20,1,15], x = 5
输出：13
解释：最开始，巧克力的类型分别是 [0,1,2] 。我们可以用成本 1 购买第 1 个类型的巧克力。
接着，我们用成本 5 执行一次操作，巧克力的类型变更为 [2,0,1] 。我们可以用成本 1 购买第 0 个类型的巧克力。
然后，我们用成本 5 执行一次操作，巧克力的类型变更为 [1,2,0] 。我们可以用成本 1 购买第 2 个类型的巧克力。
因此，收集所有类型的巧克力需要的总成本是 (1 + 5 + 1 + 5 + 1) = 13 。可以证明这是一种最优方案。

示例 2：

输入：nums = [1,2,3], x = 4
输出：6
解释：我们将会按最初的成本收集全部三个类型的巧克力，而不需执行任何操作。因此，收集所有类型的巧克力需要的总成本是 1 + 2 + 3 = 6 。

提示：

• 1 <= nums.length <= 1000
• 1 <= nums[i] <= 109
• 1 <= x <= 109

---

思路

思路基于一个关键的观察：在收集所有类型巧克力的过程中，我们可以通过执行一次操作来在某种程度上改变巧克力类型的顺序。这意味着，如果某种类型的巧克力的成本比较高，我们可以通过一些操作使得它被替换成其他类型的巧克力，这样就可以降低总的收集成本。

注意提示信息

本题给出的n的大小是1000以内，也就是说可以使用O(n^2)的做法！

完整版

class Solution {
public:
    long long minCost(vector<int>& nums, int x) {
       long long ans = LLONG_MAX;
        int n = nums.size();
        vector<int> cost(n); // 记录每个点的最小花费
        for (int i = 0; i < n; ++i) 
            cost[i] = nums[i];  
       
        for (int d = 0; d < n; ++d) {   // 尝试移动d次
            long long cnt = 0;   // 移动d次时的最小花费
            for (int i = 0; i < n; ++i) {
                int newcost = nums[(i - d + n) % n];    // 这个点移动d次是否找到了更少的花费
                cost[i] = min(cost[i], newcost);
                cnt += cost[i];
            }
            ans = min(ans, cnt + static_cast<long long>(d) * x);
        }
        return ans;
        
    }
};

这种写法，代码中的for循环尝试了每一个可能的操作次数（从0到n-1）。对于每一种可能的操作次数d，计算了执行d次操作之后的总成本。这个成本包括每种类型巧克力的最小成本以及执行操作的成本。

然后，它找出了这些成本中的最小值，这就是收集所有类型巧克力所需的最小成本。

在计算执行d次操作之后的总成本时，对于每一个巧克力类型，都计算了执行d次操作之后的成本（通过nums[(i - d + n) % n]得到），并更新了当前类型的最小成本（通过min(cost[i], newcost)得到）。这样，cost[i]数组始终存储了对于每种类型，经过一系列操作之后的最小成本。

最后要注意的一点是，这种方法的时间复杂度是O(n^2)，在n较大时可能无法在合理时间内完成计算。

但是本题给出的n的大小是1000以内，因此，O(n^2)这种方法是可以接受的。

补充：由数据范围反推算法复杂度及算法内容

参考：由数据范围反推算法复杂度以及算法内容 - AcWing

一般ACM或者笔试题的时间限制是1秒或2秒。
在这种情况下，C++代码中的操作次数控制在 10^7∼10^8为最佳。

下面给出在不同数据范围下，代码的时间复杂度和算法该如何选择：