6096. Success logarithm of spells and potions

utilize hash Record spells Subscript where a single number appears , Yes spells Sort by increments , Yes potions Sort in descending order , Traverse spells when , You can be sure that you have traversed potions The position of does not need to be traversed , Then the position of the last jump , Just continue to traverse , This ensures potions Only be traversed once .

class Solution {
public:
    vector<int> successfulPairs(vector<int>& spells, vector<int>& potions, long long success) {
      int len = spells.size();
      vector<int> ans(len, 0);
      
      // key: val; 
      // value: val stay spells All subscripts in 
      map<int, vector<int>> indMap;
      // key: val;
      // value:  The val And potions The multiplication of the elements of is greater than or equal to  success The number of times 
      map<int, int> resMap;
      
      //  Storage spells The elements of , But each element is guaranteed to appear only once 
      vector<int> spe;
      
      //  Fill the above set 
      for(int i = 0; i < len; i++){
        int num = spells[i];
        
        auto it = resMap.find(num);
        if(it == end(resMap)){
          //  For the first time 

          resMap.emplace(num, 0);
          
          spe.push_back(num);  
          
          //  Most of the val It only occurs once, and the direct initialization capacity here is 1 that will do 
          vector<int> vec(1, i);
          indMap.emplace(num, vec);

        }else{
          //  The same subscript appears in other positions , Append this subscript directly to the list 
          indMap[num].push_back(i);
        }
      }  
      
      //  Sort by increments 
      sort(begin(spe), end(spe));

      //  Sort in descending order 
      sort(begin(potions), end(potions), [](int ele0, int ele1){ return ele0 > ele1;});
      
      long long numI, numJ;

      //  Store the last result 
      int res = 0;
      for(int i = 0; i < spe.size(); i++){
        //  At present val
        numI = spe[i];
        
        //  Continue the subscript of the last stop traversal 
        //  because spe The order of , Here you can guarantee res After that, you must be satisfied 
        int j = res;
        
        for(; j < potions.size();){
          numJ = potions[j];
          
          //  If you are not satisfied, just jump out 
          if(numI * numJ < success){  
            break;
          }
        
          //  Record the current results 
          res = (++j);
        }
        
        //  Record the current val The corresponding result 
        resMap[numI] = res;
      }
      
      //  Fill in everything val The result is ans
      for(auto &pair : resMap){
        // key  For the corresponding val
        int val = pair.first;
        
        // value  For the number of successful 
        int times = pair.second;
        
        //  same val But there are many , Fill the corresponding position 
        auto &vec = indMap[val];
        for(auto &ind : vec){
          ans[ind] = times;
        }
      }
      
      return ans;
    }
};