Pour rendre le tableau identique en échangeant des éléments

Il existe 2 tableaux i / p. Ils sont identiques lorsqu'ils contiennent exactement les mêmes numéros. Pour les rendre identiques, nous pouvons échanger leurs éléments. L'échange aura un coût. Si nous échangeons les éléments a et b, alors cost = min (a, b).

Tout en rendant le tableau identique, le coût devrait être minimum.
S'il n'est pas possible de rendre le tableau identique, alors imprimez -1.

#include<iostream>
#include<algorithm>
#include<map>

using namespace std;

int main()
{
    int t;
    cin >> t;
    while(t--)
    {
        int size;
        long long int cost = 0;
        cin >> size;
        bool flag = false;
        map<long long int, int> aMap;
        map<long long int, int> bMap;
        
        // storing frequency of elements of 1st input array in map
        for( int i = 0 ; i < size; i++)
        {
            long long int no;
            cin >> no;
            aMap[no]++;
        }

        // storing frequency of elements of 2nd input array in map
        for(int i = 0 ; i < size; i++)
        {
            long long int no;
            cin >> no;
            bMap[no]++;
        }

        // fetching smallest element (i.e. 1st element) from both map
        long long int firstNo = aMap.begin()->first;
        long long int secondNo = bMap.begin()->first;
        long long int smallestNo;
       
        // finding smallest element from both maps
        if(firstNo < secondNo)
            smallestNo = firstNo;
        else
            smallestNo = secondNo;

        map<long long int, int> :: iterator itr;

        // trying to find out total number of swaps we have to perform
        int totalSwapsFromA = 0;
        int totalSwapsFromB = 0;

        // trversing a map
        for(itr = aMap.begin(); itr != aMap.end(); itr++)
        {
            // if element "a" in aMap is also present in bMap, then we have to consider
            // number of swapping = abs(freq(a) in aMap - freq(a) in bMap)
            auto newItr = bMap.find(itr->first);
            if(newItr != bMap.end())
            {
                if(itr->second >= newItr->second)
                {
                    itr->second -= newItr->second;
                    newItr->second = 0;
                }
                else
                {
                    newItr->second -= itr->second;
                    itr->second = 0;   
                }                        
            }
            // if freq is "odd" then, this input is invalid as it can not be swapped
            if(itr->second & 1 )
            {
                flag = true;
                break;
            }
            else
            {
                // if freq is even, then we need to swap only for freq(a)/ 2 times
                itr->second /= 2;

                // if swapping element is smallest element then we required 1 less swap
                if(itr->first == smallestNo && itr->second != 0)
                    totalSwapsFromA += itr->second -1;
                else
                    totalSwapsFromA += itr->second;
            }
            
        }  

        // traversing bMap to check whether there any number is present which is 
        // not in aMap.
      if(!flag)
      {
        for(itr = bMap.begin(); itr != bMap.end(); itr++)
        {
            auto newItr = aMap.find(itr->first);
            if( newItr == aMap.end())
            {
                // if frew is odd , then i/p is invalid
                if(itr->second & 1)
                {
                    flag = true;
                    break;
                }
                else
                {
                    itr->second /= 2;

                    // if swapping element is smallest element then we required 1 less swap
                    if(itr->first == smallestNo && itr->second != 0)
                        totalSwapsFromB += itr->second -1;
                    else
                        totalSwapsFromB += itr->second;
                    
                }
                
            }
        } 
     }
       if( !flag )
       {   
          cost = smallestNo * (totalSwapsFromB + totalSwapsFromA);
          cout<<"cost "<<cost <<endl;
       }
       else
           cout<<"-1"<<endl;
    }
    return 0;
}
    

Ici, j'ai permuté (2,7) et (2,6). Donc, Coût minimum = 2 + 2 = 4.

Logique:

1. Créez 2 cartes qui enregistreront la fréquence des éléments du tableau i / p.

2. si l'élément "a" dans aMap est également présent dans bMap, alors nous devons considérer le nombre de permutation pour a = abs (freq (a) dans aMap - freq (a) dans bMap)

3. si la fréquence des éléments est "impaire", alors impossible de les rendre identiques.

4. sinon, ajoutez le total des échanges à partir des deux cartes et recherchez le coût à l'aide de
   coût = plus petit élément * total des swaps

Voici le code

i/p:     
3 6 6 2  
2 7 7 3   

o/p :     
4     
   

Aucune erreur dans le code ci-dessus mais une mauvaise réponse et ne pas être accepté.
Quelqu'un peut-il améliorer ce code / cette logique?