Programming Assignment 1: Percolation

最新推荐文章于 2021-07-28 10:25:11 发布
最新推荐文章于 2021-07-28 10:25:11 发布
阅读量1.9k 收藏 2
点赞数
分类专栏： Coursera Algorithms 文章标签： Coursera Algorithms Princeton
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangyuzuishuai/article/details/58664228
版权

Percolation

实现Percolation模型。
用蒙特卡罗模拟估计渗滤阈值的值。

关于backwash问题：有了一个虚拟底层位置，如果网格已经渗透了。这时判断其中一个位置（与底部相连，并且底部是打开的，与虚拟底层位置相连）是否满（即与虚拟顶层位置是相连的），那么不管这个位置是不是真的满，结果总会是满的。因为网格已经渗透了，那么虚拟顶层位置与虚拟底层位置总是相连的，而这个位置与虚拟顶层位置是相连的，这时候再判断它是不是满（与虚拟顶层位置相连），结果当然总是为真。
回流问题

这里提供了两种方法解决backwash，即回流问题

Percolation with top virtual site

即带有虚拟位置的网格。
同时需要建立两个WeightedQuickUnionUF 对象，一个同时有虚拟顶层位置和虚拟底层位置，这样判断是否渗透很容易。另一个只有虚拟顶层位置，这就避免了回流问题，用来判断是否满。
由于建立了两个WeightedQuickUnionUF 对象，所以 内存使用没有完全过关，得到了97分。

Percolation.java

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

/**
 * The {@code Percolation} class provides methods for calculating the Percolation. 
 * <p>
 * Creates two WeightedQuickUnionUF objects to solve the backwash problem.
 * 
 * @author zhangyu
 * @date 2017.2.27
 */
public class Percolation 
{
    private int size; // size of created grid
    private int[] status; // record the status of each site
    private WeightedQuickUnionUF grid;
    private WeightedQuickUnionUF gridNoVBottom;

    /**
     * Initializes two WeightedQuickUnionUF object. One has two 
     * virtual sites, and the other one has only one top site. 
     * Set state of each site blocked.
     * 
     * @param  n size of created grid
     * @throws IllegalArgumentException if n < 1
     */
    public Percolation(int n)
    {
        if (n < 1) throw new IllegalArgumentException("Grid size out of range");
        size = n;
        status = new int[n * n];
        for (int i = 0; i < n * n; i++) status[i] = 0;
        grid = new WeightedQuickUnionUF(n*n + 2);
        gridNoVBottom = new WeightedQuickUnionUF(n*n + 1);
    }

    /**
     * open site (row, col) if it is not open already.
     * 
     * @param row abscissa of the grid 
     * @param col ordinate of the grid
     */
    public void open(int row, int col)
    {
        int idx = xyTo1D(row, col);

        validate(row, col);
        status[idx] = 1;
        if (1 == row) // connect to the virtual site
        {
            grid.union(idx, size * size);
            gridNoVBottom.union(idx, size * size);
        }
        if (size == row) grid.union(idx, size*size + 1);

        int[] xDiff = {-1, 1, 0, 0};
        int[] yDiff = {0, 0, -1, 1};

        for (int i = 0; i < 4; i++)
        {
            int adjX = row + xDiff[i];
            int adjY = col + yDiff[i];

            if (adjX > 0 && adjX <= size)
            {
                if (adjY > 0 && adjY <= size)
                {
                    int adjPosIdx = xyTo1D(adjX, adjY);
                    if (1 == status[adjPosIdx])
                    {
                        grid.union(idx, adjPosIdx);
                        gridNoVBottom.union(idx, adjPosIdx);
                    }
                }
            }
        }
    }

    /**
     * Determine whether the site (row, col) is open.
     * 
     * @param row abscissa of the grid 
     * @param col ordinate of the grid
     * @return true if the site (row, col) is open;
     *         false otherwise
     */
    public boolean isOpen(int row, int col)
    {
        validate(row, col);
        return status[xyTo1D(row, col)] == 1;
    }

    /**
     * Determine whether the site (row, col) is full.
     * 
     * @param row abscissa of the grid 
     * @param col ordinate of the grid
     * @return true if the site (row, col) is full;
     *         false otherwise
     */
    public boolean isFull(int row, int col)
    {
        validate(row, col);
        return isOpen(row, col) && gridNoVBottom.connected(xyTo1D(row, col), size * size);
    }

