3月27日做了华为笔试，3道题2小时。当时没有拍照，现在凭记忆将题目和代码叙述一遍，方便后人。前面将把三道题分别列一下，供后来者自己做。在后面说明一下自己的写法

第一题：题目说的比较复杂，读懂题意之后大致是，9个字符一组，每组的第一个字符是标志位，后面8个字符是地址。如果标志位是0，地址逆序，标志位是1地址不变。输入说明：一个字符串，有多组字符，中间没有空格。输出说明：输出最后的地址，每组地址用空格隔开，最后一个输出不需要空格。时间：C/C++1秒其他2秒

第二题：简而言之就是TSP问题。蜂巢在坐标（0,0）的位置，有五处花丛，蜜蜂从蜂巢出发，要把五处花丛的花蜜采完再回到蜂巢，最短距离是多少。输入说明：一行输入，10个数分别是五处花丛的坐标（x1,y1,x2,y2,x3,y3,x4,y4,x5,y5），用空格隔开。输出说明：输出最短距离，距离向下取整。时间：C/C++5秒其他10秒

第三题：切水果游戏。有一个40×50的方格，里面有n（1≤n≤36）个水果，每一刀可以横切，竖切以及左斜切与右斜切四种方式。想要切完所有水果，最少需要多少刀。输入说明：第一行是说过个数n，接下来的n行是水果的横纵坐标。输出说明：输出最少需要的刀数。（PS：原题有图，这里无图解释一下切割方式，横切就是所有x相同的水果可以一刀切完，纵切就是y相同，左斜切就是x-y相同，右斜切就是x+y相同）。时间：C/C++3秒其他6秒

下面是各题做法和思路：

第一题：题目说的比较复杂，读懂题意之后大致是，9个字符一组，每组的第一个字符是标志位，后面8个字符是地址。如果标志位是0，地址逆序，标志位是1地址不变。输入说明：一个字符串，有多组字符，中间没有空格。输出说明：输出最后的地址，每组地址用空格隔开，最后一个输出不需要空格。

解答：第一题很简单，9个一组得读取，判断第一个是0还是1即可。5分钟内即可AC。

# -*- coding:utf8 -*-
n = int(input())
strs = input()
for i in range(n):
    s = strs[9*i:9*i+9]  # 9个一组得读取
    if s[0] == '0':
        s = s[1:]
        s = s[::-1]  # 逆序
    else:
        s = s[1:]
    print(s, end=' ')  # 空格输出

第二题：简而言之就是TSP问题。蜂巢在坐标（0,0）的位置，有五处花丛，蜜蜂从蜂巢出发，要把五处花丛的花蜜采完再回到蜂巢，最短距离是多少。输入说明：一行输入，10个数分别是五处花丛的坐标（x1,y1,x2,y2,x3,y3,x4,y4,x5,y5），用空格隔开。输出说明：输出最短距离，距离向下取整。

解答：一开始就想到了全排列之后贪心算法取最小，虽然觉得方法太low了，但是让我一下子写出蚁群之类的觉得记忆模糊就很纠结。后来发现这道题给了10秒的运行时间，妥妥的决定用全排列了。思路：先用全排列的方式获取蜜蜂访问5个花丛的所有可能顺序，之后计算每个路径长度取最小。

# -*- coding:utf8 -*-
from math import sqrt
line = input().strip().split()
n = list(map(int, line))
n = [int(i) for i in line]
nums = [[0,0], [n[0],n[1]], [n[2],n[3]], [n[4],n[5]], [n[6],n[7]], [n[8],n[9]]]
# 以下为插入的方式获取全排列的代码。没看过别人的，自己想到的。
# 后来看网上说，递归获取全排列更常见，有兴趣的可以自己去搜一下。
order = [[1]]
for i in range(2,6):
    lens = len(order)
    j = 0
    while j < lens:
        for k in range(i-1):
            tmp = order[j][:]  #
            order.append(tmp)
            order[-1].insert(k, i)
        order[j].append(i)
        j += 1
