图的定义与一般算法教材一致，分为无向图和有向图，一般有临接矩阵和临接表的表示法，包含两个具体参数，用V来指代图的节点(vertices)个数 和 E指代图的边(edge)的数目(Graph(V, E)), 具体介绍参见《算法导论》或着《算法第四版》。
图的最小切分：

一个图graph(V, E)的切分： 将图按结点分隔成两个非空集A和B----cut(A, B)。

cut(A, B)的crossing edge: 对无向图，两个端点各在两个点集内； 对有向图：边的尾结点在A, 首结点在B

总的切分个数（可能性）：最终有两个非空点集，那么假设总共有n个点，这n个点每一个都等可能在A 或B内，两种可能，故总共有2^n种切分方式。

最小切分：图的一种切分有数量最少的的crossing edge。

问题：

输入： 一个无向图G = (V, E), 允许存在平行边（最小切分的本质不变）

输出： 计算一个图的最小切分（有最少个数的crossing edge的切分的crossing edge个数）

算法：一种概率算法, 多次计算取最小值

import java.io.IOException;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;
import java.util.Scanner;

public class KargerMinCut {

    public static void main(String[] args) throws IOException {
        KargerMinCut mc = new KargerMinCut();
        int min = mc.mincut();
        
        
        for (int i = 0; i < 1000; i++){
            mc = new KargerMinCut();
            int ans = mc.mincut();
            if ( ans < min) {
                min = ans;
            }
        }
        
        System.out.println(min);
    }
    
    // 图的数据结构，存储每一条边
    List<HashSet<Integer>> vergroups = new LinkedList<>();
    
    HashSet<ArrayList<Integer>> Graph = new HashSet<>();
    
    public int mincut() throws IOException {
        Random r = new Random();
        HashSet<Integer> vertices = new HashSet<>();
        int vsize = 0;

        Scanner in1 = new Scanner(Paths.get(""));  // 文件路径
        
        while (in1.hasNextLine()) {
            vsize++;
            String line = in1.nextLine();
            Scanner readInt = new Scanner(line);
            int v = readInt.nextInt();
            while (readInt.hasNextInt()) {
                Graph.add(new ArrayList<Integer>() {{ add(v); add(readInt.nextInt());}});
            }
            readInt.close();
        }
        in1.close();
        
        for (int i=1; i<=vsize; i++) {
            vertices.add(i);
        }

        while (true) {
            if ((vergroups.size()==2 && vertices.size()==0) ||
                    ((vergroups.size()==1) && vertices.size()==1)) {
                break;
            }

            ArrayList[] a = new ArrayList[0];
            ArrayList<Integer>[] g = Graph.toArray(a);
            ArrayList<Integer> pair = g[r.nextInt(g.length)];

            int v = pair.get(0);
            int u = pair.get(1);
            
            Iterator<HashSet<Integer>> i = vergroups.iterator();
            HashSet<Integer> conV = new HashSet<Integer>();
            HashSet<Integer> conU = new HashSet<Integer>();
            if (!i.hasNext()) {
                vergroups.add(new HashSet<Integer>(pair));
                vertices.remove(u);
                vertices.remove(v);
            }
            else 
            while (i.hasNext()) {
                HashSet<Integer> h = i.next();
                
                if (h.contains(v)) {
                    conV = h;
                }
                else if (h.contains(u)) {
                    conU = h;
                }
            }
            
            if (conV.contains(v) && !conU.contains(u)) {
                conV.add(u);                    
                vertices.remove(u);
                removeloop(conV, v, u);
            }
            else if (!conV.contains(v) && conU.contains(u)) {
                conU.add(v);                    
                vertices.remove(v);
                removeloop(conU, u, v);
            }
            else if (!conV.contains(v) && !conU.contains(u) && !vergroups.contains(new HashSet<Integer>(pair))) {
                vergroups.add(new HashSet<Integer>(pair));
                vertices.remove(u);
                vertices.remove(v);
            }
            else if (conV.contains(v) && conU.contains(u)) {
                conV.addAll(conU);
                vergroups.remove(conU);
                removeloop(conV, conU, v, u);
            }

            deledge(v, u);
        }
        
        return Graph.size()/2;
    }

    
    public void deledge(int v, int u) {
        List<Integer> t1 = new ArrayList<Integer>(2); 
        t1.add(v); t1.add(u);
        List<Integer> t2 = new ArrayList<Integer>(2); 
        t2.add(u); t2.add(v);
        Graph.remove(t1);
        Graph.remove(t2);
        
    }
    
    public HashSet<Integer> preprocess(int v, int u) {
        for (HashSet<Integer> h : vergroups) {
            if (h.contains(v)) return h;
            else if (h.contains(u)) return h;
        }
        return null;
    }
    
    public void removeloop(HashSet<Integer> h, int v, int u) {
        for (Integer l : h) {
            if (l != u && l != v) {
                deledge(l, u);
                System.out.println("l:" + l + "  " + "u:" + u);
            }
        }
    }
    
    public void removeloop(HashSet<Integer> V, HashSet<Integer> U, int v, int u) {
        for (Integer exu : U) {
            if (exu != u)
            for (Integer j : V) {
                deledge(exu, j);
            }
        }
    }

}