首页 > 试题广场 > 特征提取
[编程题]特征提取
  • 热度指数:2412 时间限制:C/C++ 1秒,其他语言2秒 空间限制:C/C++ 32M,其他语言64M
  • 算法知识视频讲解
       小明是一名算法工程师,同时也是一名铲屎官。某天,他突发奇想,想从猫咪的视频里挖掘一些猫咪的运动信息。为了提取运动信息,他需要从视频的每一帧提取“猫咪特征”。一个猫咪特征是一个两维的vector<x, y>。如果x_1=x_2 and y_1=y_2,那么这俩是同一个特征。
       因此,如果喵咪特征连续一致,可以认为喵咪在运动。也就是说,如果特征<a, b>在持续帧里出现,那么它将构成特征运动。比如,特征<a, b>在第2/3/4/7/8帧出现,那么该特征将形成两个特征运动2-3-4 和7-8。
现在,给定每一帧的特征,特征的数量可能不一样。小明期望能找到最长的特征运动。

输入描述:
第一行包含一个正整数N,代表测试用例的个数。

每个测试用例的第一行包含一个正整数M,代表视频的帧数。

接下来的M行,每行代表一帧。其中,第一个数字是该帧的特征个数,接下来的数字是在特征的取值;比如样例输入第三行里,2代表该帧有两个猫咪特征,<1,1>和<2,2>
所有用例的输入特征总数和<100000

N满足1≤N≤100000,M满足1≤M≤10000,一帧的特征个数满足 ≤ 10000。
特征取值均为非负整数。


输出描述:
对每一个测试用例,输出特征运动的长度作为一行
示例1

输入

1
8
2 1 1 2 2
2 1 1 1 4
2 1 1 2 2
2 2 2 1 4
0
0
1 1 1
1 1 1

输出

3

说明

特征<1,1>在连续的帧中连续出现3次,相比其他特征连续出现的次数大,所以输出3

备注:
如没有长度大于2的特征运动,返回1
我想知道有什么方法能让一个数组中的数的组合成为map的键值。做题的时候没想到,只能把数组转换程字符串作为map的键值了。很难受
import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        for(int i = 0; i < N; ++i){
            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){
                    int x = sc.nextInt();
                    int y = sc.nextInt();
                    String key = String.valueOf(x) + " " + String.valueOf(y);
                    temp_mem.put(key, mem.getOrDefault(key, 0) + 1);
                    max = Math.max(temp_mem.get(key), max);
                }
                mem.clear();
                mem.putAll(temp_mem);
            }
            if(max <= 1){
                System.out.println(1);
            }else{
                System.out.println(max);
            }
        }

    }
}




发表于 2019-08-09 21:45:28 回复(7)
用Map做,省事很多!!!

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

int main()
{
    int n, m;
    cin >> n;

    int len;
    pair<int, int> xy;

    while (n--)
    {
        cin >> m;

        int maxCnt = 0;
        map<pair<int, int>, int> preFeaTimes;
        map<pair<int, int>, int> feaTimes;
        while (m--)
        {
            cin >> len;
            for (int i = 0; i < len; i++)
            {
                cin >> xy.first >> xy.second;
                
                if (preFeaTimes.count(xy))
                    feaTimes[xy] = preFeaTimes[xy] + 1;
                else
                    feaTimes[xy] = 1;

                if (feaTimes[xy] > maxCnt)
                    maxCnt = feaTimes[xy];
            }
            preFeaTimes.clear();
            preFeaTimes.swap(feaTimes);
        }
        cout << maxCnt << endl;
    }

    return 0;
}




发表于 2019-08-29 11:21:57 回复(0)
基本的想法是这样的,比如案例数据:
1
8
2 1 1 2 2
2 1 1 1 4
2 1 1 2 2
2 2 2 1 4
0
0
1 1 1
1 1 1
使用map记录动作上一次出现的帧数和当前连续帧数,同时记录下当前连续的最长帧数res。
第一组数:(1,1)-> (0,1)    ,    (2,2) -> (0,1)      res = 1;
即代表(1,1)上次出现在0时刻,当前连续动作为1;(2,2)上次出现在0时刻,当前连续动作为1
第二组数:(1,1)-> (1,2)    ,    (1,4) -> (1,1)      res = 2;
即代表(1,1)上次出现在1时刻,当前连续动作为2;(1,4)上次出现在1时刻,当前连续动作为1
第三组数:(1,1)-> (2,3)    ,    (2,2) -> (2,1)      res = 3;
即代表(1,1)上次出现在2时刻,当前连续动作为3;(2,2)上次出现在2时刻,当前连续动作为1
第四组数:(2,2)-> (3,2)    ,    (1,4) -> (3,1)      res = 3;