# 接下来是制作距离矩阵
dist = [[0] * 6 for i in range(6)]
for i in range(6):
    for j in range(6):
        if dist[i][j] == 0:
            dist[i][j] = sqrt((nums[i][0]-nums[j][0])**2 + (nums[i][1]-nums[j][1])**2)
        else:
            dist[i][j] = dist[j][i]
# 贪心算法取最小
minVal = 0
for path in order:
    sums = dist[0][path[0]]
    for i in range(4):
        sums += dist[path[i]][path[i+1]]
    sums += dist[path[4]][0]
    if minVal > sums or minVal == 0:
        minVal = sums
print(int(minVal))

第三题：切水果游戏。有一个40×50的方格，里面有n（1≤n≤36）个水果，每一刀可以横切，竖切以及左斜切与右斜切四种方式。想要切完所有水果，最少需要多少刀。输入说明：第一行是说过个数n，接下来的n行是水果的横纵坐标。输出说明：输出最少需要的刀数。（PS：原题有图，这里无图解释一下切割方式，横切就是所有x相同的水果可以一刀切完，纵切就是y相同，左斜切就是x-y相同，右斜切就是x+y相同）。时间：C/C++3秒其他6秒。

解答：当时用的贪心算法，只通过了70%，后来想到了动态规划算法，虽然没试过但是个人感觉应该可以AC。和LeetCode零钱兑换问题差不多的思路。评论中有人说时间复杂度很高。的确时间复杂度是4的n次方。我尝试了一下，n=15应该没问题，超过15时间就比较久了。期待有大佬给出更好的答案。

# -*- coding:utf8 -*-
# 40 * 50的方格
from random import randint
# 动态规划算法。对于一个点，四种切法去除被切除的点即可获得下一次的点集。加上1即可
def dp(points):
    if len(points) <= 1:
        return len(points)
    first = points[0]
    row = [i for i in points if i[0] != first[0]]
    cntRow = dp(row)
    col = [i for i in points if i[1] != first[1]]
    cntCol = dp(col)
    left = [i for i in points if i[2] != first[2]]
    cntLeft = dp(left)
    right = [i for i in points if i[3] != first[3]]
    cntRight = dp(right)
    return 1 + min(cntRow, cntCol, cntLeft, cntRight)


# 贪心算法。假设只能选择一种方式切，选择刀数最少的
def greedyOne(points):
    x = [i[0] for i in points]
    y = [i[1] for i in points]
    l = [i[2] for i in points]
    r = [i[3] for i in points]
    return min(len(set(x)), len(set(y)), len(set(l)), len(set(r)))


n = int(input())
points = []
for i in range(n):
    line = input().strip().split()
    x = int(line[0])
    y = int(line[1])
    l = y - x
    r = x + y
    points.append([x, y, l, r])
'''
# 此部分为随机获取点值，确定自己的动态规划算法是否最优
n = 15
for i in range(10):
    points = []
    for j in range(n):
        x = randint(0,40)
        y = randint(0,50)
        l = y - x
        r = x + y
        points.append([x, y, l, r])
    res1 = dp(points)
    res2 = greedyOne(points)
    print('dp is %d, greedy is %d'%(res1, res2))
    if res1 > res2:
        print(points)
'''

 

1.Java笔试面试-字符串
2.Java笔试面试-玩转时间
3.Java笔试面试-数组
4.Java笔试面试-异常处理
5.Java笔试面试-类与Object
6.Java笔试面试-内部类
内部类相关笔试面试题
7.Java笔试面试-抽象类与接口
8.Java笔试面试-克隆和序列化
9.集合（上）
集合（下）
10.泛型和迭代器
11.数据结构队列
12.BIO、NIO、AIO
13.反射和动态代理
14.线程和死锁
15.线程池（ThreadPoolExecutor）
16.Executors
17.ThreadLocal
18.线程安全（synchronized 和 ReentrantLock）
19.Java并发包中的高级同步工具
20.Java中的各种锁和CAS
21.Spring核心
22.SpringMVC核心
23.SpringBoot核心
24.MyBatis（上）
MyBatis（下）
25.消息队列
26.MySQL汇总
27.Redis
28.设计模式
29.常见翻车合集
30.Java分布式框架
31.算法
32.JVM

2019网申渠道已开放，全国行程将在9月份正式开启