    /**
     * Returns the number of open sites.
     * 
     * @return the number of open sites
     */
    public int numberOfOpenSites()
    {
        int sum = 0;

        for (int i = 0; i < status.length; i++) sum += status[i];
        return sum;
    }

    /**
     * Determine whether the grid percolates.
     * 
     * @return true if the grid percolates.
     *         false otherwise
     */
    public boolean percolates()
    {
        return grid.connected(size * size, size*size + 1);
    }

    //map 2D coordinates to 1D coordinates 
    private int xyTo1D(int row, int col)
    {
        return (row - 1)*size + col - 1;
    }

    // validate that (row, col) is valid
    private void validate(int row, int col)
    {
        if (row < 1 || row > size || col < 1 || col > size) 
            throw new IndexOutOfBoundsException("index: (" + row + ", " + col + ") are out of bounds");
    }

    /**
     * Unit tests the {@code Percolation} data type.
     *
     * @param args the command-line arguments
     */
    public static void main(String[] args)
    {
        int n = StdIn.readInt();
        Percolation client = new Percolation(n);
        while (!StdIn.isEmpty())
        {
            int row = StdIn.readInt();
            int col = StdIn.readInt();
            client.open(row, col);
            StdOut.println(client.isOpen(row, col));
            StdOut.println(client.isFull(row, col));
            StdOut.println(client.percolates());
        }
    }
}
ASSESSMENT SUMMARY

Compilation: PASSED
API: PASSED

Findbugs: PASSED
Checkstyle: FAILED (2 warnings)

Correctness: 26/26 tests passed
Memory: 5/8 tests passed
Timing: 9/9 tests passed

Aggregate score: 96.25%
[Compilation: 5%, API: 5%, Findbugs: 0%, Checkstyle: 0%, Correctness: 60%, Memory: 10%, Timing: 20%]

Percolation without virtual sites

不带虚拟位置的网格。
只建立一个WeightedQuickUnionUF 对象，没有虚拟位置。使用很多标签来判断打开，阻塞，与顶部相连，与底部相连和渗透这几种状态。当一个位置与顶部相连，就是满状态，当它既是与顶部相连，又是与底部相连，这个网格就是渗透的。在打开一个位置时，就同时更新他们的状态，如果相邻的位置是打开的，那么除了合并区域使它们相连，还要互相将状态进行或操作，即每个位置得到相邻位置的状态，为了使每个部分的位置的状态都能更新，就必须更新根位置的状态。
由于使用的是字节类型和或操作。所以内存使用的不多（少了一个WeightedQuickUnionUF 对象），得到了一个bonus:)，100分。

Percolation.java

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

/**
 * The {@code Percolation} class provides methods for calculating the Percolation.
 * <p>
 * Creates only one WeightedQuickUnionUF object to solve the backwash problem.
 * 
 * @author zhangyu
 * @date 2017.2.27
 */
public class Percolation 
{
    private static final byte BLOCKED         = Byte.valueOf("0"); // 00000000
    private static final byte OPEN            = Byte.valueOf("1"); // 00000001
    private static final byte TOPCONNECTED    = Byte.valueOf("2"); // 00000010
    private static final byte BOTTOMCONNECTED = Byte.valueOf("4"); // 00000100
    private static final byte PERCOLATED      = Byte.valueOf("7"); // 00000111
    private int size; // size of created grid
    private byte[] state; // record the state of each site
    private int openSites; // number of open sites
    private boolean percolate = false;
    private WeightedQuickUnionUF grid;

    /**
     * Initializes one WeightedQuickUnionUF object, without 
     * any virtual site. Set state of each site blocked.
     * 
     * @param  n size of created grid
     * @throws IllegalArgumentException if n < 1
     */
    public Percolation(int n) // create n-by-n grid, with all sites blocked
    {
        if (n < 1) throw new IllegalArgumentException("Grid size out of range");
        size = n;
        state = new byte[n * n];
        for (int i = 0; i < n * n; i++) state[i] = BLOCKED;
        grid = new WeightedQuickUnionUF(n * n);
    }

