<p>You are given two <strong>0-indexed</strong> integer arrays <code>nums1</code> and <code>nums2</code>, of equal length <code>n</code>.</p>

<p>In one operation, you can swap the values of any two indices of <code>nums1</code>. The <strong>cost</strong> of this operation is the <strong>sum</strong> of the indices.</p>

<p>Find the <strong>minimum</strong> total cost of performing the given operation <strong>any</strong> number of times such that <code>nums1[i] != nums2[i]</code> for all <code>0 &lt;= i &lt;= n - 1</code> after performing all the operations.</p>

<p>Return <em>the <strong>minimum total cost</strong> such that </em><code>nums1</code> and <code>nums2</code><em> satisfy the above condition</em>. In case it is not possible, return <code>-1</code>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> nums1 = [1,2,3,4,5], nums2 = [1,2,3,4,5]
<strong>Output:</strong> 10
<strong>Explanation:</strong> 
One of the ways we can perform the operations is:
- Swap values at indices 0 and 3, incurring cost = 0 + 3 = 3. Now, nums1 = [4,2,3,1,5]
- Swap values at indices 1 and 2, incurring cost = 1 + 2 = 3. Now, nums1 = [4,3,2,1,5].
- Swap values at indices 0 and 4, incurring cost = 0 + 4 = 4. Now, nums1 =[5,3,2,1,4].
We can see that for each index i, nums1[i] != nums2[i]. The cost required here is 10.
Note that there are other ways to swap values, but it can be proven that it is not possible to obtain a cost less than 10.
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> nums1 = [2,2,2,1,3], nums2 = [1,2,2,3,3]
<strong>Output:</strong> 10
<strong>Explanation:</strong> 
One of the ways we can perform the operations is:
- Swap values at indices 2 and 3, incurring cost = 2 + 3 = 5. Now, nums1 = [2,2,1,2,3].
- Swap values at indices 1 and 4, incurring cost = 1 + 4 = 5. Now, nums1 = [2,3,1,2,2].
The total cost needed here is 10, which is the minimum possible.
</pre>

<p><strong class="example">Example 3:</strong></p>

<pre>
<strong>Input:</strong> nums1 = [1,2,2], nums2 = [1,2,2]
<strong>Output:</strong> -1
<strong>Explanation:</strong> 
It can be shown that it is not possible to satisfy the given conditions irrespective of the number of operations we perform.
Hence, we return -1.
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>n == nums1.length == nums2.length</code></li>
	<li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
	<li><code>1 &lt;= nums1[i], nums2[i] &lt;= n</code></li>
</ul>

class Solution:
    def minimumTotalCost(self, L1: List[int], L2: List[int]) -> int:
        dic1={}
        dic2={}
        for j in range (0,len(L1)):
            dic1[L1[j]]=dic1.get(L1[j],0)+1
            dic2[L2[j]]=dic2.get(L2[j],0)+1
        for x in dic1:
            if dic1.get(x,0)+dic2.get(x,0)>len(L1):
                return -1
        M=[]
        for j in range (0,len(L1)):
            if L1[j]==L2[j]:
                M.append([j,L1[j]])
        dic={}
        for j in range (0,len(M)):
            dic[M[j][1]]=dic.get(M[j][1],0)+1
        boolean=True
        num=0
        for x in dic:
            if dic[x]>len(M)//2:
                boolean=False
                num=x
                break
        if boolean==True:
            ans=0
            for j in range (0,len(M)):
                ans=ans+M[j][0]
            return ans
        count=dic[num]
        for x in dic:
            if x!=num:
                count=count-dic[x]
        ans=0
        visited=[True]*len(L1)
        for j in range (0,len(M)):
            visited[M[j][0]]=False 
        for j in range (0,len(L1)):
            if L1[j]!=num and L2[j]!=num and visited[j]==True :
                ans=ans+j
                count=count-1
            if count==0:
                break
        for j in range (0,len(M)):
            ans=ans+M[j][0]
        return ans
49300