特征提取

import java.util.HashMap;
import java.util.Scanner;

//把vector拼成一个字符串，当作哈希的key存放，对应的value存放该特征的连续长度count和上一次出现的视频帧lastFrame
public class Main {

    static class Stat{
        int lastFrame = 0;
        int count = 0;
        public Stat(int lastFrame, int count){
            this.lastFrame = lastFrame;
            this.count = count;
        }
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int cntUsage = in.nextInt();
        int cntFrame = 0;
        int cntStat = 0;
        int res = 1;
        HashMap<String,Stat> map = new HashMap<>();
        // 注意 hasNext 和 hasNextLine 的区别
        int iUsage = 0;
        while (iUsage < cntUsage) {
            int iFrame = 0;
            cntFrame = in.nextInt();
            while (iFrame < cntFrame) {
                int iStat = 0;
                cntStat = in.nextInt();
                while (iStat < cntStat) {
                    int a = in.nextInt();
                    int b = in.nextInt();
                    String str = a + "," + b;
                    if (!map.containsKey(str)){
                        map.put(str,new Stat(iFrame,1));
                    }else{
                        Stat stat = map.get(str);
                        if (iFrame - stat.lastFrame == 1){ //连续特征累加count
                            stat.count++;
                            if (stat.count > res){ //找最大特征长度
                                res = stat.count;
                            }
                        }else{
                            stat.count = 1;
                        }
                        stat.lastFrame = iFrame;
                    }
                    iStat++;
                }
                iFrame++;
            }
            iUsage++;
        }
        System.out.println(res);
    }
}

自定义一个Point用来存放点，然后将point存放在map中，每次都进行更新。每一帧都新建一个map，若上一帧中存在该点，则将该点对应的值+1，并存放在map中，判断是否为新的最大。若上一帧不存在该点，则存放入map中，value为1

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        HashMap<Point,Integer> points = new HashMap<Point,Integer>();
        for(int i = 0; i < n; i ++){
            int m = sc.nextInt();
            int res = 0;
            for(int j = 0; j < m; j ++){
                int p = sc.nextInt();
                HashMap<Point,Integer> tempPoints = new HashMap<Point,Integer>();
                for (int k = 0; k < p; k ++){
                    int x = sc.nextInt();
                    int y = sc.nextInt();
                    Point temp = new Point(x,y);
                    Integer num = points.get(temp);
                    if (num == null){
                        num = new Integer(1);
                    } else{
                        num += 1;
                    }
                    res = num > res ? num : res;
                    tempPoints.put(temp,num); 
                }
                points.clear();
                points = tempPoints;
            }
            System.out.print(res);
        }
   }
}

class Point{
    int x;
    int y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public Point() {
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Point point = (Point) o;
        return x == point.x &&
                y == point.y;
    }

    @Override
    public int hashCode() {
        return Objects.hash(x, y);
    }
}

import java.util.HashMap;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        while (N-- > 0){
            HashMap<String, Integer> mem = new HashMap<>();
            HashMap<String, Integer> temp_mem = new HashMap<>();
            int M = sc.nextInt();
            int max = 1;
            for(int j = 0; j < M; ++j){
                temp_mem.clear();
                int n = sc.nextInt();
                for(int k = 0; k < n; ++k){
                    String key = sc.nextInt() + " " + sc.nextInt();
                    temp_mem.put(key, mem.getOrDefault(key, 0) + 1);
                    max = Math.max(temp_mem.get(key), max);
                }
                mem.clear();
                mem.putAll(temp_mem);
            }
            System.out.println(max);
        }
    }
}

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int n = scanner.nextInt();
		int ans = 0;
		Map<Reference, Integer> map1 = new HashMap<Reference, Integer>();
		Map<Reference, Integer> map2 = new HashMap<Reference, Integer>();
		for(int i=0;i<n;i++) {
			int m = scanner.nextInt();
			map1.clear();
			for(int j=0;j<m;j++) {
				 int p = scanner.nextInt();
				 if(p==0) {
					 map1.clear();
					 continue;
				 }
				 for(int k=0;k<p;k++) {
					 int x = scanner.nextInt();
					 int y = scanner.nextInt();
					 Reference reference = new Reference(x, y);
					 if(map1.containsKey(reference)) {
						 map2.put(reference, map1.get(reference)+1);
					 }else {
						 map2.put(reference, 1);
					 }
					 ans = Math.max(ans, map2.get(reference));
				 }
				 map1.clear();
				 map1.putAll(map2);
				 map2.clear();
			}
		}
		System.out.println(ans);
	}
	
	
	
	
}
class Reference{
	int x;
	int y;
	public Reference(int x, int y) {
		super();
		this.x = x;
		this.y = y;
	}
	@Override
	public int hashCode() {
		return  x + y + x*y;
	}
	@Override
	public boolean equals(Object obj) {
		Reference reference = (Reference)obj;
		return x==reference.x && y==reference.y;
	}
	
}

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int N = input.nextInt();
        int[] M = new int[N];
        int[][] num = new int[N][];
        int[][][][] feats= new int[N][][][];
        for(int i = 0; i < N; i++) {
            M[i] = input.nextInt();
            num[i] = new int[M[i]];
            feats[i] = new int[M[i]][][]; 
        	for(int j = 0; j < M[i]; j++) {
        		num[i][j] = input.nextInt();
        		feats[i][j] = new int[num[i][j]][];
        		for(int k = 0; k < num[i][j]; k++) {
        			feats[i][j][k] = new int[2];
        			feats[i][j][k][0] = input.nextInt();
        			feats[i][j][k][1] = input.nextInt();
        		}
        	}
        }
        input.close();
        for(int i = 0; i < N; i++)
        	System.out.println(Solution(M[i], num[i], feats[i]));
    }
    public static int Solution(int M, int[] num, int[][][] feats) {
		int max = 1;
		if(M == 1)
			return max;
		for(int i = 0; i < M-1; i++) {
			for(int j = 0; j < num[i]; j ++) {
				if(feats[i][j] != null) {
					int sum = 1;
					for(int x = i + 1; x < M; x++) {
						for(int y = 0; y < num[x]; y++) {
							if(Equals(feats[x][y], feats[i][j])) {
								sum ++;
								feats[x][y] = null;
								break;
							}
						}if(sum != x-i+1 || x == M-1) {
							max = (max < sum) ? sum : max;
							break;
						}
					}
				}
			}
		}
    	return max;    	
    }
    public static boolean Equals(int[] a, int[] b){
        if(a == null || b == null)
            return false;
        if(a[0] == b[0] && a[1] == b[1])
           return true;
        else
            return false;
    }
}