Coursera Algorithms Programming Assignment 1: Percolation（100分）

題目來源http://coursera.cs.princeton.edu/algs4/assignments/percolation.html

作業分為兩部分：建立模型和仿真實驗。

最關鍵的部分就是建立模型對象。模型對象要求如下：

The model.  We model a percolation system using an n-by-n grid of sites. Each site is either open or blocked. A full site is an open site that can be connected to an open site in the top row via a chain of neighboring (left, right, up, down) open sites. We say the system percolates if there is a full site in the bottom row. In other words, a system percolates if we fill all open sites connected to the top row and that process fills some open site on the bottom row. (For the insulating/metallic materials example, the open sites correspond to metallic materials, so that a system that percolates has a metallic path from top to bottom, with full sites conducting. For the porous substance example, the open sites correspond to empty space through which water might flow, so that a system that percolates lets water fill open sites, flowing from top to bottom.)

 

邊界要求：  By convention, the row and column indices are integers between 1 and  n, where (1, 1) is the upper-left site: Throw a  java.lang.IllegalArgumentException if any argument to  open(),  isOpen(), or  isFull() is outside its prescribed range. The constructor should throw a  java.lang.IllegalArgumentException if  n ≤ 0.

 

性能要求：   The constructor should take time proportional to  n2; all methods should take constant time plus a constant number of calls to the union–find methods  union(),  find(),  connected(), and  count().

我的分析

本次作業根據教授在視頻課上提示，可以在grid的上方和下方各加入一個虛節點，grid第一行的open節點都與top虛節點連通，grid最后一行的open節點都與bottom虛節點連通。這樣只需判斷top虛節點與bottom虛節點是否連通就知道grid是否滲透，而不需要去一一選取特定節點比對了。照着這個思路，我實現了下述模型代碼。值得注意的是，模型代碼的main中測試方法不是僅僅進行各本地測試就可以了，提交作業的時候會進行自動腳本測試，所以提交的版本main方法中必須讀取args[0]中的文件名，並加載文件內容進行生成grid和open對應的site。

import edu.princeton.cs.algs4.In;
import edu.princeton.cs.algs4.StdOut;
import edu.princeton.cs.algs4.WeightedQuickUnionUF;
/**
 * @author evasean www.cnblogs.com/evasean/
 */
public class Percolation {
    private static final boolean BLOCK = false; // block state
    private static final boolean OPEN = true; // open state

    /* topUF bottomUF n 均為final是因為它們只在構造函數時初始化，后續其值未發生變化 */
    private final WeightedQuickUnionUF topUF; // 用來記錄與top虛節點的連通性
    private final WeightedQuickUnionUF bottomUF;// 用來記錄與bottom虛節點的連通性
    private final int n;

    private boolean[][] grid;
    private boolean percolateFlag = false; // grid是否滲透的標志
    private int openedNum = 0;// 已經open的site數目

    public Percolation(int n) {
        // create n-by-n grid, with all sites blocked
        if (n < 1)
            throw new IllegalArgumentException("grid size should be bigger than one !");
        this.n = n;
        topUF = new WeightedQuickUnionUF(n * n + 1); // 多了一個節點的空間，位置n*n處用來代表虛節點
        bottomUF = new WeightedQuickUnionUF(n * n + 1); // 多了一個節點的空間，位置n*n處用來代表虛節點
        grid = new boolean[n][n];
        // 初始化grid設為block
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                grid[i][j] = BLOCK;
    }

    private void validate(int row, int col) {
        if (row < 1 || col < 1 || row > n || col > n)
            throw new IllegalArgumentException("input row or col is not illegal!");
    }