    /**
     * open site (row, col) if it is not open already.
     * 
     * @param row abscissa of the grid 
     * @param col ordinate of the grid
     */
    public void open(int row, int col)
    {
        validate(row, col);

        int idx = xyTo1D(row, col);
        int[] xDiff = {-1, 1, 0, 0};
        int[] yDiff = {0, 0, -1, 1};

        // if the site has been opened, then return
        if (0 != (state[idx] & OPEN)) return;
        state[idx] = (byte)(state[idx] | OPEN);
        if (1 == row)    state[idx] = (byte)(state[idx] | TOPCONNECTED);
        if (size == row) state[idx] = (byte)(state[idx] | BOTTOMCONNECTED);

        for (int i = 0; i < 4; i++)
        {
            int adjX = row + xDiff[i];
            int adjY = col + yDiff[i];

            if (adjX > 0 && adjX <= size)
            {
                if (adjY > 0 && adjY <= size)
                {
                    int adjSiteIdx = xyTo1D(adjX, adjY); // index of the adjacent site
                    int rootASIdx = grid.find(adjSiteIdx);

                    if (OPEN == (state[adjSiteIdx] & OPEN)) // if the adjacent site is open
                    {
                        state[idx] = (byte)(state[idx] | state[rootASIdx]);
                        grid.union(idx, adjSiteIdx); // union the two components
                    }
                }
            }
        }

        int rootIdx = grid.find(idx); // must get root index after union operation

        state[rootIdx] = (byte)(state[rootIdx] | state[idx]);
        if (PERCOLATED == (byte)(state[rootIdx] & PERCOLATED))
            percolate = true;
        openSites++;
    }

    /**
     * Determine whether the site (row, col) is open.
     * 
     * @param row abscissa of the grid 
     * @param col ordinate of the grid
     * @return true if the site (row, col) is open;
     *         false otherwise
     */
    public boolean isOpen(int row, int col)
    {
        validate(row, col);
        return OPEN == (state[xyTo1D(row, col)] & OPEN);
    }

    /**
     * Determine whether the site (row, col) is full.
     * 
     * @param row abscissa of the grid 
     * @param col ordinate of the grid
     * @return true if the site (row, col) is full;
     *         false otherwise
     */
    public boolean isFull(int row, int col)
    {
        validate(row, col);

        int rootIdx = grid.find(xyTo1D(row, col)); // root index of given site (row, col)
        return isOpen(row, col) && TOPCONNECTED == (state[rootIdx] & TOPCONNECTED);
    }

    /**
     * Returns the number of open sites.
     * 
     * @return the number of open sites
     */
    public int numberOfOpenSites()
    {
        return openSites;
    }

    /**
     * Determine whether the grid percolates.
     * 
     * @return true if the grid percolates.
     *         false otherwise
     */
    public boolean percolates()
    {
        return percolate;
    }

    //map 2D coordinates to 1D coordinates 
    private int xyTo1D(int row, int col)
    {
        return (row - 1)*size + col - 1;
    }

    // validate that (row, col) is valid
    private void validate(int row, int col)
    {
        if (row < 1 || row > size || col < 1 || col > size) 
            throw new IndexOutOfBoundsException("index: (" + row + ", " + col + ") are out of bounds");
    }

    /**
     * Unit tests the {@code Percolation} data type.
     *
     * @param args the command-line arguments
     */
    public static void main(String[] args)
    {
        int n = StdIn.readInt();
        Percolation client = new Percolation(n);

        while (!StdIn.isEmpty())
        {
            int row = StdIn.readInt();
            int col = StdIn.readInt();
            client.open(row, col);
            StdOut.println(client.isOpen(row, col));
            StdOut.println(client.isFull(row, col));
            StdOut.println(client.percolates());
        }
    }
}
ASSESSMENT SUMMARY

Compilation: PASSED
API: PASSED

Findbugs: PASSED
Checkstyle: FAILED (8 warnings)

Correctness: 26/26 tests passed
Memory: 9/8 tests passed
Timing: 9/9 tests passed   

Aggregate score: 101.25%  
[Compilation: 5%, API: 5%, Findbugs: 0%, Checkstyle: 0%, Correctness: 60%, Memory: 10%, Timing: 20%]

PercolationStats.java

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

/**
 * The {@code PercolationStats} class performs independent experiment, using 
 * the Percolation data structure. Then compute the mean and standard 
 * deviation of results.
 * <p>
 * It also provides method to compute confidence intervals for them.
 * 
 * @author zhangyu
 * @date 2017.2.27
 */
