对于《Algorithms》这门课，如果想做一做这里面的Assignment，首先必须要到他的官方网站下面下载一些jar文件，链接如下：http://algs4.cs.princeton.edu/home/。应用它提供的很多库函数以及实例代码，可以帮助我们简化编程题目的难度。

题目

Programming Assignment 1: Percolation

Write a program to estimate the value of the percolationthreshold via Monte Carlo simulation.

Percolation. Given a composite systems comprised ofrandomly distributed insulating and metallic materials: whatfraction of the materials need to be metallic so that the compositesystem is an electrical conductor? Given a porous landscape withwater on the surface (or oil below), under what conditions will thewater be able to drain through to the bottom (or the oil to gushthrough to the surface)? Scientists have defined an abstractprocess known aspercolation to model such situations.

The model. We model a percolation system using anN-by-N grid ofsites. Each site iseitheropen or blocked. A full site isan open site that can be connected to an open site in the top rowvia a chain of neighboring (left, right, up, down) open sites. Wesay the systempercolates if there is a full site in thebottom row. In other words, a system percolates if we fill all opensites connected to the top row and that process fills some opensite on the bottom row. (For the insulating/metallic materialsexample, the open sites correspond to metallic materials, so that asystem that percolates has a metallic path from top to bottom, withfull sites conducting. For the porous substance example, the opensites correspond to empty space through which water might flow, sothat a system that percolates lets water fill open sites, flowingfrom top to bottom.)

The problem. In a famous scientific problem, researchersare interested in the following question: if sites areindependently set to be open with probabilityp (andtherefore blocked with probability 1 −p), what is theprobability that the system percolates? Whenp equals 0,the system does not percolate; whenp equals 1, the systempercolates. The plots below show the site vacancy probabilityp versus the percolation probability for 20-by-20 randomgrid (left) and 100-by-100 random grid (right).

            

When N is sufficiently large, there is athreshold value p* such that when p <p* a random N-by-N grid almost neverpercolates, and whenp >p*, a randomN-by-N grid almost always percolates. Nomathematical solution for determining the percolation thresholdp* has yet been derived. Your task is to write a computerprogram to estimatep*.

Percolation data type. To model a percolation system,create a data typePercolation with the following API:

