看的见得算法 第三章 概率模拟算法

1.一个有意思的分钱模拟问题

AlgoFrame.java中

在render方法中设置数据

  // TODO: 设置自己的数据
    int[] money;
    public void render(int[] money){
        this.money = money;
        repaint();
    }

绘制方法paintComponent中

int w = canvasWidth / money.length;//每一个小矩形的宽度
            for(int i = 0 ; i < money.length ; i ++)//左上角XY坐标，宽度，高
                AlgoVisHelper.fillRectangle(g2d,
                        i*w+1, canvasHeight-money[i], w-1, money[i]);

AlgoVisualize.java

设置初始每个人100元

        // TODO: 初始化数据
        money = new int[100];
        for(int i = 0; i < money.length; i++){
            money[i] = 100;
        }

每一轮第i个人给随机一个人1块钱

 // 动画逻辑
    private void run(){
        while(true) {
            // TODO: 编写自己的动画逻辑
            frame.render(money);
            AlgoVisHelper.pause(1);
            for (int i = 0; i < money.length; i++) {
                if (money[i] > 0) {
                    int j = (int) (Math.random() * money.length);
                    money[i] -= 1;
                    money[j] += 1;
                }
            }
        }
    }

2.深入随机分钱问题

加快速度，计算50次后再render显示。

            for(int k = 0; k< 50; k++){
                for (int i = 0; i < money.length; i++) {
                    if (money[i] > 0) {
                        int j = (int) (Math.random() * money.length);
                        money[i] -= 1;
                        money[j] += 1;
                    }
                }
            }

考虑有人的钱为负数。

当钱为正数,x坐标不变，y坐标为panel面板高度的1/2减去钱，宽度为w减去间隔1，高是钱money[i]

当钱为正数,x坐标不变，y坐标为panel面板高度的1/2，宽度为w减去间隔1，高是钱-money[i]

int w = canvasWidth / money.length;//每一个小矩形的宽度
            for(int i = 0 ; i < money.length ; i ++) {//左上角X，Y坐标，宽度，高
                if (money[i] > 0) {
                    AlgoVisHelper.setColor(g2d, AlgoVisHelper.Blue);
                    AlgoVisHelper.fillRectangle(g2d, i * w + 1, canvasHeight / 2 - money[i], w - 1, money[i]);
                }
                else{
                    AlgoVisHelper.setColor(g2d, AlgoVisHelper.Red);
                    AlgoVisHelper.fillRectangle(g2d, i * w + 1, canvasHeight / 2, w - 1, -money[i]);
                }
            }

3 蒙特卡洛算法 随机模拟 

AlgoFrame.java

设置数据

    // TODO: 设置自己的数据
    private Circle circle;
    private LinkedList<Point> points;
    public void render(Circle circle, LinkedList<Point> points){
        this.circle = circle;
        this.points = points;
        repaint();
    }

具体绘制方法paintComponent，先绘制一个圈，圈内的点红色，圈外绿色，点用实心圆画。

            // 具体绘制
            // TODO： 绘制自己的数据data
            AlgoVisHelper.setStrokeWidth(g2d,3);
            AlgoVisHelper.setColor(g2d, AlgoVisHelper.Blue);
            AlgoVisHelper.strokeCircle(g2d, circle.getX(), circle.getY(), circle.getR());
            for(int i = 0; i < points.size(); i++){
                Point p =points.get(i);
                if(circle.contain(p))
                    AlgoVisHelper.setColor(g2d, AlgoVisHelper.Red);
                else
                    AlgoVisHelper.setColor(g2d, AlgoVisHelper.Green);
                AlgoVisHelper.fillCircle(g2d, p.x, p.y, 3);
            }

 AlgoVisualizer.java

