选择均匀随机的站点以阻止剩余的阵列站点

Question

I have an appication of a grid where the two dimensional array represents sites which may be blocked or open , take blocked as 0 and open as 1 . Let the boolean array be boolean gridSite[N*N] . I am using a one dimensional array for two dimensions by correctly changing the index from the user into required index in the 1-D array . The function which changes the index is as follows int index(int i,int j){ return (i-1)*N + j-1 ;} . The user gives an index b/w 1 and N for both dimension .

During a simulation I require to open the sites by randomly choosing them . I mean initially all the sites are blocked . Next step is to choose random index i and j and open it . Repeat this again (randomly) till when the condition is met . I have a library for specific purpose which can generate random number by this code StdRandom.uniform(N) but the point is , this doesn't solve the problem . When run for the first time it will generate a random site and open it , but now I have to generate a random index only for the remaining locations . Suppose we have 20x20 grid and for the first time it chooses 4,7 then next time it shouldn't choose this anymore . How to achieve this

Answer 1

It sounds like you need a random permutation of numbers from 1 to N , where N = 20 * 20 = 400 in this case.

1. Write a loop to generate the numbers between 1 and N in an ordered list or array.
2. Use Java's standard libraries to shuffle this list and create a random permutation.
3. Iterate through the permuted list, and transform the indices using your function to map the single index to a paired index.

Answer 2

Use the following class which will sequentially give you a random index and enumerate all your indices exactly once.

import java.util.Enumeration;
import java.util.Random;

public class RandomPermuteIterator implements Enumeration<Long> {
    int c = 1013904223, a = 1664525;
    long seed, N, m, next;
    boolean hasNext = true;

    public RandomPermuteIterator(long N) throws Exception {
        if (N <= 0 || N > Math.pow(2, 62)) throw new Exception("Unsupported size: " + N);
        this.N = N;
        m = (long) Math.pow(2, Math.ceil(Math.log(N) / Math.log(2)));
        next = seed = new Random().nextInt((int) Math.min(N, Integer.MAX_VALUE));
    }

    public static void main(String[] args) throws Exception {
        RandomPermuteIterator r = new RandomPermuteIterator(100);
        while (r.hasMoreElements()) System.out.print(r.nextElement() + " ");
        //output: 50 52 3 6 45 40 26 49 92 11 80 2 4 19 86 61 65 44 27 62 ...
    }

    @Override
    public boolean hasMoreElements() {
        return hasNext;
    }

    @Override
    public Long nextElement() {
        next = (a * next + c) % m;
        while (next >= N) next = (a * next + c) % m;
        if (next == seed) hasNext = false;
        return  next;
    }
}