最大流（一）----前向星与链式前向星存储图结构

前向星存储图结构

链式前向星存储图结构

package graphModel;

import java.util.Arrays;

public class Graph {
    public static int inf = 1000;// 用于申请大数组，防止越界，同时也表示两点之间不连接
    private Edge[] edges;// 存储边的数组
    private int[] head;// 链式前向星存储图结构
    private int cnt;// 用于链式前向星存储图结构
    private int[][] indexOfEdge;//已知from和to节点，输出from-to这条边在edges数组内的索引
    public Graph(int N) {//N为顶点个数
        edges = new Edge[N*(N-1)];
        head = new int[N];
        Arrays.fill(head, -1);
        indexOfEdge = new int[N][N];
        for(int i=0 ;i <N; i++) 
            for(int j=0; j<N; j++)
                indexOfEdge[i][j]=inf;
        this.cnt = 0;
    }
    public void addEdge(int u, int v, int w) {
        edges[cnt] = new Graph.Edge();
        edges[cnt].w = w;
        edges[cnt].to = v;
        edges[cnt].next = head[u];
        head[u] = cnt;
        indexOfEdge[u][v] = cnt;
        cnt++;
    }

    /**
     * 将邻接矩阵存储的图转为链式前向星存储 用于解决最大流问题
     * 
     * @param dag
     */
    public void initSolveMaxFlow(int[][] dag) {
        for (int i = 0; i < dag.length; i++) {
            for (int j = dag.length - 1; j >= 0; j--) {
                if (i != j && dag[i][j] < inf) {
                    this.addEdge(i, j, dag[i][j]);
                    this.addEdge(j, i, 0);
                }
            }
        }
    }

    /**
     * 将邻接矩阵存储的图转为链式前向星存储 用于解决非最大流问题，例如单源最短路径
     * 
     * @param dag
     */
    public void init(int[][] dag) {
        for (int i = 0; i < dag.length; i++) {
            for (int j = dag.length - 1; j >= 0; j--) {
                if (i != j && dag[i][j] < inf) {
                    this.addEdge(i, j, dag[i][j]);
                }
            }
        }
    }

    public Edge[] getEdges() {
        return this.edges;
    }

    public int[] getHead() {
        return this.head;
    }
    public int[][] getIndexOfEdge(){
        return this.indexOfEdge;
    }

    class Edge {
        Edge() {
        }

        int next;
        int to;
        int w;
    }
}