LeetCode160. 相交链表 / 牛客：特征提取

Posted 2021-06-21 Zephyr丶J

160. 相交链表

2021.6.4每日一题

题目描述

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

图示两个链表在节点 c1 开始相交：

题目数据 保证 整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构 。

 

示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
示例 2：

输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Intersected at '2'
解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。
在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。
示例 3：

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/intersection-of-two-linked-lists
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

剑指offer的题，前段时间做过，最简单的方法就是两个指针分别从两个头节点出发，如果走到尾部就指向另一个头节点继续前进，直到两个结点相同；此时如果指针节点为空，那么返回null，否则返回这个节点，即相交节点

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        //刚剑指offer做过
        if(headA == null || headB == null)
            return null;
        ListNode index1 = headA;
        ListNode index2 = headB;
        while(index1 != index2){
            if(index1 == null)
                index1 = headB;
            else{
                index1 = index1.next;
            }
            if(index2 == null)
                index2 = headA;
            else
                index2 = index2.next;
        }
        return index1 == null ? null : index1;
    }
}

牛客：特征提取

链接：https://www.nowcoder.com/questionTerminal/5afcf93c419a4aa793e9b325d01957e2
来源：牛客网

题目描述

发出去高度相似了…题目就不描述了，要看题目的话还是直接点链接吧
小明是一名算法工程师，同时也是一名铲屎官。某天，他突发奇想，想从猫咪的视频里挖掘一些猫咪的运动信息。为了提取运动信息，他需要从视频的每一帧提取“猫咪特征”。一个猫咪特征是一个两维的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。
特征取值均为非负整数。

思路

主要学到了，哈希表在使用containsKey方法的时候，是怎么判断两个键值相同的
会先进入hashCode方法中，进行计算，如果两个键值的哈希值相同，再进入equals方法中进行判断，如果相同，才会返回true；
因此这里要重写这两个方法，光写一个hashCode方法是不行的。

//这题就本身算法而言没什么难度，如果下面一行有和上面一行相同的，就把计数器++，否则为0
//主要还是看怎么存储数据方便
//看了一圈，学习两个写法吧，一个是将特征的两个数拼接成字符串当做哈希表的键
//另一种写法，创建一个新的类作为哈希表的键，然后重写equals方法
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++){
            int M = sc.nextInt();
            //当前特征和出现次数
            Map<Node, Integer> map = new HashMap<>();
            Map<Node, Integer> temp = new HashMap<>();
            int max = 0;
            for(int j = 0; j < M; j++){
                int k = sc.nextInt();
                for(int t = 0; t < k; t++){
                    int x = sc.nextInt();
                    int y = sc.nextInt();
                    
                    Node node = new Node(x, y);
                    if(map.containsKey(node)){
                        temp.put(node, map.get(node) + 1);                   
                    }else{
                        temp.put(node, 1);
                    }
                    max = Math.max(max, temp.get(node));
                }
                map.clear();
                map.putAll(temp);
                temp.clear();
            }
            System.out.println(max);
        }
    }
}

class Node{
    int x;
    int y;
    public Node(int x, int y){
        this.x = x;
        this.y = y;
    }
    
    public boolean equals(Object o){
        if(this == o)   
            return true;
        if(o == null || getClass() != o.getClass())
            return false;
        Node node = (Node) o;
        return x == node.x && y == node.y;
    }
    
    public int hashCode() {
        return Objects.hash(x, y);
    }
}