public class Percolation {   public Percolation(int N)              // create N-by-N grid, with all sites blocked   public void open(int i, int j)         // open site (row i, column j) if it is not already   public boolean isOpen(int i, int j)    // is site (row i, column j) open?   public boolean isFull(int i, int j)    // is site (row i, column j) full?   public boolean percolates()            // does the system percolate?}

By convention, the indices i and j are integersbetween 1 and N, where (1, 1) is the upper-left site:Throw a java.lang.IndexOutOfBoundsException if eitheri orj is outside this range. The constructorshould take time proportional to N^2; all methods should takeconstant time plus a constant number of calls to the union-findmethodsunion(), find(), connected(),andcount().

Monte Carlo simulation. To estimate the percolationthreshold, consider the following computational experiment:

• Initialize all sites to be blocked.
• Repeat the following until the system percolates:
  • Choose a site (row i, column j) uniformly atrandom among all blocked sites.
  • Open the site (row i, column j).
• The fraction of sites that are opened when the systempercolates provides an estimate of the percolation threshold.

For example, if sites are opened in a 20-by-20 lattice accordingto the snapshots below, then our estimate of the percolationthreshold is 204/400 = 0.51 because the system percolates when the204th site is opened.

50 open sites

100 open sites

150 open sites

204 open sites

By repeating this computation experiment T times andaveraging the results, we obtain a more accurate estimate of thepercolation threshold. Letx_t be the fractionof open sites in computational experimentt. The samplemean μ provides an estimate of the percolation threshold; thesample standard deviation σ measures the sharpness of thethreshold.

Assuming T is sufficiently large (say, at least 30), thefollowing provides a 95% confidence interval for the percolationthreshold:

To perform a series of computational experiments, create a datatype PercolationStats with the following API.

public class PercolationStats {   public PercolationStats(int N, int T)    // perform T independent computational experiments on an N-by-N grid   public double mean()                     // sample mean of percolation threshold   public double stddev()                   // sample standard deviation of percolation threshold   public double confidenceLo()             // returns lower bound of the 95% confidence interval   public double confidenceHi()             // returns upper bound of the 95% confidence interval   public static void main(String[] args)   // test client, described below}

The constructor should throw ajava.lang.IllegalArgumentException if eitherN ≤0 orT ≤ 0.

Also, include a main() method that takes twocommand-line arguments N andT, performsT independent computational experiments (discussed above)on anN-by-N grid, and prints out the mean,standard deviation, and the95% confidence interval forthe percolation threshold. Use standard random from ourstandard libraries to generate random numbers; usestandardstatistics to compute the sample mean and standarddeviation.

% java PercolationStats 200 100mean                    = 0.5929934999999997stddev                  = 0.0087699042155256795% confidence interval = 0.5912745987737567, 0.5947124012262428% java PercolationStats 200 100mean                    = 0.592877stddev                  = 0.00999052371707379995% confidence interval = 0.5909188573514536, 0.5948351426485464% java PercolationStats 2 10000mean                    = 0.666925stddev                  = 0.1177653652103355895% confidence interval = 0.6646167988418774, 0.6692332011581226% java PercolationStats 2 100000mean                    = 0.6669475stddev                  = 0.11775205263262094
95% confidence interval = 0.666217665216461, 0.6676773347835391

分析

这道题看起来难度不大，但是实际上做的时候还是需要想一想的。首先的问题就是，这是一个蓄水问题，而不是图连接问题，如何将蓄水问题转换为图连接问题呢？我的方法是这样的：
（1）Open一个Site
（2）分别检查Open的这个Site的上下左右是不是也有Open的Site
        如果有，那么将这两个Open的Site链接起来
   这样一来，题目就简单多了。

第二个问题是，如何用提供的API，模拟一个N*N的蓄水池呢？方法肯定是坐标转换，我的方法是将每个i,j的Site表示为一维数组中的i*N+j，那么这个N*N的蓄水池起始点为1*N+1，终止点为N*N+N。先把0*N+1到0*N+N以及（N+1）*N+1到（N*1）*N+N链接起来，这样的好处就是：我们检查是否percolates的条件就是看0*N+1,(N+1)*N+1这两个点是否Connected就行了。如果不这么做，我们需要循环检查所有0*N+1到0*N+N以及（N+1）*N+1到（N*1）*N+N是否Connected。

第三个问题，也是我一直纠结的问题，就是所谓Backwash问题。什么叫做Backwash问题呢？下面一个图可以很好地解释这个情况：

也就是说，当我们的蓄水池已经percolate了以后，那么所有和最底边联通的Site也会和有水的地方connected。在课程上面，还没有一种不增加存储复杂度的前提下，在上面的模型中解决这一问题，唯一的解决方法是由Callum Noble提出的，原文如下：
A simple solution would be to maintain 2 data structures - onewhich has a hidden top and bottom and one which has a hidden toponly. In the interest of promoting discussion I'll not say exactlywhat these could be would be used for and how this solves thebackwash problem.

OK，这就是所有的问题了。

代码

1. Percolation.java

public class Percolation {private WeightedQuickUnionUF uf;private WeightedQuickUnionUF uf_backwash;private int N;private boolean[] arrayOpen;// create N-by-N grid, with all sites blockedpublic Percolation(int N){this.N = N;uf = new WeightedQuickUnionUF((N+1)*(N)+N+1);uf_backwash = new WeightedQuickUnionUF(N*N+N+1);arrayOpen = new boolean[(N+1)*(N)+N+1];for (int i=1; i<=N; i++){uf.union(0*N+1, 0*N+i);uf_backwash.union(0*N+1, 0*N+i);arrayOpen[0*N+i] = true;uf.union((N+1)*N+1, (N+1)*N+i);arrayOpen[(N+1)*N+i] = true;}}// open site (row i, column j) if it is not alreadypublic void open(int i, int j){if (i < 1 || i > N){throw new IndexOutOfBoundsException("row index " + i + " out of bounds");}if (j < 1 || j > N){throw new IndexOutOfBoundsException("row index " + j + " out of bounds");}if (arrayOpen[i*N+j]){return;}arrayOpen[i*N+j] = true;if (arrayOpen[(i-1)*N+j]){uf.union(i*N+j, (i-1)*N+j);uf_backwash.union(i*N+j, (i-1)*N+j);}if (arrayOpen[(i+1)*N+j]){uf.union(i*N+j, (i+1)*N+j);if (i!=N){uf_backwash.union(i*N+j, (i+1)*N+j);}}if (j!=1 && arrayOpen[i*N+j-1]){uf.union(i*N+j, i*N+j-1);uf_backwash.union(i*N+j, i*N+j-1);}if (j!=N && arrayOpen[i*N+j+1]){uf.union(i*N+j, i*N+j+1);uf_backwash.union(i*N+j, i*N+j+1);}}// is site (row i, column j) open?public boolean isOpen(int i, int j){if (i <1 || i > N){throw new IndexOutOfBoundsException("row index " + i + " out of bounds");}if (j < 1 || j > N){throw new IndexOutOfBoundsException("row index " + j + " out of bounds");}return arrayOpen[i*N+j];}// is site (row i, column j) full?public boolean isFull(int i, int j){if (i <1 || i > N){throw new IndexOutOfBoundsException("row index " + i + " out of bounds");}if (j < 1 || j > N){throw new IndexOutOfBoundsException("row index " + j + " out of bounds");}return uf_backwash.connected(i*N+j, 0*N+1) && arrayOpen[i*N+j];}// does the system percolate?public boolean percolates(){return uf.connected(0*N+1, (N+1)*N+1);}
}

2. PercolationStats.java

public class PercolationStats {private double recT[];private double res_mean;private double res_stddev;private int N;// perform T independent computational experiments on an N-by-N gridpublic PercolationStats(int N, int T){recT = new double[T];this.N = N;int times = 0;if (N <= 0){throw new IllegalArgumentException();}if (T <= 0){throw new IllegalArgumentException();}while (times < T){Percolation percolation = new Percolation(N);boolean[][] arrOpen = new boolean[N+1][N+1];int count = 0;while(true){count++;while(true){int x = StdRandom.uniform(N) + 1;int y = StdRandom.uniform(N) + 1;if (arrOpen[x][y]){continue;}else{percolation.open(x, y);arrOpen[x][y] = true;break;}}if (percolation.percolates()){recT[times] = (double)count / ((double)N * (double)N);break;}}times++;}this.res_mean = StdStats.mean(recT);this.res_stddev = StdStats.stddev(recT);}// sample mean of percolation thresholdpublic double mean(){return this.res_mean;}// sample standard deviation of percolation thresholdpublic double stddev(){return this.res_stddev;}// returns lower bound of the 95% confidence intervalpublic double confidenceLo(){return this.res_mean - 1.96*this.res_stddev / Math.sqrt(N);}// returns upper bound of the 95% confidence intervalpublic double confidenceHi(){return this.res_mean + 1.96*this.res_stddev / Math.sqrt(N);}// test client, described belowpublic static void main(String[] args){int N = StdIn.readInt();int T = StdIn.readInt();PercolationStats percolationStats = new PercolationStats(N, T);StdOut.println("mean = " + percolationStats.mean());StdOut.println("stddev = " + percolationStats.stddev());StdOut.println("95% confidence interval " + percolationStats.confidenceLo() + ", " + percolationStats.confidenceHi());}
}