定义变量

    // TODO: 创建自己的数据
    private Circle circle;//圆
    private LinkedList<Point> points;//点队列
    private AlgoFrame frame;    // 视图
    private int N;//点个数
    private static int DELAY = 40;//刷新停顿

 实例化类方法，传参为界面宽高，点的个数。

    public AlgoVisualizer(int sceneWidth, int sceneHeight, int N){
        // TODO: 初始化数据
        if(sceneWidth != sceneHeight)
            throw new IllegalArgumentException("This demo must be run in a square window!");
        this.N = N;
        circle = new Circle(sceneWidth/2, sceneHeight/2, sceneWidth/2);
        points = new LinkedList<Point>();
        // 初始化视图
        EventQueue.invokeLater(() -> {
            frame = new AlgoFrame("Welcome", sceneWidth, sceneHeight);
            new Thread(() -> {
                run();
            }).start();
        });
    }

 动画逻辑方法，点的坐标为(0~1随机值)*面板的宽高，frame的render方法不断调用PaintComonent方法刷新控件。

    private void run(){
        for(int i = 0; i < N; i++){
            frame.render(circle, points);//刷新控件
            AlgoVisHelper.pause(DELAY);//停顿
            int x = (int)(Math.random() * frame.getCanvasWidth());
            int y = (int)(Math.random() * frame.getCanvasHeight());
            Point p = new Point(x, y);//点的位置
            points.add(p);
        }
    }

 Main方法

    public static void main(String[] args) {
        int sceneWidth = 800;
        int sceneHeight = 800;
        int N = 10000;
        // TODO: 根据需要设置其他参数，初始化visualizer
        AlgoVisualizer visualizer = new AlgoVisualizer(sceneWidth, sceneHeight, N);
    }

 4.用蒙特卡洛算法计算π值

MonteCarloPiData.java

数据类，主要包含圆、点列表

import java.util.LinkedList;
import java.awt.*;
public class MonteCarloPiData {
    private Circle circle;//圆
    private LinkedList<Point> points;//点列表
    private int insideCircle = 0;//在圆内的点
    public MonteCarloPiData(Circle circle){//构造函数
        this.circle = circle;
        points = new LinkedList<Point>();
    }
    public Circle getCircle(){
        return circle;
    }//返回圆
    public int getPointsNumber(){
        return points.size();
    }//所有点数目
    public Point getPoint(int i){//获得第几个点
        if(i < 0 || i >= points.size())
            throw new IllegalArgumentException("out of bound in getPoint!");
        return points.get(i);
    }
    public void addPoint(Point p){//统计在圈内的点
        points.add(p);
        if(circle.contain(p))
            insideCircle ++;
    }
    public double estimatePi(){//计算π值
        if(points.size() == 0)
            return 0.0;
        int circleArea = insideCircle;
        int squareArea = points.size();
        return (double)circleArea * 4 / squareArea;
    }
}

视图层AlgoFrame.java

render方法设置数据：

    // TODO: 设置自己的数据
    private MonteCarloPiData data;
    public void render(MonteCarloPiData data){
        this.data = data;
        repaint();
    }

 paintComponent绘制方法中具体绘制：

         // TODO： 绘制自己的数据data
            AlgoVisHelper.setStrokeWidth(g2d,3);
            AlgoVisHelper.setColor(g2d, AlgoVisHelper.Blue);
            Circle circle = data.getCircle();//取出圆
            AlgoVisHelper.strokeCircle(g2d, circle.getX(), circle.getY(), circle.getR());
            for(int i = 0; i < data.getPointsNumber(); i++){
                Point p =data.getPoint(i);//取出第i个点
                if(circle.contain(p))
                    AlgoVisHelper.setColor(g2d, AlgoVisHelper.Red);
                else
                    AlgoVisHelper.setColor(g2d, AlgoVisHelper.Green);
                AlgoVisHelper.fillCircle(g2d, p.x, p.y, 3);
            }

AlgoVisualizer.java

控制层