public class PercolationStats 
{
    private int trials;
    private double[] threshold;

    /**
     * perform trials independent experiments on an n-by-n grid
     * 
     * @param  n size of created grid
     * @param  trials times of experiments
     * @throws IllegalArgumentException unless
     *         both grid size and value of trials out of range
     */
    public PercolationStats(int n, int trials)
    {   
        if (n < 1) 
            throw new IllegalArgumentException("Grid size out of range");
        if (trials < 1) 
            throw new IllegalArgumentException("value of trials out of range");
        this.trials = trials;
        threshold = new double[trials];
        for (int i = 0; i < trials; i++)
        {
            Percolation expModel = new Percolation(n);

            while (!expModel.percolates())
            {
                int row = StdRandom.uniform(n) + 1;
                int col = StdRandom.uniform(n) + 1;

                expModel.open(row, col);
            }
            threshold[i] = (double)expModel.numberOfOpenSites() / (double)(n*n);
        }
    }

    /**
     * Returns the sample mean of percolation threshold.
     * 
     * @return the sample mean of percolation threshold
     */
    public double mean()
    {
        return StdStats.mean(threshold);
    }

    /**
     * Returns the sample standard deviation of percolation threshold.
     * 
     * @return the sample standard deviation of percolation threshold
     */
    public double stddev()
    {
        return StdStats.stddev(threshold);
    }

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

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

