特征提取

C++

//哈希表
#include<iostream>
#include<unordered_map>

using namespace std;

struct Vector {
    int x;
    int y;

    Vector(int x, int y = 0) : x(x), y(y) {}
    Vector() = default;

    bool operator==(const Vector& other) const {
         return x == other.x && y == other.y;
    }
};

struct hash_func {
    size_t operator() (Vector v) const {
        return size_t(v.x + v.y);
    }
};

int main() {
    int T;
    cin >> T;
    while (T--) {
        int m, n;
        cin >> m;
        int maxCount = 0;
        unordered_map<Vector, int, hash_func> hash, prehash;
        while (m--) {
            cin >> n;
            for (int i = 0; i < n; ++i) {
                int x, y;
                cin >> x >> y;
                Vector v(x, y);
                if (prehash.find(v) != prehash.end()) {
                    hash[v] = prehash[v] + 1;
                } else {
                    hash[v] = 1;
                }
                maxCount = max(maxCount, hash[v]);
            }
            prehash = hash;
            hash.clear();
        }
        cout << maxCount << endl;
    }
    return 0;
}

貌似没啥好说的额，用一个字典记录上一帧最大连续特征就行

n = int(input())

while n > 0:
    m = int(input())
    res = 1
    d = {}
    for i in range(m):
        l = list(map(int , input().split()))
        k = l[0]
        tmp_d = {}
        for j in range(k):
            index = l[2 * j + 1] * 1000000000 + l[2 * j + 2]
            if index in d:
                tmp_d[index] = d[index] + 1
                res = max(res, tmp_d[index])
            else:
                tmp_d[index] = 1
        d = tmp_d
    print(res)
    n -= 1

/*深度优先遍历的思想DFS
每一帧的特征只和下一层的相同特征相连*/
#include 
(849)#include 
#include 
(849)#include 
#include 
(849)#include 
using namespace std;
int N,M;
int maxn = 10001;
struct feature{
    int x;
    int y;
};
int max_features=1, cur_max_frame=0;
void DFS(feature f, int cur_frame, vector video[], int ans){
    if(cur_frame>cur_max_frame)
        cur_max_frame = cur_frame;
    if(cur_frame>M-1)
        return;
    for(int i=0;i<video[cur_frame].size();i++){
        feature tmp = video[cur_frame][i];
        if(f.x==tmp.x && f.y==tmp.y){
            if(ans+1>max_features){
                max_features = ans+1;
            }
            DFS(tmp, cur_frame+1, video, ans+1);
        }
    }
}
int main()
{
    scanf("%d", &N);
    while(N>0){
        N--;
        max_features=1, cur_max_frame=0;
        scanf("%d", &M);
        vector video[M];
        for(int i=0;i<M;i++){
            int feature_num;
            scanf("%d", &feature_num);
            for(int j=0;j<feature_num;j++){
                feature f;
                scanf("%d %d",&f.x, &f.y);
                video[i].push_back(f);
            }
        }
        int cur = 0;
        while(cur<M-1){
            if(video[cur].size()==0){
                cur++;
                continue;
            }
            for(int i=0;i<video[cur].size();i++){
                feature f = video[cur][i];
                DFS(f, cur+1, video, 1);
            }
            cur = cur_max_frame;
        }
        printf("%d\n", max_features);
    }
    return 0;
}

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.*;
public class Main
{
    public static void main(String [] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        for(int p=0;p<n;p++) {
            Map <point,Integer> map=new HashMap<>();//map存放（特征值，连续次数）
            int m=in.nextInt();
            int max=0;
            for(int q=0;q<m;q++) {
                int z=in.nextInt();
                ArrayList <point> list=new ArrayList<>();//list存放本行有哪些特征值
                for(int i=0;i<z;i++) {
                    int x=in.nextInt();
                    int y=in.nextInt();
                    point po=new point(x,y);                      for(point poo:map.keySet()) {
                        if(poo.x==x&&poo.y==y) {
                            po=poo;
                            map.put(po, map.get(po)+1);
                            max=Math.max(map.get(po),max);
                            break;
                        }
                    }
                    if(!map.containsKey(po)) {
                        map.put(po,1);
                        max=Math.max(map.get(po),max);
                    }
                    list.add(po);
                }
                for(point poo:map.keySet()) {//对于本行没有出现过的特征值，map对应的键值清零

                    if(!list.contains(poo)) {
                        map.put(poo,0);
                    }
                }
            }
            System.out.println(max);
        }
    }
}
class point {
    int x=0;
    int y=0;
    point(int a,int b) {
        x=a;
        y=b;
    }
}

