数组实现邻接表(java)

受限条件下可到达节点的数目

现有一棵由 n 个节点组成的无向树，节点编号从 0 到 n - 1 ，共有 n - 1 条边。

给你一个二维整数数组 edges ，长度为 n - 1 ，其中 edges[i] = [ai, bi] 表示树中节点 ai 和 bi 之间存在一条边。另给你一个整数数组 restricted 表示 受限 节点。

在不访问受限节点的前提下，返回你可以从节点 0 到达的 最多 节点数目。

注意，节点 0 不 会标记为受限节点。

示例 1：

输入：n = 7, edges = [[0,1],[1,2],[3,1],[4,0],[0,5],[5,6]], restricted = [4,5]
输出：4
解释：上图所示正是这棵树。
在不访问受限节点的前提下，只有节点 [0,1,2,3] 可以从节点 0 到达。

解题思路：对于稀疏图采用邻接表来实现，这里使用数组来实现邻接表，建立三个数组，h,e,ne.

h[i]代表点i是第几条边的起点，e[i]代表是第i条边的终点，ne[i]代表在生成第i条边前，第i条边的起点a同时还是第几条边的起点。具体代码如下

public class Solution {
 
    public static void main(String args[]) {
        int[][] chess = {{4,1},{1,3},{1,5},{0,5},{3,6},{8,4},{5,7},{6,9},{3,2}};
        int[] restricted = {2,7};
        System.out.println(reachableNodes(10,chess,restricted));
    }
 
    static int[] h;
    static int[] e;
    static int[] ne;
    static int idx = 0;
    static boolean[] ban;
    public static int reachableNodes(int n, int[][] edges, int[] restricted) {
        h = new int[n];
        e = new int[2 * n];
        ne = new int[2 * n];
        Arrays.fill(h, -1);
        // 建图
        for (int[] e : edges) {
            // 无向图, 连2条边
            add(e[0], e[1]);
            add(e[1], e[0]);
        }
        ban = new boolean[n];
        for (int r : restricted) {
            ban[r] = true;
        }
        return dfs(0);
    }
 
    private static int dfs(int node) {
        if (ban[node]) {
            return 0;
        }
        int ans = 1;
        ban[node] = true;
        for (int i = h[node]; i != -1; i = ne[i]) {
            int son = e[i];
            ans += dfs(son);
        }
        return ans;
    }
 
    private static void add(int a, int b) {
        e[idx] = b;
        ne[idx] = h[a];
        h[a] = idx++;
    }
 
 
}