代码如下:(实际上需要写个while(N--),但是好像测试用例都是1组,就懒得改了)
#include<iostream>
#include<map>
#include<algorithm>
using namespace std;

int main() {
    int N; cin >> N; //测试用例数
    int M; cin >> M; //帧数
    map<pair<int, int>, pair<int, int> > record;

    int amounts, x, y;
    int res = 1;
    for (int i = 0; i < M; i++) {//每一组测试用例
        cin >> amounts;
        for (int j = 0; j < amounts; j++) { //每一组特征
            cin >> x >> y;
            if (record.find(make_pair(x, y)) == record.end()) {
                record.insert(make_pair(make_pair(x, y), make_pair(i, 1)));
            }
            else {
                auto iter = record.find(make_pair(x, y));
                if (i - iter->second.first == 1) {//连续出现
                    iter->second.first = i; iter->second.second += 1;
                    res = max(res, iter->second.second);
                }
                else { //没有连续出现
                    iter->second.first = i;
                    iter->second.second = 1;
                }
            }
        }
    }
    cout << res << endl;
    return 0;
}



编辑于 2019-08-08 09:43:24 回复(0)
两个map轻松解决,一个用来保存当前帧的特征,一个用来保存上一帧的特征。用hashmap比treemap更合理,但是C++ 的hashmap不能接受pair作为key 转化成string即可
#include<bits/stdc++.h>
using namespace std;
unordered_map<string, int> last;
unordered_map<string, int> cur;

string make_str(int x, int y) {
	return to_string((long long)x) + to_string((long long)y);
}

int N, M;
int main() {
    scanf("%d", &N);
    while(N--) {
        scanf("%d", &M);
        int res = 1;
        while(M--) {
            int cnt; scanf("%d", &cnt);
            cur.clear();
            while(cnt--) {
                int x, y; scanf("%d%d", &x, &y);
                if(last.count(make_str(x, y))) {
                    cur[make_str(x, y)] += (last[make_str(x, y)] + 1);
                    res = max(res, cur[make_str(x, y)]);
                } else {
                    cur[make_str(x, y)]++;
                }
            }
            last = cur;
        }
        last.clear();
        printf("%d\n", res);
    }
}
/*
1
8
2 1 1 2 2
2 1 1 1 4
2 1 1 2 2
2 2 2 1 4
0
0
1 1 1
1 1 1
res: 3
*/


发表于 2019-12-28 10:27:17 回复(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;
	}
	
}

发表于 2019-10-30 16:26:50 回复(0)
#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;
}

发表于 2019-09-17 07:55:04 回复(0)
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;
    }
}

发表于 2019-09-16 11:37:42 回复(0)
# 看不懂题目的测试用例和题目的具体用意,感觉这个题目有问题,求大佬解答
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))

发表于 2019-08-28 15:01:41 回复(0)
从头到尾遍历
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        for (int i=0;i<n;i++){
            int m = in.nextInt();
            Pair[][] pairs = new Pair[m][];
            for (int j=0;j<m;j++){
                int t = in.nextInt();
                pairs[j] = new Pair[t];
                for (int k=0;k<t;k++){
                    pairs[j][k] = new Pair(in.nextInt(),in.nextInt());
                }
            }
            int max = Integer.MIN_VALUE;
            for (int j=0;j<m;j++){          //遍历每一帧
                for (int k=0;k<pairs[j].length;k++){         //遍历每一特征
                    if (pairs[j][k] != null){         //如果特征不为null
                        int c = 1;          //特征初始次数为1
                        int temp = c;
                        for (int t=j+1;t<m;t++){         //遍历当前帧以下的所有帧
                            for (int s = 0;s<pairs[t].length;s++){      //遍历每一特征
                                if (pairs[t][s] != null && pairs[j][k].first == pairs[t][s].first
                                        && pairs[j][k].second == pairs[t][s].second){     //若特征不为null,且相等
                                    pairs[t][s] = null;         //将其标志为null,防止后序重复遍历
                                    c++;      //特帧数加1
                                }
                            }
                            if (temp == c){    //遍历一个帧后,特征数不变,说明其已不连续了,此时退出
                                break;
                            }else {
                                temp = c;
                            }
                        }//还有一种退出情况,即循环到尾部,自动退出了
                        if (c > max)
                            max = c;    //记录最大特帧数
                    }
                }
            }
            System.out.println(max);
        }
    }

    private static class Pair{
        int first;
        int second;
        Pair(int first,int second){
            this.first = first;
            this.second = second;
        }
    }
}


