美妙的约会

#include <bits/stdc++.h>
using namespace std;
int main()
{
    int n;
    cin>>n;
    int a[2*n],mark[2*n];
    for(int i=0;i<2*n;i++)
    {
        cin>>a[i];
        mark[i]=1;
    }
    int left=0, right, count=0;
    while(left<2*n)
    {
        if(mark[left])
        {
            mark[left]=0;
            right=left+1;
            while(right<2*n && a[right]!=a[left])
            {
                count+=mark[right];
                ++right;
            }
            mark[right]=0;
        }
        left++;
    }
    cout<<count<<endl;
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

int main(){
    int n,m;
    cin>>n;
    m = 2*n;
    int a[m];
    bool b[m];
    for(int i=0;i<m;i++){
        cin>>a[i];
        b[i] = true;
    }
    int l=0,r=0,cnt=0;
    for(;l<m;l++){
        if(b[l]){
            b[l] = false;
            r = l+1;
            for(;r<m && a[r]!=a[l];r++)
                cnt += int(b[r]);
            b[r] = false;
        }
    }
    cout<<cnt<<endl;
    return 0;
}

k = int(input().strip())
nums = list(map(int, input().strip().split(" ")))
 
times = 0
 
for i in range(2*k):
    if i >= len(nums)-1:
        break
    for j in range(i+1, 2*k):
        if j >= len(nums):
            break
        if nums[j] == nums[i]:
            nums.pop(j)
            times += (j-i-1)
            break
print(times)

#include <iostream>
#include <vector>

using namespace std;

int main(){
    int n;
    cin >> n;
    int temp;
    vector<int> arr;
    int count = 0;
    
    while (cin >> temp)
        arr.push_back(temp);
    
    //1.找到第2i个人
    for (int i=0;i<n;++i){
        //2.看看他和对象是否坐在一起
        if (arr[2*i]==arr[2*i+1])
            //2.1 如果坐在一起，去找第2i+2个人
            continue;
        //2.2 如果不坐在一起
        else {
            int j = 2*i+1;
            //2.2.1 找到他的情侣
            for (;j<2*n;++j){
                if (arr[j]==arr[2*i])
                    break;
            }
            //2.2.2 把他的情侣换回来
            for (int k=j;k>2*i+1;--k){
                swap(arr[k],arr[k-1]);
                ++count;
            }
        }
        //3. 进入下一个循环
    }
    cout << count << endl;
    return 0;
}

#include<bits/stdc++.h>
using namespace std;

int n, a[100];

int main() {
    cin >> n;
    for(int i=0;i<2*n;i++)
        cin >> a[i];
    int ans = 0;
    unordered_set<int> st;
    for(int i=0;i<2*n && st.size()<n;i++) {
        if(st.find(a[i])!=st.end())
            continue;
        for(int j=i+1;a[j]!=a[i];j++)
            if(st.find(a[j])==st.end())
                ans++;
        st.insert(a[i]);
    }
    cout << ans << endl;
    return 0;
}

a,b,k = int(input()),input().split(),0
for i in range(0,a * 2,2):
    for j in range(i + 1,a * 2):
        if b[j] == b[i]:
            b = b[:i + 1] + [b[j]] + b[i + 1:j] + b[j + 1:]
            k += len(b[i + 1:j])
            break
print(k)

/*用id标识每个人实际位置，枚举每个人，寻找其情侣的位置，将靠后的情侣换过来
（两者之间人的id都+1，相当于后移一位）
*/
#include <bits/stdc++.h>
using namespace std;
const int AX = 1e2 + 66 ;
struct Node{
    int id ; 
    int v ; 
}a[AX];
map<int,int>mp ; 
int main(){
    int n ;
    cin >> n ; 
    int res = 0 ;
    int len = 2 * n ; 
    for( int i = 1 ; i <= len ; i++ ){
        cin >> a[i].v ;
        a[i].id = i ;
    }
    for( int i = 1 ; i < len ; i++ ){
        mp[a[i].v] = 1 ;
        for( int j = i + 1 ; j <= len ; j++ ){
            if( a[j].id < a[i].id ) continue ;
            if( mp[a[j].v] ){
                res += ( abs( a[j].id - a[i].id ) - 1 ) ; 
                for( int k = 1 ; k <= len ; k++ ){
                                        //两者之间人位置后移一位
                    if( a[j].id > a[k].id && a[k].id > a[i].id ) a[k].id ++ ; 
                }
                a[j].id = a[i].id + 1 ; //修改靠后情侣实际位置
                break ; 
            }
        }
        mp[a[i].v] = 0 ;
    }
    cout << res << endl ; 
    return 0 ; 
}

# 思路
# 以数组第一个元素ai[0]为基准，保存其值为first_item
# 在ai中找到第二个与first_item相等的数，记录其坐标为 second_item_index
# 在数组中删除这两个相等的元素
# 因为每次都会删除首部元素，删除之后迭代前的第二个元素就会成为首个元素
# 而且每次都以第一个元素ai[0]为基准，故 second_item_index 就是两个相同元素的距离
# 结果为 res 累加上 second_item_index

n = int(input())
ai = list(map(int, input().split()))
res = 0
while len(ai) > 0:
    first_item = ai[0]
    del ai[0]  # 从list中删除首个元素
    second_item_index = ai.index(first_item)  # 找到第二个元素的位置（也就是与首个元素的距离）
    res += second_item_index  # 累加距离
    del ai[second_item_index]  # 从list中删除第二个元素
print(res)

/*
有个人的思路是这样的：
先把所有人存入集合，从第一个开始找
向后找到与他编号相同的位置，两者相减就是要交换的次数，同时把这个与他编号相同的数剔除，
后面继续上面的操作。

其实如果你仔细思考也是这么回事，比如三个人，编号如下
1 3 1 2 3 2
第一次交换：
1 1 3 2 3 2（交换一次）
第二次交换：
1 1 3 3 2 2（交换一次）
结束。其实你会发现某个数交换完成后，其他的相对位置是不变的，比如，1交换完成后，3之间的相对位置是不变的，2同样

因此我们可以把它放到集合里面，找到与他相同编号的，就把那个剔除（记录交换次数），这也不会印象其他的编号交换
如：
找到第二个1后：
1 3 2 3 2（交换一次）
找到第二个3后：
1 3 2 2（交换一次）
找到第二个2后：
1 3 2（交换0次）
*/
import java.io.*;
import java.util.ArrayList;
public class Main{
    public static void main(String[] args)throws IOException{
        BufferedReader br = new BufferedReader( new InputStreamReader( System.in ));
        int n = Integer.parseInt(br.readLine());
        String[] str = br.readLine().split(" ");
        ArrayList<Integer> list = new ArrayList<Integer>();
        for(int i = 0;i<2*n;i++)
            list.add(Integer.parseInt(str[i]));
        
        //开始计数
        int count = 0;
        int i = 0;
        while(i<list.size()){
            int secIndex = list.lastIndexOf(list.get(i));
            count += (secIndex-i-1);
            list.remove(secIndex);
            i++;
        }
        System.out.println(count);
    }
}

package main

import (
    "fmt"
)

func main() {
    var n int
    fmt.Scan(&n)
    arr:=make([]int,2*n)
    for i:=0;i<2*n;i++{
        fmt.Scan(&arr[i])
    }
    ans:=0
    //每次寻找第一位的配对数，并计算相隔的距离，寻找到后把剩下的数组合成新的数组继续寻找
    for len(arr)>0{
        for i:=1;i<len(arr);i++{
            if arr[i]==arr[0]{
                ans+=i-1
                arr=append(arr[1:i],arr[i+1:]...)
                break
            }
        }
    }
    fmt.Print(ans)
}

import java.util.*;
public class Main{
    
    
    public static void main(String[] args){
        
       Scanner s  = new Scanner(System.in); 
       int n= s.nextInt();
      List<Integer> list = new ArrayList<>(2*n);
       for(int i=0;i<2*n;i++){
          list.add(s.nextInt());
       }
      int res=0;
      while(list.size()>0){
          int first = list.get(0);
          list.remove(0);
           int lastIndex = list.indexOf(first);
          res+=lastIndex;
          list.remove(lastIndex);
      }
      System.out.println(res);
       
    }  

// 贪心法，依次在i后面找到当前与a[i]相邻的个数，其中相邻中未被访问过

#include <bits/stdc++.h>
using namespace std;

const int N = 210;
bool st[N];
int a[N];
int n;

int main() {
    cin >> n;
    n *= 2;
    for (int i = 1; i <= n; ++ i) {
        cin >> a[i];
    }
    
    int ret = 0;
    for (int i = 1; i <= n; ++ i) {
        int t = a[i];
        if (!st[t]) {
            st[t] = true;
            int j = i + 1;
            while (j <= n && a[j] != t) {               
                
                if (!st[a[j]])
                    ret ++ ;
                j ++ ;
            }
        }
    }
    
    cout << ret << endl;
    return 0;
}