完整流程：网申-笔试-2轮面试（群面+单面）-收到实习录取通知

笔试流程：通过宣讲会,然后现场笔试。

一般早上9点开始笔试，笔试时间两小时，大概1个多小时完成答题。笔试后一天或一周，收到人力通知参加面试

笔试介绍：

1.参加笔试的学生分A-F卷，每套卷子的题目不一样，但题型应该差不多

2.恒生就一套笔试题，没有专门为不同岗位设计不同的试卷（噗！这就很坑爹了）

意味着网上能找到的所有恒生电子笔试题我都要准备一下，擦泪

题型

###一、基础题

#####（一）	选择题（单选或多选）

######第一部分（基础）

软件工程的如白盒黑盒测试
操作系统的进程
计算机网络
测试理论、数据库、c语言基础、tcp/ip协议，算法时间复杂度、遍历方法
基本涉及到大学的主要科目，题目不难但范围广，要拿高分比较难
…

######第二部分（Java/c）
C主要考察指针和引用(通过程序段的运行结果来考察)，还有数组和字符串、char类型…
java考察了子类和父类的继承，static修饰符，final、finally、finalize三个关键字的区别，还有protected、private、public关键字的区别…

#####（二）	大题

######第一部分（数据库）
一道数据库的题目（15分）：是一个商店的购买记录，用数据库语言进行如下操作，如查询所有女性购买的商品的前三名，查询某种商品的销售额，增加索引，创建一条新的条目等等，属于基本操作，难度不大。（数据库考得是简单语句，有写过一些数据库代码就不难做。）

涉及的有查询（包括子查询）、分组、排序、求平均值、添加索引，基本都涉及到数据库的增删改查…

######第二部分（算法）
两道算法的题目：一道相对简单，用数据结构或者基本的逻辑思维可以做，让我们输出螺旋矩阵；一道相对难一些，需要用到算法的知识，击鼓传花算法…

######第三部分（编程）

1.一道现场编程题，一方面要写清楚编程思路，一方面写出程序，需要好好锻炼一下。）用c/java/c++编程，我的这份题目是求100以内的素数

###二、逻辑题、性格测试

#####（一）	推理题，这一部分网上有很多类似的题目

#####（二）	寻找图像规律的题目，有点像智力测试

#####（三）	寻找数字规律的题目，这一部分找规律的题目比较难，基本靠蒙……


以下贴出部分关于恒生电子笔试的blog。

之后对于网上的恒生电子笔试题，我也会慢慢整理，放在我的博客里，供大家参考

2017年恒生电子春招笔试题

2016年恒生电子秋招笔试两道算法题

2008年恒生电子成都笔试题

2011年恒生电子校招笔试题

2015年恒生电子春季校招笔试题

2016年恒生电子校招编程题

恒生电子的坑爹Java笔试题

目录
前言
一、万万没想到之聪明的编辑
方法：常规方法，主要考察逻辑思维
二、万万没想到之抓捕孔连顺
方法：双指针（窗口滑动）
三、雀魂启动！
方法：递归（回溯法）
四、特征提取
方法：双hashMap

前言
如果能过字节的笔试，那应该没什么笔试能难倒你了，祝所有秋招的同学offer拿到手软

如果你从本文中学习到丝毫知识，那么请您点点关注、点赞、评论和收藏

大家好，我是爱做梦的鱼，我是东北大学大数据实验班大三的小菜鸡，非常渴望优秀，羡慕优秀的人，个人博客为：爱做梦的鱼https://zihao.blog.csdn.net/，微信公众号、微信视频号为【程序猿干货铺】，qq交流群为：1107710098，



一、万万没想到之聪明的编辑
时间限制： C/C++ 1秒，其他语言2秒
空间限制： C/C++ 32M，其他语言64M

我叫王大锤，是一家出版社的编辑。我负责校对投稿来的英文稿件，这份工作非常烦人，因为每天都要去修正无数的拼写错误。但是，优秀的人总能在平凡的工作中发现真理。我发现一个发现拼写错误的捷径：