编辑于 2019-08-18 16:04:57 回复(0)
#把特征出现的帧记录在字典中,并取最长连续帧
n =int(input())
for i in range(n):
    m =int(input())
    #保存不同的帧出现的像素
    num =0
    index =0
    #保存不同特征出现的位置
    dic ={}
    while index < m:
        line =[int(x) forx in input().strip().split()]
        num_pixel =line[0]
        num +=num_pixel
        p =[]
        for j in range(num_pixel):
            term =(line[2*j+1],line[2*j+2])
            if term not in dic:
                dic[term] =[]
                dic[term].append(index)
            else:
                dic[term].append(index)
        index +=1
    #最大连续序列
    max1 =0#全局最大长度
    for key indic:
        sequence =dic[key]
        max2 =1#至少有一个
        s =0
        while s +1< len(sequence):
            if sequence[s+1] ==sequence[s] +1:
                max2 +=1
            else:
                #连续断了,新断归0
                max2 =1
            if max2 > max1:
                max1 =max2
            s +=1
        if max2 > max1:
            max1 =max2
    print(max1)

发表于 2019-08-11 11:01:34 回复(0)
#include<iostream>
#include<vector>
#include<map>
#include<set>
using namespace std;

int main(){
    int N; cin>>N;
    for(int i=0; i<N; i++){
        int M; cin>>M;
        
        int ans = 0;
        map<pair<int,int>, int> pairMap;
        
        vector<set<pair<int,int>>> nums(M);
        for(int i=0; i<M; i++){
            set<pair<int,int>> one;
            int len; cin>>len;
            int x, y;
            for(int j=0; j<len; j++){
                cin>>x>>y; one.insert(make_pair(x,y));
                if(i-1>=0 && nums[i-1].find(make_pair(x,y))!=nums[i-1].end()){
                    pairMap[make_pair(x,y)]++;
                }else{
                    pairMap[make_pair(x,y)] = 1;
                }
                ans = max(ans, pairMap[make_pair(x,y)]);
            }
            nums[i] = one;
        }
        cout<<ans<<endl;
    }
    return 0;
}

发表于 2019-07-07 18:30:34 回复(1)

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

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
发表于 2019-05-28 20:45:48 回复(0)

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

public class Main{

    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
//        Vec vec1 = new Vec(1, 1);
//        Vec vec2 = new Vec(1, 1);
//        Map<Vec, Integer> map1 = new HashMap<>();
//        map1.put(vec1, 1);
//        System.out.println(map1.containsKey(vec2));
        
        int usercase = in.nextInt();
       
        for(int i=0;i<usercase;i++){
            int re=0;
            Map<Vec, Vec> map = new HashMap<>();
            int frame = in.nextInt();
            for(int j=0;j<frame;j++){
                int vectors = in.nextInt();
                for(int k=0;k<vectors;k++){
                    int x=in.nextInt();
                    int y=in.nextInt();
                    Vec vec = new Vec(x, y);
                    int value=0;
                    if(map.containsKey(vec) && map.get(vec).getY()==(j-1)){
                        value= map.get(vec).getX()+1;                        
                    }else{
                        value=1;
                    }
                    map.put(vec, new Vec(value, j));
                    if(value>re)
                        re=value;
                }
            }
            System.out.println(re);
            
            
        }
    }
    

}
class Vec{
    int x;
    int y;
    public Vec(int a,int b){
        x=a;
        y=b;
    }
    