创建数据

    // TODO: 创建自己的数据
    private MonteCarloPiData data;//数据对象，参数包括圆和点列表
    private AlgoFrame frame;    // 视图
    private int N;//点个数
    private static int DELAY = 1;//刷新每个点停顿

 构造方法初始化数据

    public AlgoVisualizer(int sceneWidth, int sceneHeight, int N){
        // TODO: 初始化数据
        if(sceneWidth != sceneHeight)
            throw new IllegalArgumentException("This demo must be run in a square window!");
        this.N = N;
        Circle circle = new Circle(sceneWidth/2, sceneHeight/2, sceneWidth/2);
        data = new MonteCarloPiData(circle);
        // 初始化视图
        EventQueue.invokeLater(() -> {
            frame = new AlgoFrame("Welcome", sceneWidth, sceneHeight);
            new Thread(() -> {
                run();
            }).start();
        });
    }

动画逻辑run方法

    // 动画逻辑
    private void run(){
        for(int i = 0; i < N; i++){
            if( i % 100 == 0) {
                frame.render(data);//刷新控件
                AlgoVisHelper.pause(DELAY);//停顿
                System.out.println(data.estimatePi());//输出π计算值
            }
            int x = (int)(Math.random() * frame.getCanvasWidth());
            int y = (int)(Math.random() * frame.getCanvasHeight());
            data.addPoint(new Point(x, y));
        }
    }

5不用UI计算π：

圆类Circle.java，参数圆心的坐标x，y，半径r，类方法contain判断点是否在圆内。

算法类MonteCarloPiData.java，参数圆。

测试类MonteCarloExperiment.java，参数正方型边长squareSide,点个数N。

类方法run先建立MonteCarloPiData对象data，然后随机模拟点，使用data的方法addPoint加入每个点。每一百次计算π值。

import java.awt.*;
public class MonteCarloExperiment {
    private int squareSide;
    private int N;
    public MonteCarloExperiment(int squareSide, int N){
        if(squareSide <= 0 || N <= 0)
            throw new IllegalArgumentException("squareSide and N must larger than zero!");
        this.squareSide = squareSide;
        this.N = N;
    }
    public void run(){
        Circle circle = new Circle(squareSide/2, squareSide/2, squareSide/2);
        MonteCarloPiData data = new MonteCarloPiData(circle);
        for(int i = 0 ; i < N ; i ++){
            if( i % 100 == 0) {
                System.out.println(data.estimatePi());
            }
            int x = (int)(Math.random() * squareSide);
            int y = (int)(Math.random() * squareSide);
            data.addPoint(new Point(x, y));
        }
    }
}

6、三门问题

 

public class ThreeGatesExperiment {
    private int N;
    public ThreeGatesExperiment(int N){
        if(N <= 0)
            throw new IllegalArgumentException("N<=0");
        this.N = N;
    }
    public void run(boolean changeDoor){
        int wins = 0;
        for(int i = 0; i < N; i++){
            if(play(changeDoor)){
                wins ++;
            }
        }
        System.out.println(changeDoor ? "change" : "not change");
        System.out.println("winning rate:"+(double)wins/N);
    }
    private boolean play(boolean changeDoor){
        // Door 0, 1, 2
        int prizeDoor = (int)(Math.random() * 3);
        int playerChoice = (int)(Math.random() * 3);
        if( playerChoice == prizeDoor)
            return changeDoor ? false : true;
        else
            return changeDoor ? true : false;
    }
}

7 抽5次中奖率为20%的奖品。

 

public class WinningPrize {
    private double chance;//一次中奖的概率0.2
    private int playTime;//开几次宝箱5
    private int N;//模拟几次
    public WinningPrize(double chance, int playTime, int N){
        if(chance < 0.0 || chance > 1.0)
            throw new IllegalArgumentException("chance must be between 0 and 1!");
        if(playTime <= 0 || N <= 0)
            throw new IllegalArgumentException("playTime or N must be larger than 0!");
        this.chance = chance;
        this.playTime = playTime;
        this.N = N;
    }
    public void run(){
        int wins = 0;
        for(int i = 0 ; i < N ; i ++)
            if(play())
                wins ++;
        System.out.println("winning rate: " + (double)wins/N);
    }
    private boolean play(){
        for(int i = 0 ; i < playTime ; i ++)
            if(Math.random() < chance)//0-1之间的数，小于chance就中奖
                return true;
        return false;
    }
}