如何建立一个链表，使每个节点都有一个随机的int值，但是总值之和和节点数将预先确定？

Question

I've started building something like this:

class Node{
    Node next,prev;
    int val;
    Node(int val, Node prev, Node next){
        this.val = val;
        this.prev = prev;
        this.next = next;
    }
}

....

 public void buildRandomPath(int size, int total){
    road = new Node[size];
    int tmp = (int)(Math.random()*(double)(total/size));
    total = total-tmp;
    road[0] = new Node(tmp,road[size-1],road[1]);
    for (int i = 1; i < size-1; i++){
        tmp = (int)(Math.random()*(double)(total/size-i));
        total = total-tmp;
        road[i] = new Node(tmp1,road[i-1],road[i+1]);
    }
    tmp = (int)(Math.random()*(double)(total));
    total = total-tmp;
    road[size-1] = new Node(tmp,road[size-2],road[0]);
}

It is totally not the right algorithm, but this is the general idea i'm heading for

Answer 1

For a uniform random answer (assuming the implicit non-negativity constraint): generate nodeCount - 1 pairwise distinct integers between 0 inclusive and sum + nodeCount - 1 exclusive. Sort these, prepend -1 , and append sum + nodeCount - 1 . Return the difference sequence minus one.

Example: nodeCount = 4 and sum = 10 . Generate integers.

5 2 12

Sort, prepend, append.

-1 2 5 12 13

Difference sequence.

3 3 7 1

Minus one.

2 2 6 0

Implementation notes: you need to special case nodeCount == 0 if that's a possibility. To generate integers with no duplicates: if sum is small compared to nodeCount , then use a partial Fisher--Yates shuffle. Otherwise, sample nodeCount - 1 integers with replacement and repeat until there are no duplicates.

Answer 2

If you want the sum to be a particular total, you can have a remaining total and make the last element that value. e..g

Make the nodes have random values X1, X2, ... Xn-1, total - SumOf(X1, ... Xn-1) This will ensure the total is always total

Answer 3

如果您要生成n个值，它们的总和为S，则可以生成0到1之间的n个随机双精度数，然后将它们相除，使其总数为1。然后将值乘以S。如果数字必须为整数，可能需要一些其他工作才能正确处理舍入。

Answer 4

You can do something like this:

double runningTotal = total;
Random rand = new Random();
road = new double[size];
while(runningTotal > 0) {
    double temp = rand.nextDouble(); // return [0, 1)
    if(temp > runningTotal) {
        temp = runningTotal;
        runningTotal = 0.0;
    } else {
        runningTotal -= temp;
    }
    road[rand.nextInt(size)] += temp;
}

You can replace temp = rand.nextDouble() with temp = rand.nextDouble / scalingFactor (where eg scalingFactor = 10) to increase the uniformity and reduce the probability that any nodes will end up equaling 0.

Answer 5

public Node[] buildRandomPath(int size, int total){
    Node[] road = new Node[size];
    int tmp = (int)(Math.random()*(double)(total/size));
    if(tmp==0)
        tmp=1;
    total = total-tmp;
    road[0] = new Node(tmp,road[size-1],road[1]);
    int tmp1=0;
    for (int i = 1; i < size-1; i++){
        tmp1 = (int)(Math.random()*(double)(total/size-i));
        if(tmp1==0)
            tmp1=1;
        total = total-tmp1;
        if(total>0)
            road[i] = new Node(tmp1,road[i-1],road[i+1]);
        else
            road[i] = new Node(0,road[i-1],road[i+1]);
    }
    road[size-1] = new Node(total,road[size-2],road[0]);
    return road;
}

Answer 6

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;


class Node{
    Node next,prev;
    int val;
}

public class temp {

    public Node[] buildRandomPath(int size, int total){

        Node[] road = new Node[size];
        for (int i = 0; i < road.length; i++) {
            road[i]=new Node();
        } 

         int tmp = (int)(Math.random()*(double)(total/size));
        if(tmp==0)
            tmp=1;
        total = total-tmp;
        road[0].val=tmp;
        road[0].next=road[1];
        road[0].prev=road[size-1];  
        int tmp1=0;
        for (int i = 1; i < size-1; i++){
            tmp1 = (int)(Math.random()*(double)(total/size-i));
            if(tmp1==0)
                tmp1=1;
            total = total-tmp1;
            road[i].next=road[i+1];
            road[i].prev=road[i-1];
            if(total>0)
                road[i].val=tmp1;
            else
                road[i].val=0;
        }
        road[size-1].val=total;
        road[size-1].next=road[0];
        road[size-1].prev=road[size-2];
        return road;
    }
    public static void main(String[] args) {

        temp t=new temp();
        Node[] node=t.buildRandomPath(10, 500);
        int i=0;
        for (Node node2 : node) {
            i=i+node2.val;

    }
        System.out.println(i);
    }
}