    /**
     * Unit tests the {@code PercolationStats} data type.
     *
     * @param args the command-line arguments
     */
    public static void main(String[] args)
    {
        int n, trials;

        n = StdIn.readInt();
        trials = StdIn.readInt();
        PercolationStats client = new PercolationStats(n, trials);
        StdOut.println("mean                    = " + client.mean());
        StdOut.println("stddev                  = " + client.stddev());
        StdOut.println("95% confidence interval = " + "[" + client.confidenceLo() + ", " 
                                                    + client.confidenceHi() + "]");
    }
}
参考我的github
5262yz
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Coursera算法课Programming Assignment 1: Percolation
aha_sogood的博客
02-11 392
Percolation 目标 通过蒙特卡洛模拟来计算 percolation threshold即渗滤阈值。 渗滤 percolation渗滤是一个由绝缘体和金属随机分布的复杂系统。那么它的金属分布在什么情况下会导致它是一个导体。科学家定义了一个抽象的被称作percolation的过程来为这些情况建模。 模型 这个模型被定义为一个n*n的方格来表示。方格site有两种状态：阻塞block和打开op...
Percolation(渗透)问题
tengyuan93的博客
09-06 9996
Percolation(渗透)问题@(算法) Coursera作业链接直接将马克飞象导出的md文件发到博客，排版不是很清晰，抱歉，可查看GitHub详细代码和文档实际问题：将一个不透水的均质方块分割为N*N，最上方为水源，随机打开方块中任意格子，重复此项操作多次，产生一条路径使水能穿过这个方块到达最下方。the modelpercolation系统使用n-n格点，每个格点site有open/blo
Programming 作业 Assignment 3
刘璐菲
11-27 362
作业要求以及moudle1-11以及翻译版的moudle 在百度网盘里 链接：https://pan.baidu.com/s/1rnAiWtB9J5VTMtoCS3P2hQ 提取码：dbje
Programming Assignment 7: Performance
lincs's blog
07-28 145
Here is the original link Ramanujan.java RevesPuzzle.java（汉诺塔问题的升级版，4根柱子的情况） public class Ramanujan { // Is n a Ramanujan number? public static boolean isRamanujan(long n) { int count = 0; for (long i = 1, n_3 = (long)Math
coursera算法课 Programming Assignment 1:Percolation
u011343730的博客
02-27 3832
这次算法作业的任务是通过蒙特卡洛模拟来计算 percolation threshold即渗滤阈值。 渗滤：percolation渗滤是一个由绝缘体和金属随机分布的复杂系统。那么它的金属分布在什么情况下会导致它是一个导体。科学家定义了一个抽象的被称作percolation的过程来为这些情况建模。 模型：这个模型被定义为一个n*n的方格来表示。方格site有两种状态：阻塞block和打开open。
Percolation 渗透算法
xiewen99的专栏
12-20 9819
Percolation 渗透算法
Percolation（渗透模型）普林斯顿算法课
梦在waterloo
09-24 1万+
第一周看完了，要完成percolation的编程作业。
ProgrammingAssignment2:Coursera的R作业2
05-26
介绍 第二项编程任务将要求您编写一个R函数，该函数能够缓存可能耗时的计算。 例如，取数值向量的平均值通常是快速的操作。 但是，对于非常长的向量，计算均值可能会花费太长时间，尤其是在必须重复计算（例如，在...
ProgrammingAssignment2:编程作业2
06-10
介绍第二个编程作业将要求您编写一个 R 函数，该函数能够缓存潜在的耗时计算。 例如，取数字向量的平均值通常是一种快速操作。 然而，对于一个很长的向量，计算均值可能需要很长时间，特别是如果它必须重复计算...
ProgrammingAssignment2:Coursera PA2
06-17
介绍第二个编程作业将要求您编写一个 R 函数，该函数能够缓存潜在的耗时计算。 例如，取数字向量的平均值通常是一种快速操作。 然而，对于一个很长的向量，计算均值可能需要很长时间，特别是如果它必须重复计算...
ProgrammingAssignment3:提交 GettingAndCleaningData 分配
06-10
run_analysis.R 的 README 说明 ##Use：要使用此脚本，请将 R 中的工作目录设置为“UCI HAR Dataset”目录。 工作目录必须包含文件“features.txt”、“activity_labels.txt”和子目录“train”和“test” 必须安装...
ProgrammingAssignment2:编程分配2
05-26
介绍 第二项编程任务将要求您编写一个R函数，该函数能够缓存可能耗时的计算。 例如，取数值向量的平均值通常是快速的操作。 但是，对于非常长的向量，计算均值可能会花费太长时间，尤其是在必须重复计算（例如，在...
渗流模型（Percolation ）
热门推荐
追求灵魂代码
09-27 1万+
1 标度行为 标度行为（Scaling）是现在复杂系统研究中的一个非常典型的现象，它体现为系统的若干宏观指标或者某个变量的分布函数满足具有不同幂指数的幂律行为。 也就是说，标度行为是一种现象，这种现象满足幂律分布。 2 渗流模型 2.1 什么是渗流？ 渗流是指流体在孔隙介质中的流动。 渗流状态，是指系统中出现一个大的集群，能够将这些集群节点的和邻居节点的边界打通、渗透（只考虑上下左右四个方向的邻...
Programming Assignment 1: Percolation代码
u013685323的专栏
05-13 5543
public class Percolation { private boolean[] NN; private int N; private WeightedQuickUnionUF WQUF; private WeightedQuickUnionUF WQUFBack; public Percolation(int N){ this.N = N; NN = new boo
普林斯顿算法课第一周作业
涂修竹的专栏
01-27 7760
Programming Assignment 1: Percolation 作业网址如下： http://coursera.cs.princeton.edu/algs4/assignments/percolation.html 正文 -------------------------------------------------------------- 第一章的作业需要制
R Programming Assignment 1
Jacky的博客
06-11 2883
Assignment: Air Pollution
Programming Assignment 1: Hello, World
lincs's blog
04-15 636
link HelloWorld.java public class HelloWorld{ public static void main(String[] args) { System.out.println("Hello, World"); } } HelloGoodbye.java public class HelloGoodbye{ public static void main(String[] args) { System.out.println("Hello " +
Programming Assignment 4: 8 puzzle
5262yz的博客
03-29 2649
8 puzzle 使用A*搜索算法解决8-puzzle问题。 Board.java Board类用来表示一个n∗nn∗nn*n的网格，其中有n2−1n2−1n^2-1个方块，每个从1标记到n2−1n2−1n^2-1，还有一个方块是空。 这里提供了计算Hamming距离和Manhattan距离的方法。也提供了计算其“双胞胎”Board的方法。 import java.util....
形式化方法 assignment 1: software setup
最新发布
08-03
在形式化方法的Assignment 1：软件设置中，我们需要完成软件的配置和安装。首先，我们需要一个支持形式化方法的集成开发环境（IDE），例如CoqIDE或Isabelle/jEdit。这些IDE提供了一个用户友好的界面，方便我们进行...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值