""""
逆序去重输出
"""

if __name__ == "__main__":
    T = int(input().strip())
    for _ in range(T):
        n = int(input().strip())
        a = list(map(int, input().strip().split()))
        ans = []
        for i in range(len(a) - 1, -1, -1):
            if a[i] not in ans:
                ans.append(a[i])
        print(' '.join(map(str, ans)))

	

import java.util.Deque;
import java.util.LinkedList;
import java.util.Scanner;

/**
 * @author yanglaiyi
 * @title: 会话列表
 * @projectName 牛课刷题之栈
 * @description: TODO
 * @date 2020/4/15 10:31
 */
public class 会话列表 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int anInt = sc.nextInt();//读取输入的组数

        while (anInt > 0) {
            anInt--;
            int length = sc.nextInt();//读取输入的长度，即数组长度
            int[] a = new int[length];
            for (int i = 0; i < length; i++) {//输入数组
                a[i] = sc.nextInt();
            }

            Deque<Integer> dq = new LinkedList<Integer>();
            for (int i = 0; i < a.length; i++) {
                if (dq.contains(a[i])) {
                    dq.remove(a[i]);
                    dq.addFirst(a[i]);
                } else dq.addFirst(a[i]);
            }
            for (Integer i : dq) {
                System.out.print(i + " ");
            }
            System.out.println();
            dq.clear();
        }


    }


}利用队列操作

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashSet;

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(bf.readLine());
        for (int i = 0; i < n; i++) {
            int m = Integer.parseInt(bf.readLine());
            System.out.println(getDialogue(bf.readLine(),m));
        }
    }

    //用一个HashSet保存ID，做一个判断作用，从后往前遍历，如果set不包含该id，就添加进去。
    private static String getDialogue(String s, int m) {
        StringBuilder sb = new StringBuilder();
        HashSet<String> set = new HashSet<>();
        String[] ids = s.split(" ");
        for (int i = m - 1; i >= 0; i--) {
            if (!set.contains(ids[i])) {
                set.add(ids[i]);
                sb.append(ids[i]).append(" ");
            }
        }
        return sb.substring(0,sb.length()-1).toString();
    }
}

#include <iostream>
#include <vector>
#include <map>
using namespace std;
 
int main() {
    int T, N;
    cin >> T;
    for (int i = 0; i < T; ++i) {
        cin >> N;
        map<int,int> sessions, res;
        int sessionID;
        for (int j = 0; j < N; ++j) {
            cin >> sessionID;
            if(sessions.count(sessionID) > 0 ){
                int k = sessions[sessionID];
                res.erase(k);
            }
            res[N - j] = sessionID;
            sessions[sessionID] = N - j;
        }
 
        auto iter = res.begin();
        while (iter != res.end()){
            cout << iter -> second << " ";
            iter ++;
        }
        cout << endl;
 
    }
 
    return 0;
}

	
	

		# 给出python代码，以供参考
	

	

		# 用list实现一个栈的功能
	

	

		n=int(input())
	

	

		foriinrange(0,n):
	

	

		    m=int(input())
	

	

		    s=input()
	

	

		    temp=[]
	

	

		    forjinrange(0,m):
	

	

		        s1=s.split(' ')[j]
	

	

		        ifs1notintemp:  # 如果栈中不存在，则进栈
	

	

		            temp.append(s1)
	

	

		        else:
	

	

		            temp.remove(s1)  # 如果存在，先将栈中元素删除，再进栈
	

	

		            temp.append(s1)
	

	

		    result=[]       
	

	

		    forkinrange(0,len(temp)):
	

	

		        result.append(temp.pop())
	

	

		    result=' '.join(result)
	

	

		    print(result)
	

include<iostream>

include<string.h>

include<algorithm>

include<vector>

using namespace std;

