力扣：常用数据结构（零）：枚举右维护左

来源：

灵神题单

1. 两数之和

该题用哈希表来做，定义一个指针，从左往右遍历数组，对于每次查找在map里查找是否存在

target-nums[j],若有直接返回即可。

若没有，将该指针指向的元素放入map里，为后续做准备

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> a(2);
        map<int,int> m;
        for(int j=0;;j++)
        {
            auto i=m.find(target-nums[j]);
            if(i!=m.end())
            {
                return {j,i->second};
            }
            m[nums[j]]=j;
        }
        return {};
    }
};

1512. 好数对的数目

依然采用哈希表做。

定义一个指针j遍历数组，用map做哈希表来放，第一个放nums[j]，第二个放该值到目前有多少个

指针遍历数组每一个位置，查找是否有相同的值在哈希表下标中，有的话将个数加到ant上，值++

若没有则将该值作为下标放入，数量为1

class Solution {
public:
    int numIdenticalPairs(vector<int>& nums) {
     int ant=0;
     map<int,int> m;
     
     for(int j=0;j<nums.size();j++)
     {
        auto i=m.find(nums[j]);
        if(i!=m.end())
        {
        ant+=i->second;
        m[nums[j]]++;
        }
       else m[nums[j]]=1;
     }
     return ant;
    }
};

2815. 数组中的最大数对和

依然是练习哈希表。哈希下标为该数最大值，映射为最大数

用一个指针j遍历，扫描到的每一个nums[j],先算出最大数maxj,然后判断哈希表里有无以maxj为下标的映射，若有，则ant存本身和两数相加中的较大值，并更新哈希表，存两数较大值。

若无则将该值放入哈希表中。

class Solution {
public:
    int maxSum(vector<int>& nums) {
        int ant =-1;
        map<int,int> m;
        for(int j=0;j<nums.size();j++)
        {
            int maxj=0,k=nums[j];
            while(k)
            {
                maxj=max(maxj,k%10);
                k/=10;
            }
            auto i= m.find(maxj);
            if(i!=m.end())
            {
                ant=max(ant,nums[j]+m[maxj]);
                 m[maxj]=max(m[maxj],nums[j]);
            }
            else m[maxj]=nums[j];
        }
        return ant;
    }
};

219. 存在重复元素 II

哈希表。下标存nums[j],映射 存j

指针j遍历数组，判断当前值哈希表是否有，若有判断下标差绝对值是否<=k,是返回1

其它情况更新哈希表

class Solution {
public:
    bool containsNearbyDuplicate(vector<int>& nums, int k) {
    map<int,int> m;
    for(int j=0;j<nums.size();j++)
    {
        auto i=m.find(nums[j]);
        if(i!=m.end())
        {
            if(abs(i->second-j)<=k)
            return 1;
        }
        m[nums[j]]=j;
    }

return 0;
    }
};

121. 买卖股票的最佳时机

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int ant=0;
        int m=10005;
        for(int i=0;i<prices.size();i++)
        {
            int j=prices[i];
            ant=max(ant,j-m);
            m=min(j,m);
        }
  return ant;
    }
};

2342. 数位和相等数对的最大和

哈希：下标存数位和，映射存数

遍历数组，先算出数位和，然后判读，若在表中，两数相加与ant取max，然后更新哈希表为较大值。  若无，则存入哈希表中

class Solution {
public:
    int maximumSum(vector<int>& nums) {
        int ant=-1;
        map<int,int> m;
        for(int j=0;j<nums.size();j++)
        {
            int he=0,k=nums[j];
            while(k)
            {
                he+=k%10;
                k/=10;
            }
        
            auto i=m.find(he);
            if(i!=m.end())
            {
                ant=max(ant,i->second+nums[j]);
                i->second=max(i->second,nums[j]);
            }
            else m[he]=nums[j];
        }
        return ant;
    }
};

3185. 构成整天的下标对数目 II

class Solution {
public:
    long long countCompleteDayPairs(vector<int>& hours) {
        long long ant=0;
        map<int,int> m;
        for(int j=0;j<hours.size();j++)
        {
            hours[j]=hours[j]%24;
            auto i=m.find((24-hours[j])%24);
            if(i!=m.end())
            {
                ant+=i->second;
                
            }
             m[hours[j]]++;
        }
        return ant;
    }
};

1814. 统计一个数组中好对子的数目

class Solution {
public:
    int countNicePairs(vector<int>& nums) {
      map<int,int> m;
      long long ant=0;
      long long biao=1e9+7;
      for(int i=0 ;i<nums.size();i++)
      {
        string a=to_string(nums[i]);
        reverse(a.begin(),a.end());
        long long b=nums[i]-stoi(a);
        auto j=m.find(b);
        if(j!=m.end())
        {
            ant=(ant+j->second)%biao;
        }
        m[b]++;
      }
return ant;
    }
};

454. 四数相加 II

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3,
                     vector<int>& nums4) {
        map<int,int> m1,m2;
        int ant=0;
        for (int i : nums1)
            for (int j : nums2)
                m1[i+j]++;
        for (int i : nums3)
            for (int j : nums4)
                m2[i+j]++;
        
        for(auto i:m1)
           {
             auto j=m2.find(-i.first);
             if(j!=m2.end())
             {
                ant+=(j->second)*(i.second);
             }
            
           }
          
           return ant;
    }
};