维护左，枚举右（双变量转变单变量）

用一道最简单的题来介绍

. - 力扣（LeetCode）

1.两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案，并且你不能使用两次相同的元素。

你可以按任意顺序返回答案。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]

示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]

提示：

• 2 <= nums.length <= 10^4
• -10^9 <= nums[i] <= 10^9
• -10^9 <= target <= 10^9
• 只会存在一个有效答案

进阶：你可以想出一个时间复杂度小于 O(n^2) 的算法吗？

这里介绍如何通过“维护左，枚举右”来优化程序到O(n)

首先x + y = t,可以转变成x = t - y,那么在从左往右遍历时，把之前遍历过的数放到左边存一个哈希表，此时的x = t - y如果出现在了哈希表当中，那么直接输出答案即可

代码

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int,int> pos;

        for(int i = 0;i < nums.size();i ++){
            int t = target - nums[i];
            if(pos.find(t) != pos.end()) return {i,pos[t]};
            pos[nums[i]] = i;
        }

        return {};
    }
};

 

. - 力扣（LeetCode） 

1014.最佳观光组合

给你一个正整数数组 values，其中 values[i] 表示第 i 个观光景点的评分，并且两个景点 i 和 j 之间的 距离 为 j - i。

一对景点（i < j）组成的观光组合的得分为 values[i] + values[j] + i - j ，也就是景点的评分之和 减去 它们两者之间的距离。

返回一对观光景点能取得的最高分。

示例 1：

输入：values = [8,1,5,2,6]
输出：11
解释：i = 0, j = 2, values[i] + values[j] + i - j = 8 + 5 + 0 - 2 = 11

示例 2：

输入：values = [1,2]
输出：2

提示：

• 2 <= values.length <= 5 * 10^4
• 1 <= values[i] <= 1000

这道题的话就需要去想了，暴力当然很好做，但是会tle。首先观察式子values[i] + values[j] + i - j,那么values[i] + i就是属于左边了，维护左边的（values[i] + i）最大值，枚举右边（valus[j] - j）找答案

代码

class Solution {
public:
    int maxScoreSightseeingPair(vector<int>& values) {
        int n = values.size();
        int mx = values[0],res = -1;
        
        for(int i = 1;i < n;i ++){
            res = max(res,mx + values[i] - i);
            mx = max(mx,values[i] + i);
        }

        return res;
    }
};

. - 力扣（LeetCode）

3267.统计近似相等数对||

注意：在这个问题中，操作次数增加为至多 两次 。

给你一个正整数数组 nums 。

如果我们执行以下操作 至多两次 可以让两个整数 x 和 y 相等，那么我们称这个数对是 近似相等 的：

• 选择 x 或者 y  之一，将这个数字中的两个数位交换。

请你返回 nums 中，下标 i 和 j 满足 i < j 且 nums[i] 和 nums[j] 近似相等 的数对数目。

注意 ，执行操作后得到的整数可以有前导 0 。

示例 1：

输入：nums = [1023,2310,2130,213]

输出：4

解释：

近似相等数对包括：

• 1023 和 2310 。交换 1023 中数位 1 和 2 ，然后交换数位 0 和 3 ，得到 2310 。
• 1023 和 213 。交换 1023 中数位 1 和 0 ，然后交换数位 1 和 2 ，得到 0213 ，也就是 213 。
• 2310 和 213 。交换 2310 中数位 2 和 0 ，然后交换数位 3 和 2 ，得到 0213 ，也就是 213 。
• 2310 和 2130 。交换 2310 中数位 3 和 1 ，得到 2130 。

示例 2：

输入：nums = [1,10,100]

输出：3

解释：

近似相等数对包括：

• 1 和 10 。交换 10 中数位 1 和 0 ，得到 01 ，也就是 1 。
• 1 和 100 。交换 100 中数位 1 和从左往右的第二个 0 ，得到 001 ，也就是 1 。
• 10 和 100 。交换 100 中数位 1 和从左往右的第一个 0 ，得到 010 ，也就是 10 。

提示：

• 2 <= nums.length <= 5000
• 1 <= nums[i] < 10^7

这道题的难点在于状态的表示，交换两次之后有多少种状态，处理好了状态之后，就跟前面两道题没有区别了。维护左边（存哈希表），枚举右边如果交换后与左边有相等的就+1

代码

class Solution {
public:
    int countPairs(vector<int>& nums) {
        int n = nums.size(),res = 0;
        unordered_map<int,int> hs;

        sort(nums.begin(),nums.end());
        for(auto x : nums){
            unordered_set<int> st = {x};
            string s = to_string(x);
            int m = s.size();
            for(int i = 0;i < m;i ++){
                for(int j = i + 1;j < m;j ++){
                    swap(s[i],s[j]);
                    st.insert(stoi(s));
                    for(int u = i + 1;u < m;u ++){
                        for(int v = u + 1;v < m;v ++){
                            swap(s[u],s[v]);
                            st.insert(stoi(s));
                            swap(s[u],s[v]);
                        }
                    }
                    swap(s[i],s[j]);
                }
            }
            for(auto y : st){
                if(hs.find(y) != hs.end()) res += hs[y];
            }
            hs[x] ++;
        }
        
        return res;
    }
};

加油