Ex 5_21 无向图G=(V,E)的反馈边集..._第九次作业

根据题意，求的是最大生成树。利用Kruskal算法,对边进行从大到小的顺序进行排序，然后再依次取出边加入结果集中。假设图有n个顶点，那么，当结果集中有n-1条边时，剩下的边的集合即为反馈边集。

package org.xiu68.ch05.ex9;

import java.util.ArrayList;
import java.util.Comparator;

public class Ex5_21 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[][] edges=new int[][]{
            {0,2,1,6},
            {2,0,5,3},
            {1,5,0,4},
            {6,3,4,0}
        };
        ArrayList<String> vexs=new ArrayList<>();
        for(int i=0;i<4;i++)
            vexs.add("v"+i);
        MGraph<String> m1=new MGraph<String>(4,4,edges,vexs);
        m1.kruskal();
        //运行结果
        /*
        (0,3):6
        (1,2):5
        (2,3):4
        (1,3):3
        (0,1):2
        (0,2):1
        *************************************
        反馈边集为:
        (1,3):3
        (0,1):2
        (0,2):1
        */
    }
}

//边类型
class Edge{
    public int head;    //头顶点序号
    public int tail;    //尾顶点序号
    public int cost;    //权值
    
    public Edge(int head, int tail, int cost) {
        super();
        this.head = head;
        this.tail = tail;
        this.cost = cost;
    }
}

//邻接矩阵表示图
class MGraph<T> implements Comparator<Edge>{
    public int vexNum;                //顶点数量
    public int edgeNum;                //边数量
    public ArrayList<T> vexs;        //顶点表
    public int[][] edges;            //邻接矩阵
    
    public MGraph(int vexNum, int edgeNum, int[][] edges, ArrayList<T> vexs) {
        this.vexNum = vexNum;
        this.edgeNum = edgeNum;
        this.edges = edges;
        this.vexs=vexs;
    }
    
    //返回反馈边集
    public void kruskal(){
        ArrayList<Edge> eds=new ArrayList<>();
        //初始化边集数组
        for(int i=0;i<edges.length;i++){
            for(int j=i+1;j<edges[i].length;j++){
                if(edges[i][j]==0)
                    continue;
                Edge e=new Edge(i,j,edges[i][j]);
                eds.add(e);
            }
        }
        
        //对边集数组进行排序
        eds.sort(this);
        
        for(int i=0;i<eds.size();i++)
            System.out.println("("+eds.get(i).head+","+eds.get(i).tail+"):"+eds.get(i).cost);
        
        ArrayList<Edge> resultSet=new ArrayList<>();    //存放反馈边集
        int[] components=new int[vexNum];                //并查集
        for(int i=0;i<vexNum;i++)
            components[i]=i;
        
        int k=0,j=0;
        while(k<vexNum-1){
            
            int h1=eds.get(j).head;
            int t1=eds.get(j).tail;
            int com1=components[h1];
            int com2=components[t1];
            
            //在不同的并查集
            if(com1!=com2){        
                k++;
                for(int i=0;i<vexNum;i++){
                    if(components[i]==com2)
                        components[i]=com1;
                }
            }else{
                //反馈边集
                resultSet.add(eds.get(j));
            }
            j++;
        }
        
        //找到n-1条边后，剩下的边也属于反馈边集
        for(int i=j;i<eds.size();i++)
            resultSet.add(eds.get(i));
        
        System.out.println("*************************************");
        System.out.println("反馈边集为:");
        for(int i=0;i<resultSet.size();i++)
            System.out.println("("+resultSet.get(i).head+","+resultSet.get(i).tail+"):"+resultSet.get(i).cost);
    }

    @Override
    public int compare(Edge e1, Edge e2) {
        // TODO Auto-generated method stub
        //按从大到小排序
        if(e1.cost<e2.cost)
            return 1;
        else
            return -1;
    }
}