Question

我使用路径压缩启发式和联盟等联盟查找数据结构实现了Karger算法，但我遇到了几个问题

我基本上做的是，我运行算法N N log（N）时间，以便对答案做出很好的估计。但是，我只是没有得到MinCut的答案。我每次选择一个随机边缘，其中有2个成员来源＆＃39; s＆＃39;和目的地＆＃39; d。如果他们的父母不相等，我合并他们并减少顶点的数量，＆＃39; vcnt＆＃39;它最初等于原始顶点数。这个过程一直持续到剩下的顶点数为2.最后，我找到每个边的源和目标的父节点，如果它们相等，我增加MinCut计数。这会重复N N Log（N）次。

我尝试使用大量测试数据运行我的代码，但我似乎没有获得Mincut Value，特别是对于大数据。

有人可以帮帮我吗？此外，欢迎提高绩效的建议。这是代码：

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;

class KragersMinCut
{
    static int n=200;//Number of Vertices
    static int[] u=new int[n];
    static int[]rank =new int[n];

    static class Edge //Edge which hols the source and destination
    {
        int s,d;//Source,Destination
        Edge(int s,int d)
        {
            this.s=s;
            this.d=d;
        }
    }

    private static void InitializeUnionFindData()
    {
        for(int i=0;i<n;i++)
        {
            u[i]=i;
            rank[i]=1;
        }
    }

    private static int FIND(int xx) //Finding Parent using Path-Compression Heuristics
    {
        if(u[xx]!=u[u[xx]])
        {
            u[xx]=FIND(u[xx]);
        }
        return u[xx];
    }

    private static boolean UNION(int x,int y) //Union by Order-by-Rank to create evenly balanced search trees
    {
    int px=FIND(x),py=FIND(y);
    if(rank[px]>rank[py])
    {
        int temp=px;
        px=py;
        py=temp;
    }
    else if(rank[px]==rank[py])
        rank[py]++;

    u[px]=py;
    return true;
    }


    public static void main(String[] args) throws IOException
    {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        ArrayList<Edge> EdgeList=new ArrayList<Edge>();
        for(int i=0;i<n;i++)
        {
            String x=br.readLine();
            ArrayList<Integer>al=new ArrayList<Integer>();
            for(int j=0;j<x.length();j++) //This loop is for parsing the input format
            {
                if(x.charAt(j)<48 || x.charAt(j)>57)
                    continue;

                int p=j;
                String input="";
                while(p!=x.length()&&(x.charAt(p)>=48 && x.charAt(p)<=57))
                {
                    input+=(x.charAt(p));
                    p++;
                }
                j=p;
                al.add(Integer.parseInt(input.trim())-1);
            }
            for(int j=1;j<al.size();j++)
            {
                EdgeList.add(new Edge(al.get(0),al.get(j)));//Source,Destination
            }
        }
        //Edge list ready
        int MinCut=Integer.MAX_VALUE;
        for(int q=0;q<(n*n)*Math.log(n);q++)//Running theta(n^2*ln(n)) times for a good estimate. Runs in about 20 secs
        {
            int vcnt=n;//Essentially n
            InitializeUnionFindData();
            while(vcnt>2)
            {
                Edge x=EdgeList.get((int)(Math.random()*(EdgeList.size()-1)+1));//Obtaining random valued element at index from EdgeList
                int s=x.s,d=x.d;
                int ps=FIND(s),pd=FIND(d);
                if(ps!=pd)//Contracting. Essentially making their parents equal
                {
                    UNION(s,d);
                    vcnt--;
                }
            }
            int CurrMinCutValue=0;
            for(Edge i:EdgeList)
            {
                int px=FIND(i.s),py=FIND(i.d);
                if(px!=py)//Since they belong to different Vertices
                {
                    CurrMinCutValue++;
                }
            }
            MinCut=Math.min(MinCut,CurrMinCutValue);//Finding Minimum cut of all random runs
        }
        System.out.println(MinCut);
    }
}

TestData :(源顶点 - >连接顶点）

1 2 3 4 7

2 1 3 4

3 1 2 4

4 1 2 3 5

5 4 6 7 8

6 5 7 8

7 1 5 6 8

8 5 6 7

答案：4 |预期答案：2

链接：http://ideone.com/QP62FN

由于

Answer 1

该算法表明每个边缘都可能被选中用于合并。

但是你的代码从不在索引0处选择边缘。

所以修改一下：

Edge x=EdgeList.get((int)(Math.random()*(EdgeList.size()-1)+1));

到此：

Edge x=EdgeList.get((int)(Math.random()*(EdgeList.size())));

此外，因为边缘列表中的每个边缘都列出了两次：

您应该打印以下内容

System.out.println(MinCut/2);

现在应该可以了。

使用Union-Find实现Karger最小割算法的问题

1 个答案: