查找重复序列

Python hash解法

from collections import OrderedDict
if __name__ == '__main__':
    N = int(input())
    res = OrderedDict()
    for i in range(N):
        input()
        hash_code = hash(input())
        if hash_code in res:
            res[hash_code].append(i)
        else:
            res[hash_code] = [i]
    is_find = False
    for k, v in res.items():
        if len(v) > 1:
            is_find = True
            print(*v)
    if not is_find:
        print('no')

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;

public class Main {

    //判断两个list是否相同
    public static boolean sameArr(List<Integer> list1, List<Integer> list2) {
        if (list1.size() != list2.size()) {
            return false;
        } else {
            for (int i = 0; i < list1.size(); i++) {
                if (!(list1.get(i).equals(list2.get(i))))
                    return false;
            }
            return true;
        }
    }

    public static void sameSet(List<List<Integer>> list) {
        //这个set用来去重。假如i=2，3，8时三个序列相同。那么只需要遍历i=2时就好了 ，i=3和i=8的时候直接跳过
        Set<Integer> set = new TreeSet<Integer>();
        int isHave = 0;
        //这个isHave用来表示整个List<List<Integer>> list是否用相同的序列
        for (int i = 0; i < list.size() - 1; i++) {
            int flag = 0;
            // 这个flag用来表示 是否有与list.get(i)相同的序列
            if (set.contains(i)) {
                continue;
            }
            StringBuilder builder = new StringBuilder();
            //这个builder用于保存满足条件的一次输出结果，一次循环结束之后，输出就可以了。
            // 下面隐去的三个System.out.print就是我最开始的输出方式。但是测试的时候超时了。使用System.out.print需要进行各种切换，保护现场以及恢复现场，非常耗时
            //后来就想到用builder保存结果，使用一次System.out.print。速度快了很多，顺利通过。
            for (int j = i + 1; j < list.size(); j++) {
                if (sameArr(list.get(i), list.get(j)) && flag == 0) {
                    //注意这个if条件和下面那个if条件的区别，这个表示第一次有序列与list.get(i)相同，那么i和j必须都加进去
                    builder.append(i+" "+j);
                    // System.out.print(i + " " + j);
                    flag++;
                    isHave++;
                    set.add(i);
                    set.add(j);
                    continue;
                }
                if (flag != 0 && sameArr(list.get(i), list.get(j))) {
                    //进入这个循环表明至少有两个序列和list.get(i)相同，因为第一次加了i，所以只的每一场只需要加j就好了
                     builder.append(" "+j);
                    // System.out.print(" " + j);
                    set.add(j);
                }
            }
            if (flag != 0) {
                //System.out.println();
                System.out.println(builder.toString());
            }
        }
        if (isHave == 0) {
            System.out.println("no");
        }
    }

    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);
        List<List<Integer>> list = new ArrayList<List<Integer>>();
        while (in.hasNextInt()) {
            int num = in.nextInt();
            List<Integer> tmp = new ArrayList<Integer>();
            for (int i = 0; i < num; i++) {
                int n = in.nextInt();
                tmp.clear();
                for (int j = 0; j < n; j++) {
                    tmp.add(in.nextInt());
                }
                list.add(new ArrayList<Integer>(tmp));
            }
            sameSet(list);
            list.clear();
        }
    }
}

#include <string>
#include <unordered_map>
#include <vector>
#include <iostream>
using namespace std;
vector<string> arr;
unordered_map<int, bool> map;
int main() {
    int n, m, num;
    bool flag = false;
    cin >> n;
    for (int i = 0; i < n; i++) {
        string s;
        cin >> m;
        for (int j = 0; j < m; j++) {
            cin >> num;
            s += to_string(num);
        }
        arr.push_back(s);
    }
    for (int i = 0; i < arr.size() - 1; i++) {
        if (map.find(i) != map.end())
            continue;
        vector<int> res;
        res.push_back(i);
        for (int j = i + 1; j < arr.size(); j++) {
            if (map.find(j) != map.end())
                continue;
            if (arr[i] == arr[j]) {
                res.push_back(j);
                map[i] = true;
                map[j] = true;
            }
        }
        if (res.size() > 1) {
            flag = true;
            for (int k = 0; k < res.size(); k++) {
                cout << res[k] << " ";
            }
            cout << "" << endl;
        }
    }
    if (!flag)
        cout << "no" << endl;
    return 0;

}
// 64 位输出请用 printf("%lld")

//我尝试将数组序列转换成字符串，然后再去比较，但是有两个测试示例不能通过，希望有小伙伴帮忙看一下

import sys