    public int getX(){
        return x;
    }
    public int getY(){
        return y;
    }

    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        Vec bVec= (Vec)obj;
        if(bVec.getX()==x && bVec.getY()==y)
          return true;
        return false;
    }
    
    @Override
    public int hashCode() {
        // TODO Auto-generated method stub
        return new Integer(x).hashCode() & new Integer(y).hashCode();
    }
}    

发表于 2019-12-29 16:13:55 回复(0)
#include <bits/stdc++.h>
using namespace std;

pair<int, int> split(string s)
{
    int n = s.size();
    for(int i =0; i<n; i++)
    {
        if(s[i]=='#')
            return make_pair(stoi(s.substr(0,i)), stoi(s.substr(i+1)));
    }
    return {0, 0};
}

int main()
{
    int N;
    cin>>N;
    while(N--)
    {
        int M;
        cin>>M;
        unordered_map<string, int> map;
        int ans = 0;
        for(int i=0; i<M; i++)
        {
            int K;
            cin>>K;
            set<pair<int, int>> S;
            for(int j=0; j<K; j++)
            {
                int a, b;
                cin>>a>>b;
                S.insert(make_pair(a,b));
            }
            unordered_map<string, int>::iterator it = map.begin();
            for(; it!=map.end(); it++)
            {
                pair<int, int> t = split(it->first);
                if(S.find(t)==S.end()) it->second = 0;
                else 
                {
                    (it->second)++;
                    ans = max(ans, it->second);
                }
            }
            for(auto p: S)
            {
                string index = to_string(p.first)+"#"+to_string(p.second);
                if(map.find(index)==map.end()) map[index] = 1, ans = max(ans, 1);
            }
        }
        cout<<ans<<endl;
    }
    return 0;
}

发表于 2019-12-27 17:42:06 回复(0)
import sys
input = []
for line in sys.stdin:
    input.append(line.strip().split())
counter = {}
last = []
for data in input[2:]:
    tmp = []
    for i in range(1, len(data)-1, 2):
        feature = tuple(data[i:i+2])
        counter.setdefault(feature, [])
        if feature in last:
            counter[feature][-1] += 1
        else:
            counter[feature].append(1)
        tmp.append(feature)
    last = tmp
     
 
print(max([max(v)for k, v in counter.items()]))
所以说python大法好啊
发表于 2019-09-22 10:39:56 回复(0)
#include <iostream>
#include <map>
#include <utility>
#include <vector>

using namespace std;

int cal_move(vector<vector<pair<int,int>>> &features)
{
    int num_of_line = features.size();
    map<pair<int,int>,int> current;
    int longest=0;
    for(auto p : features){
        map<pair<int, int>, int> comp=current;
        for(auto ip : p){
            comp[ip]++;
        }
        for(auto ep : current){
            if(ep.second==comp[ep.first]){
                comp.erase(ep.first);
            }
        }
        current = comp;
        for(auto ap : current){
            if(ap.second > longest) longest = ap.second;
        }
    }
    return longest;
}

int main()
{
    //cout << "Hello World!" << endl;
    int num_of_tests;
    cin>>num_of_tests;
    for(int i = 0; i < num_of_tests; ++i){
        int num_of_frames;
        cin>>num_of_frames;
        vector<vector<pair<int,int>>> features;
        for(int j = 0; j < num_of_frames; ++j){
            int num_of_feature;
            cin>>num_of_feature;
            vector<pair<int,int>> feature;
            for(int k = 0; k < num_of_feature;  ++k){
                int first,second;
                cin>>first>>second;
                feature.push_back(make_pair(first,second));
            }
            features.push_back(feature);
        }
        int longest = cal_move(features);
        cout<<longest<<endl;
    }
    return 0;
}