三个同样的字母连在一起，一定是拼写错误，去掉一个的就好啦：比如 helllo -> hello
两对一样的字母（AABB型）连在一起，一定是拼写错误，去掉第二对的一个字母就好啦：比如 helloo -> hello
上面的规则优先“从左到右”匹配，即如果是AABBCC，虽然AABB和BBCC都是错误拼写，应该优先考虑修复AABB，结果为AABCC

我特喵是个天才！我在蓝翔学过挖掘机和程序设计，按照这个原理写了一个自动校对器，工作效率从此起飞。用不了多久，我就会出任CEO，当上董事长，迎娶白富美，走上人生巅峰，想想都有点小激动呢！

……

万万没想到，我被开除了，临走时老板对我说： “做人做事要兢兢业业、勤勤恳恳、本本分分，人要是行，干一行行一行。一行行行行行；要是不行，干一行不行一行，一行不行行行不行。” 我现在整个人红红火火恍恍惚惚的……
请听题：请实现大锤的自动校对程序
输入描述:
第一行包括一个数字N，表示本次用例包括多少个待校验的字符串。
后面跟随N行，每行为一个待校验的字符串。

输出描述:
N行，每行包括一个被修复后的字符串。

输入例子1:
2
helloo
wooooooow

输出例子1:
hello
woow

方法：常规方法，主要考察逻辑思维
代码
import java.util.Scanner;

public class First {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        for (int i = 0; i < N; i++) {
            String string = sc.next();
            int pointer = 0;
            StringBuilder ans = new StringBuilder();
            int last = 0;
            while (pointer < string.length()) {
                char temp = string.charAt(pointer);
                int cnt = 0;
                while (pointer < string.length() && temp == string.charAt(pointer)) { //求同一个字母相连了几个
                    pointer++;
                    cnt++;
                }
                if (cnt > 2) //1. 三个同样的字母连在一起，一定是拼写错误，去掉一个的就好啦：比如 helllo -> hello
                    cnt = 2;
                else if (cnt == 2 && last == 2)   //2.两对一样的字母（AABB型）连在一起，一定是拼写错误，去掉第二对的一个字母就好啦：比如 helloo -> hello
                    cnt = 1;
                last = cnt;
//                cnt= Math.min(cnt, 2);
                for (int j = 0; j < cnt; j++)
                    ans.append(temp);
            }
            System.out.println(ans);
        }
        sc.close();
    }
}

二、万万没想到之抓捕孔连顺
时间限制：C/C++ 1秒，其他语言2秒
空间限制：C/C++ 128M，其他语言256M

我叫王大锤，是一名特工。我刚刚接到任务：在字节跳动大街进行埋伏，抓捕恐怖分子孔连顺。和我一起行动的还有另外两名特工，我提议

我们在字节跳动大街的N个建筑中选定3个埋伏地点。
为了相互照应，我们决定相距最远的两名特工间的距离不超过D。

我特喵是个天才! 经过精密的计算，我们从X种可行的埋伏方案中选择了一种。这个方案万无一失，颤抖吧，孔连顺！

……

万万没想到，计划还是失败了，孔连顺化妆成小龙女，混在cosplay的队伍中逃出了字节跳动大街。只怪他的伪装太成功了，就是杨过本人来了也发现不了的！
请听题：给定N（可选作为埋伏点的建筑物数）、D（相距最远的两名特工间的距离的最大值）以及可选建筑的坐标，计算在这次行动中，大锤的小队有多少种埋伏选择。

注意：

两个特工不能埋伏在同一地点
三个特工是等价的：即同样的位置组合(A, B, C) 只算一种埋伏方法，不能因“特工之间互换位置”而重复使用

输入描述:
第一行包含空格分隔的两个数字 N和D(1 ≤ N ≤ 1000000; 1 ≤ D ≤ 1000000)

第二行包含N个建筑物的的位置，每个位置用一个整数（取值区间为[0, 1000000]）表示，从小到大排列（将字节跳动大街看做一条数轴）

输出描述:
一个数字，表示不同埋伏方案的数量。结果可能溢出，请对 99997867 取模

输入例子1:
4 3
1 2 3 4

输出例子1:
4

例子说明1:
可选方案 (1, 2, 3), (1, 2, 4), (1, 3, 4), (2, 3, 4)

