【<算法>从零开始】20190731-1

终于完成了Coursera第一周的内容 post一下第一周大作业Percolation的代码

import edu.princeton.cs.algs4.StdOut;
import edu.princeton.cs.algs4.WeightedQuickUnionUF;

public class Percolation {
    private int numofgrid;
    private boolean[] grid;
    private int gridlen;
    private WeightedQuickUnionUF virtualnode;
    private int numofopensites=0;
    // creates n-by-n grid, with all sites initially blocked
    public Percolation(int n){
        numofgrid = n*n;
        grid = new boolean[numofgrid];
        gridlen = n;
        virtualnode = new WeightedQuickUnionUF(numofgrid+2);
}
    private void boundary(int row, int col){
        if (row<=0 || col <=0 || row>gridlen || col>gridlen){
            throw new IllegalArgumentException("row or col out of boundary!");

        }
    }
    private int index2one(int row,int col){
        return (row-1)*gridlen+(col-1);
    }
    // opens the site (row, col) if it is not open already
    public void open(int row, int col) {
        boundary(row, col);
        int index = index2one(row, col);
        if (isOpen(row, col)) return;
        grid[index]=true;
        numofopensites++;

        int[] dx={1,-1,0,0};//default
        int[] dy={0,0,1,-1};//default
        if (row == 1) {
        virtualnode.union(index,numofgrid);
        }
        if (row==gridlen) {
            virtualnode.union(index,numofgrid+1);
    }
        if(col==1) {
            dy[3]=0;
        }
        if(row==1){
            dx[1]=0;
        }
        if(col==gridlen){
            dy[2]=0;
        }
        if(row==gridlen){
            dx[0]=0;
        }
        for(int i=0;i<4;i++){
            int row2 = row+dx[i];
            int col2 = col+dy[i];
            if(isOpen(row2,col2)) {
                virtualnode.union(index,index2one(row2,col2));
            }
        }   
    }
    // is the site (row, col) open?
    public boolean isOpen(int row, int col){
        boundary(row,col);
        return grid[index2one(row,col)];
    }

    // is the site (row, col) full?
    public boolean isFull(int row, int col){
        boundary(row,col);
        return virtualnode.connected(index2one(row,col),numofgrid);
    }

    // returns the number of open sites
    public int numberOfOpenSites(){
        return numofopensites;
    }

    // does the system percolate?
    public boolean percolates(){
        return virtualnode.connected(numofgrid+1,numofgrid);
    }

    // test client (optional)
    public static void main(String[] args){
        Percolation p = new Percolation(5);

        p.open(1,1);
        StdOut.println(p.numberOfOpenSites());
        p.open(2,2);
        p.open(3,3);
        p.open(2,1);
        p.open(3,2);
        p.open(4,3);
        p.open(5,3);
        StdOut.println(p.numberOfOpenSites());
        StdOut.println(p.percolates());
    }
}


import edu.princeton.cs.algs4.StdStats;
public class PercolationStats {
private int gridlen;
private int trialnum;
private double[] pstar;
// perform independent trials on an n-by-n grid
public PercolationStats(int n, int trials){
    gridlen=n;
    trialnum=trials;
    pstar = new double[trials];
    if(gridlen<1 || trialnum<1){throw new IllegalArgumentException("arguments out of range!");
}
    for (int i=0;i<trialnum;i++){
        Percolation p = new Percolation(gridlen);
        while(!p.percolates()){
            int row = StdRandom.uniform(gridlen)+1;
            int col = StdRandom.uniform(gridlen)+1;
            p.open(row,col);
        }
        pstar[i]=(double)p.numberOfOpenSites()/(gridlen*gridlen);
    }

    }

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

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

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

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

// test client (see below)
public static void main(String[] args){
    int n =10,trialNum=1000;
    PercolationStats ps=new PercolationStats(n,trialNum);
    StdOut.println("grid size :" + n+"*"+n);
    StdOut.println("trial times :" + trialNum);
    StdOut.println("mean of p :"+ ps.mean());
    StdOut.println("standard deviation :"+ps.stddev());
    StdOut.println("confidence interval low :"+ps.confidenceLo());
    StdOut.println("confidence interval high :"+ps.confidenceHi());
    }

}

因为赶ddl没改成考虑backwash的情况 可能也因为这个原因只得了90分 之后有时间改一下吧 暂时可以开始第二周的内容了 stack and queues