//按照倒序，依次输出序号即可，已经输出的则不输出
int main(){

int n;
int t;
string id[300];
string s;
string temp;
vector<string>v;

cin>>t;

while(t--){
cin>>n;
s="";
temp="";
for(int i=0;i<n;i++){ cin>>id[i];
}
for(int i=n-1;i>=0;i--){
for(int j=i-1;j>=0;j--){
if(id[i]==id[j]) id[j]="s"; //做标记
}
}
for(int i=n-1;i>=0;i--){
if(id[i]!="s") s=s+id[i]+" ";
}
for(int i=0;i<s.size()-1;i++){
temp=temp+s[i];
}
v.push_back(temp);
}
for(int i=0;i<v.size();i++){
cout<<v[i]<<endl;
}

return 0;

}

n=int(input())
for i in range(n):
    s=int(input())
    num=list(map(str,input().split()))
    res=[]
    for i in num:
        if i not in res:
            res.insert(0,i)
        else:
            res.remove(i)
            res.insert(0,i)
    print(" ".join(res))

//栈和unodered_map集合一起配合的方法 #include<iostream>
#include<stack>
#include<unordered_map>
using namespace std;
int main()
{
    int T;
    cin>>T;
    while(T--)
    {
        int n;
        cin>>n;
        stack<long> s;
        for(int i=0;i<n;i++)
        {
            int num;
            cin>>num;
            s.push(num);
        }
        unordered_map<long,int> m;
        int i=0;
        while(!s.empty())
        {
            if(m.end()==m.find(s.top()))
            {
                m.insert({s.top(),i++});
                cout<<s.top()<<" ";
            }
            s.pop();
        }
        cout<<endl;
    }
}

	//vector和unordered_map集合配合使用 



	#include<iostream>



	#include<vector>



	#include<unordered_map>



	usingnamespacestd;



	intmain()



	{



	    intT;



	    cin>>T;



	    while(T--)



	    {



	        intn;



	        cin>>n;



	        vector<long> v;



	        for(inti=0;i<n;i++)



	        {



	            intnum;



	            cin>>num;



	            v.push_back(num);



	        }



	        unordered_map<long,int> m;



	        for(inti=v.size()-1;i>=0;i--)



	        {



	            if(m.end()==m.find(v[i]))



	            {



	                m.insert({v[i],i});



	                cout<<v[i]<<" ";



	            }



	        }



	        cout<<endl;



	    }



	}

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            int n = sc.nextInt();
            for(int i = 0; i<n; i++){ 
                Stack<Integer> stack = new Stack<>();
                int number = sc.nextInt();
                for(int j = 0; j<number; j++){
                    stack.push(sc.nextInt());
                }
                Set<Integer> set = new LinkedHashSet<>();//使用LinkedHashSet能保证不重复且在set中的顺序与存入顺序一致
                while(!stack.isEmpty()){
                    set.add(stack.pop());
                }
                for(int next : set){
                    System.out.print(next+" ");
                }
                System.out.println();
            }
        }
    }
}

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

int main(){
    int T,n;
    cin>>T;
    while(T--){
        cin>>n;
        int a[n];
        map<int,bool> vis;
        vector<int> v;
        for(int i=0;i<n;i++)
            cin>>a[i];
        bool first = true;
        for(int i=n-1;i>=0;i--){
            if(vis.find(a[i])==vis.end()){
                vis[a[i]] = true;
                v.push_back(a[i]);
                if(first){
                    cout<<a[i];
                    first = false;
                }else
                    cout<<" "<<a[i];
            }
        }
        cout<<endl;
    }
    return 0;
}

#include <iostream>
#include <vector>
using namespace std;
int main() {
	bool check(vector<int>* s, int num);
	int eNum = 0;
	scanf("%d", &eNum);
	for (int i = 0; i < eNum; i++) {
		int size = 0;
		scanf("%d", &size);
		vector<int> mesId;
		for (int j = 0; j < size; j++) {
			int num = 0;
			cin >> num;
			mesId.push_back(num);
			for (int k = 0; k < mesId.size() - 1;) {
				if (mesId[k] == num) {
					mesId.erase(mesId.begin() + k);
					continue;
				}
				k++;
			}
		}
		for (int j = mesId.size(); j > 0; j--) {
			if (j != mesId.size())
					cout << ' ';
			cout << mesId[j - 1];
		}
		cout << endl;
	}
}

