链式前向星存图模板

一直用C++的vector<int>a[n]按需存图，Java的Arraylist倒是不给开数组，前两天写树题都用C++，请教大佬一道题，他用链式前向星写给我，突然记起还有链式前向星这么个东西，个人很少用，都忘了，今日遇到一道题，复习一下顺便记录模板。

链式前向星应用

• 存各种图都很适合，但不能快速查询一条边是否存在，也不能方便地对一个点的出边进行排序。
• 优点是边是带编号的，有时会非常有用，而且如果 cnt 的初始值为奇数，存双向边时 i ^ 1 即是 i 的反边（常用于 网络流 ）。

链式前向星用两个数组存图，edge和head数组，存图全程用一个cnt记录边的总数量。

public class Main{
    static Edge[] edge=new Edge[10086*2];
    static int[] head=new int[10086];
    static int cnt=0;
    public static void add_edge(int u,int v,int val) {
        edge[cnt]=new Edge();
        edge[cnt].to=v;
        edge[cnt].val=val;
        edge[cnt].next = head[u];
        head[u] = cnt++;
    }
    public static void main(String []args){    
        Scanner scan=new Scanner(System.in);
        Arrays.fill(head, -1);
        //建一个n个点，m条边的图
        int n=scan.nextInt();
        int m=scan.nextInt();
        for(int i=1;i<=m;i++) {
            int u=scan.nextInt();
            int v=scan.nextInt();
            int val=scan.nextInt();
            add_edge(u,v,val);
            add_edge(v, u, val);//双向存无向边
        }
        
        //遍历2号点的邻边
        for(int i=head[2];i!=-1;i=edge[i].next) {
            System.out.println("i="+i+" to="+edge[i].to+" val="+edge[i].val);
        }
    }
}
class Edge{
    int to;//指向的点
    int val;//边的权值
    int next;//用于指示该点的下一条边的在edge中的位置
}

/*
4 5
1 2 12
2 4 24
1 4 14
1 3 13
2 3 23

i=8 to=3 val=23
i=2 to=4 val=24
i=1 to=1 val=12
*/

head[u]存的是最后一条边在edge数组中的位置，初始head为-1，这个-1会放在u在edge数组边中的第一条。

 

例题：力扣1376. 通知所有员工所需的时间

公司里有 n 名员工，每个员工的 ID 都是独一无二的，编号从 0 到 n - 1。公司的总负责人通过 headID 进行标识。

在 manager 数组中，每个员工都有一个直属负责人，其中 manager[i] 是第 i 名员工的直属负责人。对于总负责人，manager[headID] = -1。题目保证从属关系可以用树结构显示。

公司总负责人想要向公司所有员工通告一条紧急消息。他将会首先通知他的直属下属们，然后由这些下属通知他们的下属，直到所有的员工都得知这条紧急消息。

第 i 名员工需要 informTime[i] 分钟来通知它的所有直属下属（也就是说在 informTime[i] 分钟后，他的所有直属下属都可以开始传播这一消息）。

返回通知所有员工这一紧急消息所需要的 分钟数 。

 

示例 1：

输入：n = 1, headID = 0, manager = [-1], informTime = [0]
输出：0
解释：公司总负责人是该公司的唯一一名员工。
示例 2：

 

输入：n = 6, headID = 2, manager = [2,2,-1,2,2,2], informTime = [0,0,1,0,0,0]
输出：1
解释：id = 2 的员工是公司的总负责人，也是其他所有员工的直属负责人，他需要 1 分钟来通知所有员工。
上图显示了公司员工的树结构。

提示：

1 <= n <= 10^5
0 <= headID < n
manager.length == n
0 <= manager[i] < n
manager[headID] == -1
informTime.length == n
0 <= informTime[i] <= 1000
如果员工 i 没有下属，informTime[i] == 0 。
题目 保证 所有员工都可以收到通知。

思路：显然找这棵树根所能到达的最远路径，通知会往下一层所有节点同时传递。

从上往下用dfs，需要建树。

从下往上用回溯，类似并查集，如果树一半是一条链，一半跟在最后一个点，常规回溯复杂度是n²，需要用记忆化搜索辅助。

class Solution {
    static Edge[] edge=new Edge[100005];//用有向边
    static int[] head = new int[100005];
    static int cnt=0,ans=0;
    public int numOfMinutes(int n, int headID, int[] manager, int[] informTime) {
        cnt=0;ans=0;
        Arrays.fill(head,-1);
        int root=0;//找树形结构的根节点
        for(int i=0;i<manager.length;i++){
            if(manager[i]!=-1){
                int u=manager[i];
                add_edge(u,i,informTime[u]);//有向边，u通知i，u→i
            }else
                root=i;
        }
        dfs(root,0);
        return ans;
    }
    public void add_edge(int u,int v,int val){
        if(edge[cnt]==null)//同一组代码测试很多数据，节省空间
            edge[cnt]=new Edge();
        edge[cnt].to=v;
        edge[cnt].val=val;
        edge[cnt].next = head[u];
        head[u] = cnt++;
    }
    public void dfs(int x,int now){//当前节点，深搜过程中当前距离
        ans=Math.max(ans,now);
        for(int i=head[x];i!=-1;i=edge[i].next){
            dfs(edge[i].to,now+edge[i].val);
        }
    }
}
class Edge{//边
    int to;
    int val;
    int next;
}