[算法] 随机模拟问题

分钱问题

• 100个人，初始每人100块钱，每轮每人将1元随机分给另一个人，若干轮过后，100个人的财富分布情况会怎样
• 画布的原点在左上角，y轴向下

AlgoVisHelper.java

import java.awt.EventQueue;
import java.util.Arrays;

public class AlgoVisualizer {
    
    private static int DELAY = 40;
    private int[] money;
    private AlgoFrame frame;
    
    public AlgoVisualizer(int sceneWidth, int sceneHeight) {
        
        // 初始化数据
        money = new int[100];
        for(int i = 0 ; i < money.length ; i ++) {
            money[i] = 100;
        }
        
        // 初始化视图
        EventQueue.invokeLater(()->{
            frame = new AlgoFrame("Welcome",sceneWidth,sceneHeight);
            new Thread(()->{
                    run();
            }).start();  
        });
    }
    
    private void run() {
        while(true) {
            Arrays.sort(money);
            frame.render(money);
            AlgoVisHelper.pause(DELAY);
            
            for(int k = 0 ; k < 50 ; k ++ ) {
                for(int i = 0 ; i < money.length ; i ++ ) {
                        int j = (int)(Math.random() * money.length);
                        money[i] -= 1;
                        money[j] += 1;
                }
            }
        }
    }
    
    public static void main(String[] args) {
        
        int sceneWidth = 1000;
        int sceneHeight = 800;
        
        AlgoVisualizer visualizer = new AlgoVisualizer(sceneWidth, sceneHeight);
        
    }
}

AlgoVisualizer.java

import java.awt.EventQueue;
import java.util.Arrays;

public class AlgoVisualizer {
    
    private static int DELAY = 40;
    private int[] money;
    private AlgoFrame frame;
    
    public AlgoVisualizer(int sceneWidth, int sceneHeight) {
        
        // 初始化数据
        money = new int[100];
        for(int i = 0 ; i < money.length ; i ++) {
            money[i] = 100;
        }
        
        // 初始化视图
        EventQueue.invokeLater(()->{
            frame = new AlgoFrame("Welcome",sceneWidth,sceneHeight);
            new Thread(()->{
                    run();
            }).start();  
        });
    }
    
    private void run() {
        while(true) {
            Arrays.sort(money);
            frame.render(money);
            AlgoVisHelper.pause(DELAY);
            
            for(int k = 0 ; k < 50 ; k ++ ) {
                for(int i = 0 ; i < money.length ; i ++ ) {
                        int j = (int)(Math.random() * money.length);
                        money[i] -= 1;
                        money[j] += 1;
                }
            }
        }
    }
    
    public static void main(String[] args) {
        
        int sceneWidth = 1000;
        int sceneHeight = 800;
        
        AlgoVisualizer visualizer = new AlgoVisualizer(sceneWidth, sceneHeight);
        
    }
}

AlgoFrame.java

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;

import javax.swing.JFrame;
import javax.swing.JPanel;

public class AlgoFrame extends JFrame{
    
    private int canvasWidth;
    private int canvasHeight;
    
    public AlgoFrame(String title, int canvasWidth, int canvasHeight) {
        
        super(title);
        
        this.canvasWidth = canvasWidth;
        this.canvasHeight = canvasHeight;
        
        AlgoCanvas canvas = new AlgoCanvas();
        setContentPane(canvas);
        pack();
        
        setResizable(false);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setVisible(true);
    }
    
    public AlgoFrame(String title) {
        this(title, 1024, 768);
    }
    
    public int getCanvasWidth() {return canvasWidth;}
    public int getCanvasHeight() {return canvasHeight;}

    private int[] money;
    public void render(int[] money) {
        this.money = money;
        repaint();
    }
    
    private class AlgoCanvas extends JPanel{
        
        public AlgoCanvas() {
            super(true);
        }
        
        @Override
        public void paintComponent(Graphics g) {
            
            super.paintComponent(g);
            
            Graphics2D g2d = (Graphics2D)g;
            
            //抗锯齿
            RenderingHints hints = new RenderingHints(
                            RenderingHints.KEY_ANTIALIASING, 
                            RenderingHints.VALUE_ANTIALIAS_ON);
            g2d.addRenderingHints(hints);
            
            //具体绘制
            int w = canvasWidth / money.length;
            for(int i = 0 ; i < money.length ; i ++ ) {
                if(money[i] > 0) {
                    AlgoVisHelper.setColor(g2d, AlgoVisHelper.Blue);
                    AlgoVisHelper.fillRectangle(g2d, 
                            i*w + 1, canvasHeight/2 - money[i], w-1, money[i]);
                }
                else if(money[i] < 0) {
                    AlgoVisHelper.setColor(g2d, AlgoVisHelper.Red);
                    AlgoVisHelper.fillRectangle(g2d,
                            i*w + 1, canvasHeight/2, w-1, -money[i]);
                }
            }
        }
        