算法的过程前面的解析说得很透彻了，我的AC就是用java现成数据结构来精简代码，供大家参考

import java.util.*;
import static java.lang.System.in;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(in);
        int m = Integer.parseInt(sc.nextLine());
        while (m-- > 0) {
            sc.nextLine();
            String[] ids = sc.nextLine().split(" ");
            LinkedHashSet<String> set = new LinkedHashSet<>();
            List list = Arrays.asList(ids);
            Collections.reverse(list);
            set.addAll(list);
            StringBuilder sb = new StringBuilder();
            for (String item : set) {
                sb.append(item).append(" ");
            }
            System.out.println(sb.substring(0,sb.length()-1));
        }
    }
}

import java.util.ArrayList;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int t = scanner.nextInt();
        for (int i = 0; i < t; i++) {
            int n = scanner.nextInt();
            String[] id = new String[n];
            for (int j = 0; j < n; j++) {
                id[j] = scanner.next();
            }
            ArrayList<String> list = new ArrayList<>();
            for (int j = id.length - 1; j >= 0; j--) {
                if (!list.contains(id[j])) {
                    list.add(id[j]);
                }
            }
            StringBuilder sb = new StringBuilder();
            for (String str : list) {
                sb.append(str + " ");
            }
            System.out.println(sb.toString().trim());
        }
    }
}

import java.util.HashSet;
import java.util.Scanner;
 
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int group_len = sc.nextInt();
        int[][] groups = new int[group_len][];
        for(int i = 0; i < group_len; i++){
            int len = sc.nextInt();
            groups[i] = new int[len];
            for(int j = 0; j < len; j++){
                groups[i][j] = sc.nextInt();
            }
        }
        sc.close();
        for(int i = 0; i < group_len; i++){
            HashSet<Integer> set = new HashSet<>();
            for(int j = groups[i].length - 1; j >= 0; j--){
                if(j != groups[i].length - 1 && set.contains(groups[i][j])) continue;
                set.add(groups[i][j]);
                System.out.print(groups[i][j] + " ");
            }
            System.out.println();
        }
 
    }
}

	

思路：每次都将元素压入栈中，然后在逐个弹出栈，每次弹出的时候判断HashSet里面有没有该元素，如果没有就打印元素并将元素加到HashSet中，如果HashSet中有该元素，则什么都不做。

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        while (t-- > 0) {
            Stack<Integer> stack = new Stack<>();
            HashSet<Integer> set = new HashSet<>();
            int n = sc.nextInt();
            for (int i = 0; i < n; i++) {
                stack.push(sc.nextInt());
            }
            while (!stack.isEmpty()) {
                int temp = stack.pop();
                if (!set.contains(temp)) {
                    set.add(temp);
                    System.out.print(temp + " ");
                }
            }
            System.out.println();
        }
    }
}

#include <iostream>
#include <map>
#include <vector>
using namespace std;

int main()
{
    int n, m;
    cin >> n;
    vector<vector<int>> v(n);
    vector<vector<int>> vRes;
    for (int i = 0; i < n; i++)
    {
        cin >> m;
        v[i].resize(m);
        for (int j = 0; j < m; j++)
        {
            cin >> v[i][j];
        }
    }
    for (int i = 0; i < n; i++)
    {
        vector<int> vTmp;
        map<int, int> mp;
        for (int j = v[i].size() - 1; j >= 0; j--)
        {
            if (mp[v[i][j]] == 0)
            {
                mp[v[i][j]] = 1;
                vTmp.push_back(v[i][j]);
            }
        }
        vRes.push_back(vTmp);
    }
    for (int i = 0; i < vRes.size(); i++)
    {
        for (int j = 0; j < vRes[i].size() - 1; j++)
        {
            cout << vRes[i][j] << " ";
        }
        cout << vRes[i][vRes[i].size() - 1] << endl;
    }
    return 0;
}