《啊哈！算法》第六章下

这个邻接表令我颇为困惑，最终只能整理出以下思绪：first数组用来存储每个点最后相关的边（最近一次作为起始点是第几条边），next数组存储的是以同一点为起始点的下一条边（回溯）的index，直到回溯到第一条，因而打印的时候是遍历所有点，找出他最后相关边的index（利用first数组），再寻找之前的相关边，直到某一条边next的值为-1，说明这已经是能找到的最前面一条了。
那就来写代码吧~

import java.util.Scanner;

public class Test {
    public static void main(String[] args){
        int n,m;
        System.out.println("请输入点和边的数量");
        Scanner sc=new Scanner(System.in);
        n=sc.nextInt();//pointnum
        m=sc.nextInt();//sidenum
        int[] a1=new int[m+1];
        int[] a2=new int[m+1];
        int[] weigh=new int[m+1];
        int[] first=new int[n+1];
        int[] next=new int[m+1];
        for(int i=1;i<=n;i++)
            first[i]=-1;
        System.out.println("请输入起点、终点和权值");
        for(int i=1;i<=m;i++){
            a1[i]=sc.nextInt();
            a2[i]=sc.nextInt();
            weigh[i]=sc.nextInt();
            next[i]=first[a1[i]];
            first[a1[i]]=i;
        }
        for(int i=1;i<=n;i++) {
            int k=first[i];
            while (k != -1) {
                System.out.println(a1[k] + " " + a2[k] + " " + weigh[k]);
                k = next[k];
            }
        }
    }
}
/*
1 4 9
4 3 8
1 2 5
2 4 6
1 3 7
 */

Floyd算法属于动态规划算法，Dijkstra算法属于贪心算法。Floyd算法可以接受负权边，但是接受不了负权回路，比如：1->2 -1，2->1 -1,这种情况，就会没完没了了。Dijkstra算法接受不了负权边，比如当前距离源点最近的点2，权值是1，就先把1->2确定了，但是如果1->3 2,3->2 -3的话，1->2的权值还需要改变，这就和Dijkstra算法的每次确定一条最短边的思路相矛盾了。
下面这种算法就可以解决这个问题了~
6.3 Bellman-Ford算法
这里主要的是两个判断：是否已经没必要继续下一轮边的松弛了，以及是否是一个负权回路。第一个要依靠复制当前数组和处理后的数组作比较判断，后一个是在所有点的松弛完成后检查各条边是否还能继续松弛来判断，因为负权回路会造成死循环。

import java.util.Scanner;

class Test{
    public static void main(String[] args){
        int n,m;
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入点和边的数量");
        n=sc.nextInt();
        m=sc.nextInt();
        int[] dis=new int[n+1];
        int[] tmp=new int[n+1];
        int[] u=new int[m+1];
        int[] v=new int[m+1];
        int[] w=new int[m+1];
        int inf=9999;
        System.out.println("请输入每条边的起点、终点和权值");
        for(int i=1;i<=m;i++){
            u[i]=sc.nextInt();
            v[i]=sc.nextInt();
            w[i]=sc.nextInt();
        }
        for(int i=2;i<=n;i++)
            dis[i]=inf;
        dis[1]=0;
        for(int i=1;i<=n-1;i++){
            for(int j=1;j<=n;j++)
                tmp[j]=dis[j];
            for(int j=1;j<=m;j++){
                if(dis[v[j]]>dis[u[j]]+w[j])
                    dis[v[j]]=dis[u[j]]+w[j];
            }
            int check=0;
            for(int j=1;j<=n;j++){
                if(tmp[j]!=dis[j]){
                    check=1;
                    break;
                }
            }
            if(check==0) //这次松弛没有造成变化，已经不用再继续了
                break;

        }
        int flag=0;
        for(int j=1;j<=m;j++){
            if(dis[v[j]]>dis[u[j]]+w[j]) {
                flag = 1;
                break;
            }
        }
        if(flag==1)
            System.out.println("这是一个负权回路");
        else {
            for (int i = 1; i <= n; i++)
                System.out.print(dis[i] + " ");
        }
    }
}
/*
2 3 2
1 2 -3
1 5 5
4 5 2
3 4 3
 */

6.4 Bellman-Ford算法优化
通过只对被松弛的边进行操作避免做重复运算。光看这个需要准备的变量和数组数量就知道这里头有几个点了：队列，邻接表，是否已标记，源点出来的到各目标点的distance数组。

import java.util.Scanner;

class Test{
    public static void main(String[] args){
        int n,m,k;
        System.out.println("请输入点和边的数量");
        Scanner sc=new Scanner(System.in);
        n=sc.nextInt();//点
        m=sc.nextInt();//线
        int[] first=new int[n+1];
        int[] next=new int[m+1];
        int[] u=new int[m+1];
        int[] v=new int[m+1];
        int[] w=new int[m+1];
        int[] book=new int[n+1];
        int[] dis=new int[n+1];
        int head,tail;
        int[] queue=new int[100];
        int inf=9999;
        for(int i=1;i<=n;i++)
            first[i]=-1;
        System.out.println("请输入起点、终点和权值");
        for(int i=1;i<=m;i++){
            u[i]=sc.nextInt();
            v[i]=sc.nextInt();
            w[i]=sc.nextInt();
            next[i]=first[u[i]];
            first[u[i]]=i;
        }
        for(int i=1;i<=n;i++)
            dis[i]=inf;
        dis[1]=0;
        head=1;
        tail=1;
        queue[tail]=1;
        tail++;
        book[1]=1;
        while(head<tail) {
            k=first[queue[head]];
            while (k != -1) {
                if (dis[v[k]] > dis[u[k]] + w[k]) {
                    dis[v[k]] = dis[u[k]] + w[k];
                    if (book[v[k]] == 0) {
                        queue[tail] = v[k];
                        book[v[k]] = 1;
                        tail++;
                    }
                }
                k = next[k];
            }
            book[queue[head]]=0;
            head++;
        }
        for(int i=1;i<=n;i++)
            System.out.print(dis[i]+" ");
    }
}
/*
1 2 2
1 5 10
2 3 3
2 5 7
3 4 4
4 5 5
5 3 6
 */

6.5 算法比较