Problem:
Score : 300 points

Problem Statement

A sequence a_1,a_2,... ,a_n is said to be /\/\/\/ when the following conditions are satisfied:

For each i = 1,2,..., n-2, a_i = a_{i+2}.

Exactly two different numbers appear in the sequence.

You are given a sequence v_1,v_2,...,v_n whose length is even.
We would like to make this sequence /\/\/\/ by replacing some of its elements.
Find the minimum number of elements that needs to be replaced.

Constraints

2 \leq n \leq 10^5

n is even.

1 \leq v_i \leq 10^5

v_i is an integer.

Input

Input is given from Standard Input in the following format:

n
v_1 v_2 ... v_n

Output

Print the minimum number of elements that needs to be replaced.

Sample Input 1

4
3 1 3 2

Sample Output 1

1

The sequence 3,1,3,2 is not /\/\/\/, but we can make it /\/\/\/ by replacing one of its elements: for example, replace the fourth element to make it 3,1,3,1.

Sample Input 2

6
105 119 105 119 105 119

Sample Output 2

0

The sequence 105,119,105,119,105,119 is /\/\/\/.

Sample Input 3

4
1 1 1 1

Sample Output 3

2

The elements of the sequence 1,1,1,1 are all the same, so it is not /\/\/\/.

Solution in Fortran (GNU Fortran 9.2.1) (judge verdict: Accepted)

program prob3
    implicit none
    integer::n, i, j, tmp, emax, omax, ei, oi
    integer, allocatable::v(:)
    integer::e(100000), o(100000)
    read(*,*) n
    allocate(v(n))
    read(*,*) v
    e = 0
    o = 0
    emax = 0
    omax = 0
    do i = 1, n
        tmp = v(i)
        if(mod(i,2) == 0) then
            e(tmp) = e(tmp) + 1
        else
            o(tmp) = o(tmp) + 1
        end if
    end do
    do i = 1, 100000
        if(e(i) > emax) then
            emax = e(i)
            ei = i
        end if
        if(o(i) > omax) then
            omax = o(i)
            oi = i
        end if
    end do
    if(ei /= oi) then
        write(*,*) n - emax - omax
    else
        call heapsort(100000,e)
        call heapsort(100000,o)
        write(*,*) n - max(e(99999)+o(100000), e(100000)+o(99999))
    end if
    stop
contains
    subroutine heapsort(n,array)
        implicit none
        integer,intent(in) :: n
        integer,intent(inout) :: array(1:n)
    
        integer ::i,k,j,l
        double precision :: t
    
        if(n.le.0)then
        write(6,*)"Error, at heapsort"; stop
        endif
        if(n.eq.1)return
    
        l=n/2+1
        k=n
        do while(k.ne.1)
        if(l.gt.1)then
            l=l-1
            t=array(L)
        else
            t=array(k)
            array(k)=array(1)
            k=k-1
            if(k.eq.1) then
                array(1)=t
                exit
            endif
        endif
        i=l
        j=l+l
        do while(j.le.k)
            if(j.lt.k)then
                if(array(j).lt.array(j+1))j=j+1
            endif
            if (t.lt.array(j))then
                array(i)=array(j)
                i=j
                j=j+j
            else
                j=k+1
            endif
        enddo
        array(i)=t
        enddo
    
        return
    end subroutine heapsort
end program