题解 | 特征提取

#include <iostream>
#include <map>
#include <utility>

using namespace std;

int main() {
    int testCases, frames;
    cin >> testCases;

    while (testCases--) {
        cin >> frames;
        int featureCount, x, y;

        map<pair<int, int>, int> previous; // 存储历史帧数
        map<pair<int, int>, int> current;  // 存储当前帧数

        int maxLength = 0; // 记录最长特征运动的长度

        for (int i = 0; i < frames; i++) {
            cin >> featureCount;

            for (int j = 0; j < featureCount; j++) {
                cin >> x >> y;

                // 更新当前特征的出现次数
                if (previous.count({x, y})) {
                    current[{x, y}] = previous[{x, y}] + 1; // 增加出现次数
                } else {
                    current[{x, y}] = 1; // 新特征，初始化为1
                }

                // 更新最大连续出现次数
                if (current[{x, y}] > maxLength) {
                    maxLength = current[{x, y}];
                }
            }

            // 清空当前帧的历史信息
            previous.clear();
            previous.swap(current); // 将当前帧信息转为历史帧信息
        }

        cout << maxLength << endl; // 输出结果
    }

    return 0;
}

import java.util.*;

public class Main {
    // 自定义Pair类
    static class Pair<K, V> {
        K key;
        V value;

        Pair(K key, V value) {
            this.key = key;
            this.value = value;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof Pair)) return false;
            Pair<?, ?> pair = (Pair<?, ?>) o;
            return Objects.equals(key, pair.key) && Objects.equals(value, pair.value);
        }

        @Override
        public int hashCode() {
            return Objects.hash(key, value);
        }
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int testCases = sc.nextInt();

        while (testCases-- > 0) {
            int frames = sc.nextInt();
            Map<Pair<Integer, Integer>, Integer> previous = new HashMap<>();
            Map<Pair<Integer, Integer>, Integer> current = new HashMap<>();
            int maxLength = 0;

            for (int i = 0; i < frames; i++) {
                int featureCount = sc.nextInt();
                for (int j = 0; j < featureCount; j++) {
                    int x = sc.nextInt();
                    int y = sc.nextInt();
                    Pair<Integer, Integer> feature = new Pair<>(x, y);

                    current.put(feature, previous.getOrDefault(feature, 0) + 1);
                    maxLength = Math.max(maxLength, current.get(feature));
                }
                previous.clear();
                previous.putAll(current);
                current.clear();
            }
            System.out.println(maxLength);
        }
        sc.close();
    }
}

class Pair:
    def __init__(self, key, value):
        self.key = key
        self.value = value
    
    def __eq__(self, other):
        if not isinstance(other, Pair):
            return False
        return self.key == other.key and self.value == other.value
    
    def __hash__(self):
        return hash((self.key, self.value))

def solve_feature_motion():
    test_cases = int(input())
    
    for _ in range(test_cases):
        frames = int(input())
        previous = {}  # 存储历史帧的特征计数
        current = {}   # 存储当前帧的特征计数
        max_length = 0
        
        for i in range(frames):
            frame_data = list(map(int, input().split()))
            feature_count = frame_data[0]
            
            # 处理当前帧的每个特征
            for j in range(feature_count):
                x = frame_data[2*j + 1]
                y = frame_data[2*j + 2]
                feature = Pair(x, y)
                
                # 更新特征的连续出现次数
                current[feature] = previous.get(feature, 0) + 1
                max_length = max(max_length, current[feature])
            
            # 更新历史帧信息
            previous.clear()
            previous.update(current)
            current.clear()
        
        print(max_length)

if __name__ == "__main__":
    solve_feature_motion()