发表于 2019-09-15 10:27:11 回复(0)
import java.util.*;


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

        for (int i = 0; i < N; i++) {
            //存放每行的list
            List<List<Vector>> listList = new ArrayList<>();
            for (int j = 0; j < M; j++) {
                //每一行有多少个特征对象
                int n = sc.nextInt();
                
                //每行都是一个list,用来存放特征对象
                List<Vector> vectorList = new ArrayList<>();
                for (int k = 0; k < n; k++) {
                    Vector vector = new Vector();
                    vector.x = sc.nextInt();
                    vector.y = sc.nextInt();
                    vectorList.add(vector);
                }

                listList.add(vectorList);

            }

            int max = 0;
            //遍历每行的list
            for (int j = 0; j < M; j++) {
                List<Vector> vectorList = listList.get(j);
                //遍历每一行的list里面的特征对象
                for (Vector vector : vectorList) {
                    //记录该特征连续出现的次数
                    int count = 1;
                    //每一个特征对象都看看下面的行是否包含它
                    for (int l = j + 1; l < M; l++) {
                        if (listList.get(l).contains(vector)) {
                            //下面一行的list包含当前特征对象,说明该特征连续,count++
                            count++;
                        } else {
                            //不再连续,到头了,换下一个特征对象
                            break;
                        }
                    }
                    //找出最大的连续次数
                    if(count>max){
                        max = count;
                    }
                }
            }

            System.out.println(max);
        }

    }
}

//使用一个对象来保存x和y
class Vector {
    int x;
    int y;

    //重写equals方法,如果x_1=x_2 and y_1=y_2,那么这俩是同一个特征,即同一个对象
    public boolean equals(Object o) {
        if (this == o) return true;         if (o == null || getClass() != o.getClass()) return false;         Vector vector = (Vector) o;         return x == vector.x &&                 y == vector.y;     } }

编辑于 2019-09-08 12:44:47 回复(0)
导入Pair出错,只好自己写一个了
大体思路:map用来保存上一帧中的所有特征,sup是当前帧的所有特征,其中key为特征(Pair),value为从此帧向前数,连续出现该特征的帧长度。就是说,对于当前帧中某一特征,如果上一帧中出现同一特征,此特征对应的value等于上一帧中的value+1,如果没有出现,value就为1
import java.util.HashMap;
import java.util.Objects;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner reader = new Scanner(System.in);
        int N = reader.nextInt();
        for (int i = 0; i < N; i++) {
            int M = reader.nextInt();
            int max = Integer.MIN_VALUE;
            HashMap<Pair, Integer> map = new HashMap<>();
            for (int j = 0; j < M; j++) {
                HashMap<Pair, Integer> sup = new HashMap<>();
                int k = reader.nextInt();
                for (int l = 0; l < k; l++) {
                    Pair p = new Pair(reader.nextInt(), reader.nextInt());
                    if (map.containsKey(p)) {
                        sup.put(p, map.get(p) + 1);
                    } else {
                        sup.put(p, 1);
                    }
                    max = Math.max(max, sup.get(p));
                }
                map = sup;
            }
            System.out.println(max);
        }
    }
}

class Pair {
    Integer key;
    Integer value;

    public Pair(Integer key, Integer value) {
        this.key = key;
        this.value = value;
    }

    @Override
    public int hashCode() {
        return key.hashCode() * 13 + (value == null ? 0 : value.hashCode());
    }

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

发表于 2019-09-07 08:48:13 回复(0)
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;
    }
}


编辑于 2019-09-06 12:13:25 回复(0)
#include<iostream>
#include<map>
#include<vector>
#include<string>
using namespace std;

int main()
{
    int i,zhen;
    cin>>i;
    if(i<=0)
        return 0;
    int c=0;
    map<vector<int>,vector<int>> m;
    while(c<i)
    {
        cin>>zhen;
        for(int j=0;j<zhen;++j)
        {
            int temp;
            //temp该帧的特征数,j是第几帧
            cin>>temp;
            for(int k=0;k<temp;k++)
            {
                int t;
                vector<int> v;
                cin>>t;
                v.push_back(t);
                cin>>t;
                v.push_back(t);
                m[v].push_back(j);
            }
        }
        c++;
    }
    int ret=1;
    for(auto it=m.begin();it!=m.end();it++)
    {
        auto temp=it->second;
        int i=0,t=0;
        while(i<temp.size())
        {
            t=1;
            while(i+1<temp.size()&&temp[i]+1==temp[i+1])
            {
                i++;
                t++;
            }
            if(t>ret)
                ret=t;
                
            i++;
            
        }
    }
    cout<<ret<<endl;
	return 0;
}

发表于 2019-08-29 11:25:44 回复(0)