LintCode1371 · Linked List Components go

/**
1371 · Linked List Components
Algorithms
Medium
Accepted Rate
66%

DescriptionSolutionNotesDiscussLeaderboard
Description
We are given head, the head node of a linked list containing unique integer values.

We are also given the list G, a subset of the values in the linked list.

Return the number of connected components in G, where two values are connected if they appear consecutively(the longest) in the linked list.

If N is the length of the linked list given by head, 1 \leq N \leq 100001≤N≤10000.
The value of each node in the linked list will be in the range [0, N - 1].
1 \leq G.length \leq 100001≤G.length≤10000.
G is a subset of all values in the linked list.
Example
Example 1:

Input: head = 0->1->2->3, G = [0, 1, 3]
Output: 2
Explanation:
0 and 1 are connected, so [0, 1] and [3] are the two connected components.
Example 2:

Input: head = 0->1->2->3->4, G = [0, 3, 1, 4]
Output: 2
Explanation:
0 and 1 are connected, 3 and 4 are connected, so [0, 1] and [3, 4] are the two connected components.
Tags

https://blog.csdn.net/qq_46105170/article/details/105626173

https://www.lintcode.com/problem/1371/
*/

参考了一个老哥的解法，写了go语言版本的，本地测试结果是对的，结果上线跑出来结果不一致，暂时没搞清楚为什么，贴下WA的答案

//WA
func numComponents(head *ListNode, G []int) int {
	// Write your code here
	var res int = 0
	set := make(map[int]bool)
	for i := 0; i < len(G); i++ {
		set[G[i]] = true
	}
	var dummy ListNode = ListNode{0, nil}
	var prev *ListNode = &dummy
	dummy.Next = head
	for {
		if prev.Next == nil {
			break
		}
		if set[prev.Next.Val] == true {
			res += 1
			for {
				if !(prev.Next != nil && set[prev.Next.Val] == true) {
					break
				}
				prev = prev.Next
			}
		} else {
			prev = prev.Next
		}
	}
	return res
}

转载一下老哥对的答案：

import java.util.HashSet;
import java.util.Set;

public class Solution {
    /**
     * @param head: the head
     * @param G: an array
     * @return: the number of connected components in G
     */
    public int numComponents(ListNode head, int[] G) {
        // Write your code here
        int res = 0;
        Set<Integer> set = new HashSet<>();
        for (int i : G) {
            set.add(i);
        }
        
        ListNode dummy = new ListNode(0), prev = dummy;
        dummy.next = head;
        
        while (prev.next != null) {
        	// 走到了G里的数，记等价类个数res加一，
        	// 并把prev向后移动直到走到链表末尾或者走到了某个G外的数为止
            if (set.contains(prev.next.val)) {
                res++;
                while (prev.next != null && set.contains(prev.next.val)) {
                    prev = prev.next;
                }
            } else {
                prev = prev.next;
            }
        }
        
        return res;
    }
}

class ListNode {
    int val;
    ListNode next;
    ListNode(int x) {
        val = x;
    }
}