        @Override
        public Dimension getPreferredSize() {
            return new Dimension(canvasWidth, canvasHeight);
        }
    }
}    

 

蒙特卡洛方法

• 为解决裂变物质的中子随机扩散问题而提出
• 通过大量随机样本，了解一个系统，进而得到所要计算的值
• 红色点的数量-->圆的面积；红色点+绿色点的数量-->方的面积
• PI = 4 * 红色点数 / 总点数

   

AlgoFrame.java

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.RenderingHints;
import java.util.LinkedList;

import javax.swing.JFrame;
import javax.swing.JPanel;

public class AlgoFrame extends JFrame{
    private int canvasWidth;
    private int canvasHeight;
    
    public AlgoFrame(String title, int canvasWidth, int canvasHeight) {
        super(title);
        
        this.canvasWidth = canvasWidth;
        this.canvasHeight = canvasHeight;
        
        AlgoCanvas canvas = new AlgoCanvas();
        setContentPane(canvas);
        pack();
        
        setResizable(false);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setVisible(true);
    }
    
    public AlgoFrame(String title) {
        this(title, 1024, 768);
    }
    
    public int getCanvasWidth() {return canvasWidth;}
    public int getCanvasHeight() {return canvasHeight;}

    private MonteCarloPiaData data;
    public void render(MonteCarloPiaData data) {
        this.data = data;
        repaint();
    }
    
    private class AlgoCanvas extends JPanel{
        
        public AlgoCanvas() {
            super(true);
        }
        
        @Override
        public void paintComponent(Graphics g) {
            
            super.paintComponent(g);
            
            Graphics2D g2d = (Graphics2D)g;
            
            //抗锯齿
            RenderingHints hints = new RenderingHints(
                                        RenderingHints.KEY_ANTIALIASING, 
                                        RenderingHints.VALUE_ANTIALIAS_ON);
            g2d.addRenderingHints(hints);
            
            //具体绘制
            Circle circle = data.getCircle();
            AlgoVisHelper.setStrokeWidth(g2d, 3);
            AlgoVisHelper.setColor(g2d, AlgoVisHelper.Blue);
            AlgoVisHelper.strokeCircle(g2d, circle.getX(), circle.getY(), circle.getR());
            
            for(int i = 0 ; i < data.getPointsNumber() ; i ++ ) {
                Point p = data.getPoint(i);
                if(circle.contain(p))
                    AlgoVisHelper.setColor(g2d, AlgoVisHelper.Red);
                else
                    AlgoVisHelper.setColor(g2d, AlgoVisHelper.Green);
                AlgoVisHelper.fillCircle(g2d, p.x, p.y, 3);
            }
        }
        
        @Override
        public Dimension getPreferredSize() {
            return new Dimension(canvasWidth, canvasHeight);
        }
    }
}    

AlgoVisualizer.java

import java.awt.EventQueue;
import java.awt.Point;
import java.util.LinkedList;

public class AlgoVisualizer {
    
    private static int DELAY = 40;
    
    private MonteCarloPiaData data;
    private AlgoFrame frame;
    private int N;
    
    public AlgoVisualizer(int sceneWidth, int sceneHeight, int N) {
        
        if(sceneWidth != sceneHeight)
            throw new IllegalArgumentException("This demo must be run in a square");
        // 初始化数据
        this.N = N;
        Circle circle = new Circle(sceneWidth/2, sceneHeight/2, sceneWidth/2);
        data = new MonteCarloPiaData(circle);
        
        // 初始化视图
        EventQueue.invokeLater(()->{
            frame = new AlgoFrame("Get Pi with Monte Carlo",sceneWidth,sceneHeight);
            new Thread(()->{
                    run();
            }).start();  
        });
    }
    
    // 动画逻辑
    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));
        }
    }
    
    public static void main(String[] args) {
        
        int sceneWidth = 800;
        int sceneHeight = 800;
        int N = 10000;
        
        AlgoVisualizer visualizer = new AlgoVisualizer(sceneWidth, sceneHeight, N);
    }
}

AlgoVisHelper.java 

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.geom.Ellipse2D;

public class AlgoVisHelper {
    public AlgoVisHelper() {}
    
    public static final Color Red = new Color(0xF44336);
    public static final Color Pink = new Color(0xE91E63);
    public static final Color Purple = new Color(0x9C27B0);
    public static final Color DeepPurple = new Color(0x673AB7);
    public static final Color Indigo = new Color(0x3F51B5);
    public static final Color Blue = new Color(0x2196F3);
    public static final Color LightBlue = new Color(0x03A9F4);
    public static final Color Cyan = new Color(0x00BCD4);
    public static final Color Teal = new Color(0x009688);
    public static final Color Green = new Color(0x4CAF50);
    public static final Color LightGreen = new Color(0x8BC34A);
    public static final Color Lime = new Color(0xCDDC39);
    public static final Color Yellow = new Color(0xFFEB3B);
    public static final Color Amber = new Color(0xFFC107);
    public static final Color Orange = new Color(0xFF9800);
    public static final Color DeepOrange = new Color(0xFF5722);
    public static final Color Brown = new Color(0x795548);
    public static final Color Grey = new Color(0x9E9E9E);
    public static final Color BlueGrey = new Color(0x607D8B);
    public static final Color Black = new Color(0x000000);
    public static final Color White = new Color(0xFFFFFF);
    