    public void open(int row, int col) {
        // open site (row, col) if it is not open already
        validate(row, col);
        if (grid[row - 1][col - 1] == OPEN)
            return;

        grid[row - 1][col - 1] = OPEN;
        openedNum++;

        // n為1時，open一個節點就達到滲透要求
        if (n == 1) {
            topUF.union(0, 1);
            bottomUF.union(0, 1);
            percolateFlag = true;
            return;
        }

        // 第一行的所有節點都與top虛節點連通
        if (row == 1)
            topUF.union(n * n, col - 1);

        // 最后一行的所有節點都與bottom虛節點連通
        if (row == n)
            bottomUF.union(n * n, (n - 1) * n + col - 1);

        // 與上方節點的連通性
        if (row > 1 && grid[row - 2][col - 1] == OPEN) {
            topUF.union((row - 2) * n + col - 1, (row - 1) * n + col - 1);
            bottomUF.union((row - 2) * n + col - 1, (row - 1) * n + col - 1);
        }

        // 與下方節點的連通性
        if (row < n && grid[row][col - 1] == OPEN) {
            topUF.union(row * n + col - 1, (row - 1) * n + col - 1);
            bottomUF.union(row * n + col - 1, (row - 1) * n + col - 1);
        }

        // 與左側節點的連通性
        if (col > 1 && grid[row - 1][col - 2] == OPEN) {
            topUF.union((row - 1) * n + col - 2, (row - 1) * n + col - 1);
            bottomUF.union((row - 1) * n + col - 2, (row - 1) * n + col - 1);
        }

        // 與右側節點的連通性
        if (col < n && grid[row - 1][col] == OPEN) {
            topUF.union((row - 1) * n + col, (row - 1) * n + col - 1);
            bottomUF.union((row - 1) * n + col, (row - 1) * n + col - 1);
        }

        /*
         * 判斷條件!percolateFlag是為了防止滲透以后的重復判斷 判斷條件openedNum>=n
         * 是因為openedNum達到n時才有可能滲透，在未達到n之前，不需要進行后續判斷
         * 一個節點open的時候剛好使grid滲透的條件是該節點同時與top虛節點和bottom虛節點連通
         */
        if (!percolateFlag && openedNum >= n && topUF.connected(n * n, (row - 1) * n + col - 1)
                && bottomUF.connected(n * n, (row - 1) * n + col - 1))
            percolateFlag = true;

    }

    public boolean isOpen(int row, int col) {
        // is site (row, col) open?
        validate(row, col);
        return grid[row - 1][col - 1] == OPEN;
    }

    /**
     * 一個節點只有同時在open狀態並且與top虛節點連通時才是full狀態
     * @param row
     * @param col
     * @return
     */
    public boolean isFull(int row, int col) {
        // is site (row, col) full?
        validate(row, col);
        if (isOpen(row, col) && topUF.connected(n * n, (row - 1) * n + col - 1))
            return true;
        else
            return false;
    }

    public int numberOfOpenSites() {
        // number of open sites
        return openedNum;
    }

    public boolean percolates() {
        // does the system percolate?
        return percolateFlag;
    }

    //打印一些便於查看的信息
    private void printCheckResult(int row, int col) {
        StdOut.println("p(" + row + "," + col + ") is open=" + isOpen(row, col) + ";is full=" + isFull(row, col)
                + ";percolates=" + percolates());
    }

    /**
     * 作業提交時main需要調用該方法，因為提交后在線腳本要用一堆input文件進行測試
     * 
     * @param arg0
     */
    private static void fileInputCheck(String arg0) {
        // test client (optional)
        In in = new In(arg0);//讀入input文件名，並加載文件內容
        String s = null;
        int n = -1;
        //讀入grid的n
        while (in.hasNextLine()) {
            s = in.readLine();
            if (s != null && !s.trim().equals(""))
                break;
        }
        s = s.trim();
        n = Integer.parseInt(s);
        Percolation p = new Percolation(n);
        
        //讀入open的site坐標
        while (in.hasNextLine()) {
            s = in.readLine();
            if (s != null && !s.trim().equals("")) {
                s = s.trim();//去掉輸入字符串頭尾空格
                String[] sa = s.split("\\s+");//去掉中間所有空格
                if (sa.length != 2)
                    break;
                int row = Integer.parseInt(sa[0]);
                int col = Integer.parseInt(sa[1]);
                p.open(row, col);
            }
        }

    }