输入例子2:
5 19
1 10 20 30 50

输出例子2:
1

例子说明2:
可选方案 (1, 10, 20)

方法：双指针（窗口滑动）
注意

一看见取模，小心数据大小范围

代码
import java.util.Scanner;

public class Second4 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        int D = sc.nextInt();
        int[] arr = new int[N];
        for (int i = 0; i < N; i++) {
            arr[i] = sc.nextInt();
        }
        sc.close();
        // 固定窗口的末尾位置,这样就可以保证窗口移动过程不会出现重复，因为下一次判断至少和上次的末尾位置不一样。
        // 然后从末尾位置的前面选取两个位置，加上末尾正好三个位置
        int start = 0;
        long ans = 0;
        for (int end = 2; end < N; end++) {
            while (start < end && (arr[end] - arr[start]) > D) {
                start++;
            }
            long nums = end - start;
            ans += nums * (nums - 1) / 2 ; //nums个中取两个位置，我们末尾的位置固定了，所以只需要去它前面找两个位置
        }
        System.out.println(ans% 99997867);
    }
}

三、雀魂启动！
时间限制：C/C++ 1秒，其他语言2秒

空间限制：C/C++ 32M，其他语言64M

小包最近迷上了一款叫做雀魂的麻将游戏，但是这个游戏规则太复杂，小包玩了几个月了还是输多赢少。

于是生气的小包根据游戏简化了一下规则发明了一种新的麻将，只留下一种花色，并且去除了一些特殊和牌方式（例如七对子等），具体的规则如下：
总共有36张牌，每张牌是1~9。每个数字4张牌。

你手里有其中的14张牌，如果这14张牌满足如下条件，即算作和牌

14张牌中有2张相同数字的牌，称为雀头。

除去上述2张牌，剩下12张牌可以组成4个顺子或刻子。顺子的意思是递增的连续3个数字牌（例如234,567等），刻子的意思是相同数字的3个数字牌（例如111,777）
例如：

1 1 1 2 2 2 6 6 6 7 7 7 9 9 可以组成1,2,6,7的4个刻子和9的雀头，可以和牌

1 1 1 1 2 2 3 3 5 6 7 7 8 9 用1做雀头，组123,123,567,789的四个顺子，可以和牌

1 1 1 2 2 2 3 3 3 5 6 7 7 9 无论用1 2 3 7哪个做雀头，都无法组成和牌的条件。
现在，小包从36张牌中抽取了13张牌，他想知道在剩下的23张牌中，再取一张牌，取到哪几种数字牌可以和牌。
输入描述:
输入只有一行，包含13个数字，用空格分隔，每个数字在1~9之间，数据保证同种数字最多出现4次。

输出描述:
输出同样是一行，包含1个或以上的数字。代表他再取到哪些牌可以和牌。若满足条件的有多种牌，请按从小到大的顺序输出。若没有满足条件的牌，请输出一个数字0

输入例子1:
1 1 1 2 2 2 5 5 5 6 6 6 9

输出例子1:
9

例子说明1:
可以组成1,2,6,7的4个刻子和9的雀头

输入例子2:
1 1 1 1 2 2 3 3 5 6 7 8 9

输出例子2:
4 7

例子说明2:
用1做雀头，组123,123,567或456,789的四个顺子

输入例子3:
1 1 1 2 2 2 3 3 3 5 7 7 9

输出例子3:
0

例子说明3:
来任何牌都无法和牌

方法：递归（回溯法）
本题考查的是回溯法，由于数据的规模非常小(n<=9)，所以递归不会很深。

从最小的数字开始尝试，如果把其当成雀头成员，该数字划掉两个，并看余下的数字能否划空
如果是刻子成员，该数字划掉三个，并查看余下数字能否划空
如果是顺子成员，划掉该值 a ,a+1,a+2，并查看余下数字能否划空

如果上述三种尝试都无法划空数组，说明存在数字无法是 雀头、刻子、顺子的成员， 即无法胡牌。
代码
import java.util.ArrayList;
import java.util.Scanner;