    public static void setStrokeWidth(Graphics2D g2d, int w) {
        int strokeWidth = w;
        g2d.setStroke(new BasicStroke(strokeWidth, BasicStroke.CAP_ROUND,BasicStroke.JOIN_ROUND));
    }
    public static void setColor(Graphics2D g2d, Color color) {
        g2d.setColor(color);
    }
    public static void strokeCircle(Graphics2D g2d, int x, int y, int r) {
        Ellipse2D circle = new Ellipse2D.Double(x-r, y-r, 2*r, 2*r);
        g2d.draw(circle);
    }
    public static void fillCircle(Graphics2D g2d, int x, int y, int r) {
        Ellipse2D circle = new Ellipse2D.Double(x-r, y-r, 2*r, 2*r);
        g2d.fill(circle);
    }
    public static void pause(int t) {
        try {
            Thread.sleep(t);
        }
        catch(InterruptedException e) {
            System.out.println("Error in sleeping.");
        }
    }
}

Circle.java

import java.awt.Point;

public class Circle {
    
    public int x, y, r;
    
    public Circle(int x, int y, int r ) {
        this.x = x;
        this.y = y;
        this.r = r;
    }
    
    public int getX() { return x; }
    public int getY() { return y; }
    public int getR() { return r; }
    
    public boolean contain(Point p) {
        return Math.pow(p.getX() - x, 2) + Math.pow(p.getY() - y, 2) <= r*r;
    }
}

MonteCarloPiaData.java

import java.awt.Point;
import java.util.LinkedList;

public class MonteCarloPiaData {
    
    private Circle circle;
    private int insideCircle = 0;
    private LinkedList<Point> points;
    
    public MonteCarloPiaData(Circle circle) {
        this.circle = circle;
        points = new LinkedList<Point>();
    }
    
    public Circle getCircle() {
        return circle;
    }
    
    public Point getPoint(int i) {
        if(i < 0 || i >= points.size())
            throw new IllegalArgumentException("out of bound in getPoint!");
        return points.get(i);
    }
    
    public int getPointsNumber() {
        return points.size();
    }
    
    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;
    }
}

控制台演示

MonteCarloExperiment.java

import java.awt.*;

public class MonteCarloExperiment {
    
    private int squareSide;
    private int N;
    private int outputInterval = 100;
    
    public MonteCarloExperiment(int squareSide, int N) {
        if(squareSide <= 0 || N <= 0)
            throw new IllegalArgumentException("squareSide and N must larger than 0");
        this.squareSide = squareSide;
        this.N = N;
    }
    
    public void setOutputInterval(int interval) {
        if(interval <= 0)
            throw new IllegalArgumentException("interval must be larger than 0");
        this.outputInterval = interval;
    }
    
    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 % outputInterval == 0 )
                System.out.println(data.estimatePi());
            int x = (int)(Math.random() * squareSide);
            int y = (int)(Math.random() * squareSide);
            data.addPoint(new Point(x,y));
        }
    }
    
    public static void main(String[] args) {
        
        int squareSide = 800;
        int N = 1000000;
        
        MonteCarloExperiment exp = new MonteCarloExperiment(squareSide, N);
        exp.setOutputInterval(10000);
        exp.run();
    }
}

三门问题

• 有三扇门，其中一扇门后面有汽车，两扇后面没东西
• 当参赛者选定一扇门但未开启时，主持人会开启剩下两扇门中的一扇，这扇门后面一定没有汽车
• 如果参赛者现在换另一个门，会不会提高中奖概率？
• 换门中奖率2/3，不换门中奖率1/3
• 在计算机中模拟，看最后收敛到的结果

 ThreeGateExperiment.java

public class ThreeGatesExperiment {

    private int N;

    public ThreeGatesExperiment(int N){

        if(N <= 0)
            throw new IllegalArgumentException("N must be larger than 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;
    }

    public static void main(String[] args) {

        int N = 1000;
        ThreeGatesExperiment exp = new ThreeGatesExperiment(N);

        exp.run(true);
        System.out.println();
        exp.run(false);
    }
}

    

你会不会中奖

• 游戏中有一种宝箱，打开宝箱获得传奇武器的概率是20%
• 打开5个这样的宝箱，获得传奇武器的概率是多少？ 

WinningPrize.java

public class WinningPrize {

    private double chance;
    private int playTime;
    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)
                return true;
        return false;
    }

    public static void main(String[] args) {

        double chance = 0.2;
        int playTime = 5;
        int N = 1000000;

        WinningPrize exp = new WinningPrize(chance, playTime, N);
        exp.run();
    }
}