    /**
     * 本地測試專用
     */
    private static void generateCheck() {
        // test client (optional)
        Percolation p = new Percolation(3);
        int row = 1, col = 3;
        p.open(row, col);
        p.printCheckResult(row, col);
        row = 2;
        col = 3;
        p.open(row, col);
        p.printCheckResult(row, col);
        row = 3;
        col = 3;
        p.open(row, col);
        p.printCheckResult(row, col);
        row = 3;
        col = 1;
        p.open(row, col);
        p.printCheckResult(row, col);
        row = 2;
        col = 1;
        p.open(row, col);
        p.printCheckResult(row, col);
        row = 1;
        col = 1;
        p.open(row, col);
        p.printCheckResult(row, col);
    }

    public static void main(String[] args) {
        //generateCheck();
        fileInputCheck(args[0]);
    }
}

 

仿真分析這一部分比較簡單，其中需要注意的地方就是“隨機選取row和col進行open”，如果簡單的用random(int n)，選取[0,n)獲取row和col，會有很多重復節點被選中，隨着n越大，命中率就越低。於是我采用生成一個[0,n*n)的數組，數組內容隨機排序，依次讀取數組內容，就相當於隨機取site。

import edu.princeton.cs.algs4.StdOut;
import edu.princeton.cs.algs4.StdRandom;
import edu.princeton.cs.algs4.StdStats;
/**
 * @author evasean www.cnblogs.com/evasean/
 */
public class PercolationStats {
    /* t fractions 均為final是因為它們只在構造函數時初始化，后續其值未發生變化*/
    private final int t;//嘗試次數
    private final double[] fractions;//每一次嘗試的滲透率得分
    
    private double mean;
    private double stddev;

    public PercolationStats(int n, int trials) {
        // perform trials independent experiments on an n-by-n grid
        if (n <= 0 || trials <= 0)
            throw new IllegalArgumentException("n ≤ 0 or trials ≤ 0");
        t = trials;
        fractions = new double[t];
        for (int i = 0; i < t; i++) {//t次嘗試
            Percolation p = new Percolation(n);
            int openNum = 0;
             //為了實現隨機open一個site，模仿QuickUnion的定位方法
            //先生成一個[0,n*n)的數組，數組內容隨機排序,依次讀取數組內容，就相當於隨機取site
            int[] rand = StdRandom.permutation(n * n);
            for (int pos : rand) {
                //pos = (row-1)*n + col -1
                int row = pos / n + 1; 
                int col = pos % n + 1;
                p.open(row, col);
                openNum++;
                //只有openNum>=n時才有判斷是否滲透的必要
                if (openNum >= n && p.percolates())
                    break;
            }
            double pt = (double) openNum / (n * n);//單次嘗試的滲透率
            fractions[i] = pt;
        }
        /* 作業提交時的某個測試案例要求mean()、stddev()、confidenceLo()、confidenceHi()
         * 在任何時候任何次序調用的情況下都必須返回相同的值，故需要在構造函數中計算mean和stddev
         */
        //作業提交時的某個測試案例要調用一次StdStats.mean方法
        mean = StdStats.mean(fractions);
        //作業提交時的某個測試案例要求要調用一次StdStats.stddev方法
        stddev = StdStats.stddev(fractions);
    }

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

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

    public double confidenceLo() {
        // low endpoint of 95% confidence interval
        return mean - 1.96 * stddev / Math.sqrt(t);
    }

    public double confidenceHi() {
        // high endpoint of 95% confidence interval
        return mean + 1.96 * stddev / Math.sqrt(t);
    }

    public static void main(String[] args) {
        // test client (described below)
        int n = Integer.parseInt(args[0]);
        int t = Integer.parseInt(args[1]);
        PercolationStats ps = new PercolationStats(n, t);
        StdOut.printf("%-25s %s %f \n", "means", "=", ps.mean());
        StdOut.printf("%-25s %s %f \n", "stddev", "=", ps.stddev());
        StdOut.printf("%-25s %s%f%s%f%s\n", "95% confidence interval", "= [", ps.confidenceLo(), ", ",
                ps.confidenceHi(), "]");
    }
}