如何建立一個鏈表，使每個節點都有一個隨機的int值，但是總值之和和節點數將預先確定？

Question

我已經開始構建這樣的東西：

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]);
}

這絕對不是正確的算法，但這是我要追求的基本思想

Answer 1

對於統一的隨機答案（假設隱式非負約束）：生成nodeCount - 1成對的，在0和0之間的和且sum + nodeCount - 1互斥的整數。 對它們進行排序，在-1添加，然后追加sum + nodeCount - 1 。 返回差異序列減一。

示例： nodeCount = 4並且sum = 10 。 生成整數。

5 2 12

排序，添加，追加。

-1 2 5 12 13

差異序列。

3 3 7 1

減一

2 2 6 0

實施注意事項：如果可能，您需要特殊情況下的nodeCount == 0 。 要生成沒有重復的整數：如果sum與nodeCount相比nodeCount ，則使用部分Fisher-Yates隨機播放。 否則，請采樣nodeCount - 1帶替換的整數，然后重復進行直到沒有重復。

Answer 2

如果您希望總和是特定的總計，則可以有一個剩余的總計，並使最后一個元素成為該值。 例如

使節點具有隨機值X1，X2，... Xn-1，總數-SumOf（X1，... Xn-1）這將確保總數始終為total

Answer 3

如果您要生成n個值，它們的總和為S，則可以生成0到1之間的n個隨機雙精度數，然后將它們相除，使其總數為1。然后將值乘以S。如果數字必須為整數，可能需要一些其他工作才能正確處理舍入。

Answer 4

您可以執行以下操作：

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;
}

您可以將temp = rand.nextDouble()替換為temp = rand.nextDouble / scalingFactor （例如，scaleFactor = 10），以提高均勻性並降低任何節點最終等於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);
    }
}