public class Third {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[] state = new int[9], helpArr = new int[9];
        ArrayList<Integer> res = new ArrayList<>();
        for (int i = 0; i < 13; i++) {
            int num = sc.nextInt();
            state[num - 1]++; //构建出state数组表示每一张牌的数量
        }
        for (int i = 0; i < 9; i++) { //抓取下一张牌，1-9
            if (state[i] < 4) { //如果抓了一张牌导致某个数字超过4，那么错误
                int num = i + 1;
                System.arraycopy(state, 0, helpArr, 0, 9); //复制数组
                helpArr[i]++;
                if (canHu(helpArr, 14, false)) res.add(num);
            }
        }
        if (res.isEmpty())
            System.out.println(0);
        else {
            StringBuilder sbf = new StringBuilder();
            sbf.append(res.get(0));
            for (int i = 1; i < res.size(); i++) {
                sbf.append(" ");
                sbf.append(res.get(i));
            }
            System.out.println(sbf.toString());
        }
    }

    /**
     * 判断是否可以和牌
     * @param arr 表示每一张牌的数量的数组，index+1代表牌的小，比如arr[0]存放的是1的个数
     * @param total 现在剩下的牌的数量
     * @param hasHead 有无雀头
     * @return
     */
    private static boolean canHu(int[] arr, int total, boolean hasHead) {
        if (total == 0)  // 剩下的牌为0，表明牌可以找到雀头，刻子和顺子（找到了就删掉了，所以数量不断变小）
            return true;
        if (!hasHead) { //  1. 先判断有无雀头
            for (int i = 0; i < 9; i++) {
                if (arr[i] >= 2) {
                    arr[i] -= 2;
                    if (canHu(arr, total - 2, true)) return true;
                    arr[i] += 2;
                }
            }
            return false;
        } else {
            for (int i = 0; i < 9; i++) {
                if (arr[i] > 0) { //找刻子和顺子，先找哪个无所谓
                    if (arr[i] >= 3) { //刻子：刻子的意思是相同数字的3个数字牌（例如111,777）
                        arr[i] -= 3;
                        if (canHu(arr, total - 3, true)) return true;
                        //和牌失败，得把拿掉的牌加回来
                        arr[i] += 3;
                    }
                    if (i + 2 < 9 && arr[i + 1] > 0 && arr[i + 2] > 0) { //顺子的意思是递增的连续3个数字牌（例如234,567等）
                        arr[i]--;
                        arr[i + 1]--;
                        arr[i + 2]--;
                        if (canHu(arr, total - 3, true)) return true;
                        //和牌失败，得把拿掉的牌加回来
                        arr[i]++;
                        arr[i + 1]++;
                        arr[i + 2]++;
                    }
                }
            }
        }
        return false;
    }
}

四、特征提取
时间限制：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

输出例子1:
3

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

方法：双hashMap
import java.util.HashMap;
import java.util.Scanner;

public class Fourth {
    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> map = new HashMap<>();
            HashMap<String, Integer> temp_map = new HashMap<>();
            int M = sc.nextInt();
            int max = 1;
            for (int j = 0; j < M; ++j) {
                temp_map.clear();
//                System.out.println(temp_map);
                int n = sc.nextInt();
                for (int k = 0; k < n; ++k) {
                    int x = sc.nextInt();
                    int y = sc.nextInt();
                    String key = x + "-" + y; //如果 x + “ ”+ y那么特征（1，11）和（11，1）无法区分
                    //使用的是map而不是temp_map，这是本算法核心，
                    //如果上一帧中存在一样的特征，那么我们的num在上一次记录的vlue（特征数=帧数，因为每个特征在每个帧就出现一次）基础上加1
                    //如果上一帧中不存在，则我们num为1，也就是从这次帧开始记录这个特征连续出现到几个帧
                    int num = map.getOrDefault(key, 0) + 1;
                    temp_map.put(key, num);
                    max = Math.max(num, max);
//                    System.out.println("temp_men: " + temp_map);
                }
                map.clear();
                map.putAll(temp_map);
//                System.out.println("men: " + map);
            }
            if (max <= 1) {
                System.out.println(1);
            } else {
                System.out.println(max);
            }

        }
        sc.close();

    }
}