在所有元素的总和都相同的情况下，如何生成两个不同的随机数矩阵？

Question

我在 C++ 中创建了两个不同的随机生成数字矩阵：

a = new int* [IT]();
    for (int j = 0; j < IT; j++) {
        a[j] = new int[P];
        for (int p = 0; p < P; p++) {
            a[j][p] = RL.randint(0,100); // I have created the randint function in another cpp file
        }
    }
b = new int* [OT]();
    for (int m = 0; m < OT; m++) {
        b[m] = new int[P];
        for (int p = 0; p < P; p++) {
            b[m][p] = RL.randint(0, 100); 
        }
    }

现在我想以某种方式实现以下条件： ∑(j,p)〖a(j,p)〗= ∑(m,p)〖b(m,p)〗

我没有在 Google 中找到任何可以帮助我的东西，只有一些在总和满足特定目标的情况下生成数字的示例（例如 sumofrandnumbs = 6）。就我而言，我没有想要满足的特定数字，只有两个总和必须相同的标准。我在想也许在 excel 中根据此标准生成数字然后将它们提取到我的 cpp 文件中并将它们放入 a 和 b 矩阵中会更容易。我也不知道该怎么做，但我在网上找到了一些信息。你的帮助意义重大。非常感谢。

Answer 1

计算率

K = Sum_of_a/Sum_of_b

.

然后，如果

K<=1.0

将这个

K

乘以

b

，否则将

1/K

乘以

a

（以保留所有元素值<= 100).

但是，由于元素类型是int，后面需要做一些调整。 （比如重新检查结果总和并在随机位置添加不足。）

Answer 2

你不能在一个迭代步骤中实现它，除非你想在输出上作弊。

你必须得到第一个数字的随机数矩阵并将和值存储在某个变量中然后你需要一次又一次地重复生成第二个矩阵直到它的和等于第一个并且代码看起来像这样

    国际相扑=0
    a = new int* [IT]();
    对于 (int j = 0; j < IT; j++) {
        a[j] = new int[P];
        for (int p = 0; p < P; p++) {
            a[j][p] = RL.randint(0,100); 
            suma+=a[j][p];
        }
    }
    b = new int* [OT]();
    while(true){
        sumb=0
        for (int m = 0; m < OT; m++) {
            b[m] = new int[P];
            for (int p = 0; p < P; p++) {
                b[m][p] = RL.randint(0, 100); 
                sumb+=b[m][p];
            }
        }
        if(suma == sumb){
            break;
        }
    }

但是如果您正在寻找速度，则根本不推荐这种方法。

如果 p 很大，这将至少迭代几百万次。

时间复杂度为 O((随机数允许长度)(OT*P)) 所以，3x3 的 O(1009)。这是最坏的情况。

但是我们可以通过简单的技术来欺骗这个，方法是在第二个数组中生成除最后一个数字之外的所有随机数。并通过

找到最后一个数字

    b[OT-1][P-1]=suma-sumb-b[Ot-1][P-1]；

代码看起来像这样；

    国际相扑=0
    a = new int* [IT]();
    对于 (int j = 0; j < IT; j++) {
        a[j] = new int[P];
        for (int p = 0; p < P; p++) {
            a[j][p] = RL.randint(0,100); 
            suma+=a[j][p];
        }
    }
    b = new int* [OT]();
    int sumb=0
    for (int m = 0; m < OT; m++) {
        b[m] = new int[P];
        for (int p = 0; p < P; p++) {
            b[m][p] = RL.randint(0, 100); 
            sumb+=b[m][p];
        }
    }
    b[OT-1][P-1]=suma-sumb-b[Ot-1][P-1];

现在无论概率如何，单次迭代都会有保证的输出。但调整一些随机数，这样你总是在修改后的值中得到正数。

如果这有帮助，请留下赞成票。