if __name__ == "__main__":
    N = int(sys.stdin.readline().strip())
    data_list = []
    unique_dict = {}

    for i in range(N):
        L = sys.stdin.readline().strip()
        data_list.append(tuple(map(int, sys.stdin.readline().strip().split(" "))))
    res = []
    for i in range(N):
        if data_list[i] not in unique_dict:
            unique_dict[data_list[i]] = [i]  # 将序列作为key，下标作为value
        else:
            unique_dict[data_list[i]].append(i)
    flag = True
    for key, value in unique_dict.items():
        # 找出重复的序列，将其下标添加到res中
        if len(value) > 1:
            flag = False
            res.append(value)

    if flag:
        print("no")
    else:
        res.sort()  # 结果对目标有排序要求，因此将unique_dict中的value进行排序，在输出
        for value in res:
            tmp = [str(j) for j in value]
            print(' '.join(tmp))

import java.util.*;
 
public class Main {
    public static void main(String[] args) {
        run();
    }
     
    public static void run(){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        sc.nextLine();
        HashMap<String,List<Integer>> amap = new HashMap<String, List<Integer>>();
        for(int i=0;i<n;i++){
                int m = sc.nextInt();sc.nextLine();
                String t = sc.nextLine();
                List<Integer> a = new ArrayList<>();
                if(amap.containsKey(t)){
                     a = amap.get(t);
                }
                a.add(i);
                amap.put(t, a);
//          }
        }
//      int tmp = 0;
        TreeMap<Integer,List<Integer>> re = new TreeMap<Integer, List<Integer>>();
        for(String k:amap.keySet()){
            List<Integer> a = amap.get(k);
            if(a.size()>1){
                re.put(a.get(0), a);
            }
        }
        for(int i:re.keySet()){
            List<Integer> a = re.get(i);
            for(int j:a){
                System.out.print(j+" ");
            }
            System.out.println();
        }
        if(re.size()<1){
            System.out.println("no");
        }
    }
}

#include<iostream>
#include<vector>
#include<list>
#include<unordered_map>
#include<algorithm>
using namespace std;
 
struct ArrayProxy{
    ArrayProxy(vector<vector<int>>& arr, int idx)
        : mIdx(idx)
        , mSum(std::accumulate(arr[idx].begin(), arr[idx].end(), 0))
        , mLen(static_cast<int>(arr[idx].size()))
        , mArray(&arr) {
             
    }
public:
    int mIdx;
    int mSum;
    int mLen;
    vector<vector<int>>* mArray;
};
 
struct ArrayProxyHash{
    size_t operator()(const ArrayProxy& arrproxy) const noexcept{
        return arrproxy.mSum;
    }
};
 
struct ArrayProxyEqual{
    bool operator()(const ArrayProxy& lhs, const ArrayProxy& rhs) const{
        if(lhs.mSum != rhs.mSum || lhs.mLen != rhs.mLen)
            return false;
        int len = lhs.mLen;
        vector<int>& larr = (*(lhs.mArray))[lhs.mIdx];
        vector<int>& rarr = (*(rhs.mArray))[rhs.mIdx];
        for(int i = 0; i < len; ++i){
            if(larr[i] != rarr[i])
                return false;
        }
        return true;
    }
};
 
int main(){
    int N; cin >> N;
    vector<vector<int>> nums(N);
    for(int i = 0; i < N; ++i){
        int len; cin >> len;
        vector<int> arr(len);
        for(int j = 0; j < len; ++j)
            cin >> arr[j];
        nums[i].swap(arr);
    }
    vector<list<int>> colli(N);
    unordered_map<ArrayProxy, 
                  int, 
                  ArrayProxyHash, 
                  ArrayProxyEqual>  hash;
    for(int i = 0; i < N; ++i){
        ArrayProxy aproxy(nums, i);
        if(hash.count(aproxy))
            colli[hash[aproxy]].push_back(i);
        else
            hash[aproxy] = i;
    }
    int k = 0;
    for(int i = 0; i < N; ++i){
        if(colli[i].empty()){
            ++k;
            continue;
        }
        cout << i << ' ';
        for(auto iter = colli[i].begin(); iter != colli[i].end(); ++iter)
            cout << *iter << ' ';
        cout << '\n';
    }
    if(k == N) cout << "no\n";
    return 0;
}

n = int(input())
seqs = []
for i in range(n):
    length  = int(input())

    seqs.append(tuple(map(int,input().split())))
dic  = {}
out = [[] for i in range(n)]
for i in range(len(seqs)):
    if seqs[i] not in dic:
        dic[seqs[i]] = i
    else:
        tmp = []
        # out.append(i)
        if dic[seqs[i]] not in out[dic[seqs[i]]]:
            out[dic[seqs[i]]].append(dic[seqs[i]])
            # out.append(dic[seqs[i]])


        out[dic[seqs[i]]].append(i)
if out == [[] for i in range(n)]:
    print('no')
else:

    for line in out:
        if line !=[]:
            print(' '.join([str(x) for x in line]))