Algorithm I assignment Percolation

这道题来自Algorithms 4th的公开课，是week1的assignment。该题主要是对并查集的应用，点击：参考

看过lecture后，想到解决这道题的思路并不难，不过想要拿到满分着实费功夫...累积花费了5个小时才AC。

在实现代码过程中遇到了以下问题：

1. 时间复杂度超了，因为在实现percolates()时，采用了遍历的方式检查：所以在grid的上下两端虚拟两个site。默认其和第一行和最后一行是连通的。
2. 由于采用了虚拟的site，引入了新问题：backwash。即isFull()会把下图右侧的也认为是full状态。解决办法：采取的解决办法是用两个并查集，多出来那个并查集只有上部的虚拟site，没有下部的。
3. percolation.java和percolationStat.java的空间复杂度都超了。percolation：开始没有使用两个并查集时没超，用了结果就超了，不过超的不多。这里面有一个int[][]，int是4个字节，改成了boolean[][]，结果就不超了。对于percolationStat，超内存超了600多倍...猜测是我把一个临时变量定义成了全局的，所以在多次测试时，gc没有回收掉。后来每次使用后，将这个临时的引用赋值为null就好了。实际上，不应该使用全局，既然是临时变量，只需要在更小的作用域里声明就行了。

 

代码：

import edu.princeton.cs.algs4.WeightedQuickUnionUF;

public class Percolation {
    private WeightedQuickUnionUF UF;
    private WeightedQuickUnionUF UF1;
    private boolean[][] grid;
    private int N;

    // create N-by-N grid, with all sites blocked
    public Percolation(int N) {
        if (N < 1) {
            throw new java.lang.IllegalArgumentException();
        }
        this.N = N;
        grid = new boolean[N + 1][N + 1];
        UF = new WeightedQuickUnionUF(N * N + 2);
        UF1 = new WeightedQuickUnionUF(N * N + 1);
    }

    // open site (row i, column j) if it is not open already
    public void open(int i, int j) {
        if (i < 1 || j < 1 || i > N || j > N) {
            throw new java.lang.IndexOutOfBoundsException();
        }
        if (!grid[i][j]) {
            if (i == 1) {
                UF.union(0, j);
                UF1.union(0, j);
            }
            if (i == N) {
                UF.union(N * N + 1, (i - 1) * N + j);
            }
            grid[i][j] = true;
            // judge whether this is full or not
            // left
            if (j > 1) {
                if (isOpen(i, j - 1)) {
                    UF.union((i - 1) * N + j, (i - 1) * N + j - 1);
                    UF1.union((i - 1) * N + j, (i - 1) * N + j - 1);
                }
            }
            // right
            if (j < N) {
                if (isOpen(i, j + 1)) {
                    UF.union((i - 1) * N + j, (i - 1) * N + j + 1);
                    UF1.union((i - 1) * N + j, (i - 1) * N + j + 1);
                }
            }
            // up
            if (i > 1) {
                if (isOpen(i - 1, j)) {
                    UF.union((i - 1) * N + j, (i - 1 - 1) * N + j);
                    UF1.union((i - 1) * N + j, (i - 1 - 1) * N + j);
                }
            }
            // down
            if (i < N) {
                if (isOpen(i + 1, j)) {
                    UF.union((i - 1) * N + j, (i + 1 - 1) * N + j);
                    UF1.union((i - 1) * N + j, (i + 1 - 1) * N + j);
                }
            }
        }
    }

    // is site (row i, column j) open?
    public boolean isOpen(int i, int j) {
        if (i < 1 || j < 1 || i > N || j > N) {
            throw new java.lang.IndexOutOfBoundsException();
        }
        if (grid[i][j]) {
            return true;
        }
        return false;
    }

    // is site (row i, column j) full?
    public boolean isFull(int i, int j) {
        if (i < 1 || j < 1 || i > N || j > N) {
            throw new java.lang.IndexOutOfBoundsException();
        }
        if (grid[i][j])
            if (UF1.connected(0, (i - 1) * N + j)) {
                return true;
            }
        return false;
    }

    // does the system percolate?
    public boolean percolates() {
        return UF.connected(0, N * N + 1);
    }

    // test client (optional)
    public static void main(String[] args) {
    }
}

import edu.princeton.cs.algs4.StdIn;
import edu.princeton.cs.algs4.StdRandom;
import edu.princeton.cs.algs4.StdStats;

public class PercolationStats {
    private double[] results;
    private double mean;
    private double stddev;
    private double confidenceLo;
    private double confidenceHi;
    private Percolation perc;

    // perform T independent experiments on an N-by-N grid
    public PercolationStats(int N, int T) {
        if (N < 1 || T < 1) {
            throw new java.lang.IllegalArgumentException();
        }
        results = new double[T];
        for (int i = 0; i < T; i++) {
            perc = new Percolation(N);
            int result = 0;
            while (!perc.percolates()) {
                int x = StdRandom.uniform(N) + 1;
                int y = StdRandom.uniform(N) + 1;
                while (perc.isOpen(x, y)) {
                    x = StdRandom.uniform(N) + 1;
                    y = StdRandom.uniform(N) + 1;
                }
                perc.open(x, y);
                result++;
            }
            perc = null;
            results[i] = result / (N * N * 1.0);
        }
        mean = StdStats.mean(results);
        stddev = StdStats.stddev(results);
        confidenceLo = mean - 1.96 * stddev / Math.sqrt(T);
        confidenceHi = mean + 1.96 * stddev / Math.sqrt(T);
    }

    // sample mean of percolation threshold
    public double mean() {
        return mean;
    }

    // sample standard deviation of percolation threshold
    public double stddev() {
        return stddev;
    }

    // low endpoint of 95% confidence interval
    public double confidenceLo() {
        return confidenceLo;
    }

    // high endpoint of 95% confidence interval
    public double confidenceHi() {
        return confidenceHi;
    }

    // test client (described below)
    public static void main(String[] args) {
        int N = StdIn.readInt();
        int T = StdIn.readInt();
        PercolationStats unittest = new PercolationStats(N, T);
        System.out.println("mean                    = " + unittest.mean());
        System.out.println("stddev                  = " + unittest.stddev());
        System.out.println("95% confidence interval = "
                + unittest.confidenceLo() + ", " + unittest.confidenceHi());

    }
}

下面是提交结果 :)