# 看不懂题目的测试用例和题目的具体用意，感觉这个题目有问题，求大佬解答
N = int(input()) # 测试用例的个数
M = int(input()) # 视频的帧数
frame = []
for i in range(M):
    frame.append(list(map(int, input().split(' '))))

maxFrame = []
cnty = 0
numy = []
for i in range(M):
    if frame[i][0] == 0:
        continue
    else:
        cntx = 0
        numx = frame[i][1]
        for j in range(2, len(frame[i])):
            # 若该帧下一个数与上一个数相等，且不为零，那么就加1，否则进行下一轮判断
            if numx == frame[i][j] and frame[i][j] != 0:
                cntx += 1
                numx = frame[i][j]
            else:
                numx = frame[i][j]
        # 每一帧的计算的特征数
        maxFrame.append(cntx)
        numx = frame[i][1]
        # 记录每帧的连续点，不重复
        for j in range(2, len(frame[i])):
            if numx == frame[i][j]:
                numy.append((numx, frame[i][j]))
                break
            else:
                numx = frame[i][j]
# 计算连续的帧中连续出现的次数
tlp = numy[0]
for t in numy:
    if tlp == t:
        cnty += 1
    else:
        cnty = 0
    maxFrame.append(cnty)
print(max(maxFrame))

cases = int(input())

for j in range(cases):

    num_frames = int(input())

    count_dict = {}
    max_count = 0

    for f in range(num_frames):  # 对于每一帧
        line = list(map(int, input().split()))
        num_features = line[0]
        features = []
        for i in range(1, num_features * 2, 2):  # 对于一帧中的每个feature
            feature = (line[i], line[i+1])
            features.append(feature)
            if feature in count_dict.keys():
                count_dict[feature] += 1
            else:
                count_dict[feature] = 1
        for key in count_dict.keys():  # 如果该帧中没有某个特征，则这个特征从0开始记数
            if key not in features:
                count_dict[key] = 0
        max_count = max(max_count, max(count_dict.values()))  # 记录最大数

    print(max_count)

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

int main(){
    int n,m,k,Max=1,x,y;
    cin>>n;
    while(n--){
        cin>>m;
        map<pair<int,int>, int> M, T;
        for(int i=1;i<=m;i++){
            cin>>k;
            for(int j=0;j<k;j++){
                pair<int,int> p;
                cin>>p.first>>p.second;
                if(M.find(p)==M.end())    
                    T[p] = 1;
                else{
                    if(M[p]==i-1){
                        T[p]++;
                        Max = max(Max, T[p]);
                    }else
                        T[p] = 1;
                }
                M[p] = i;
            }
        }
        cout<<Max<<endl;
    }
    return 0;
}

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

int main(){
    int N;                                         //测试用例
    cin >> N;
    for(int i = 0; i < N; ++i){
        //第 i 个测试数据
        int M;
        cin >> M;                                  //视频帧数
        map<pair<int,int>,int> charact;            //保存到达第 j 帧时，每个特征的最大连续出现次数
        int ans = 0;                               //第 i 个测试数据中，所有特征中最大连续出现次数
        for(int j = 0; j < M; ++j){
            //判断第 i 个测试数据的第 j 帧
            int ln;
            cin >> ln;                             //每一帧的特征数量
            int flameJ = 0;                        //到达第 j 帧时出现的最大连续特征数量
            map<pair<int,int>,int> temp;           //保存中间结果
            for(int k = 0; k < ln; ++k){
                //第 i 个测试数据的第 j 帧的第 k 个特征
                int x,y;
                cin >> x >> y;
                //如果上一帧中有 {x,y} 特征，长度加 1 并保存到 temp 中
                if(charact.count({x,y})){
                    temp[{x,y}] = charact[{x,y}] + 1;
                    flameJ = max(flameJ,charact[{x,y}] + 1);
                }
                //如果没有该帧，那么长度肯定为 1，并保存到 temp 中
                else{
                    temp[{x,y}] = 1;
                    flameJ = max(flameJ,1);
                }
            }
            ans = max(ans,flameJ);              //保存到第 j 帧为止的已知的最长连续特征数量
            charact = temp;                     //更新第 j 帧的状态
        }
        cout << ans << '\n';
    }
    return 0;
}