system verilog 2 dimensional dynamic array randomization

You can't use the random number generator (RNG) to enumerate all possible solutions of your problem. It's not built for this. An RNG can give you one of these solutions with each call to randomize(). It's not guaranteed, though, that it gives you a different solution with each call. Say you have 3 solutions, S0, S1, S2. The solver could give you S1, then S2, then S1 again, then S1, then S0, etc. If you know how many solutions there are, you can stop once you've seen them all. Generally, though, you don't know this beforehand.

What an RNG can do, however, is check whether a solution you provide is correct. If you loop over all possible solutions, you can filter out only the ones that are correct. In your case, you have N balls and up to N groups. You can start out by putting each ball into one group and trying if this is a correct solution. You can then put 2 balls into one group and all the other N - 2 into a groups of one. You can put two other balls into one group and all the others into groups of one. You can start putting 2 balls into one group, 2 other balls into one group and all the other N - 4 into groups of one. You can continue this until you put all N balls into the same group. I'm not really sure how you can easily enumerate all solutions. Combinatorics can help you here. At each step of the way you can check whether a certain ball arrangement satisfies the constraints:

// Array describing an arrangement of balls
// - the first dimension is the group
// - the second dimension is the index within the group
typedef unsigned int unsigned arrangement_t[][];

// Function that gives you the next arrangement to try out
function arrangement_t get_next_arrangement();
  // ...
endfunction

arrangement = get_next_arrangement();

if (weight_distributor_o.randomize() with {
  solution.size() == arrangement.size();
  foreach (solution[i]) {
    solution[i].size() == arrangement[i].size();
    foreach (solution[i][j])
      solution[i][j] == arrangement[i][j];
  }
})
  all_solutions.push_back(arrangement);

Now, let's look at weight_distributor. I'd recommend you write each requirement in an own constraint as this makes the code much more readable.

You can shorten you uniqueness constraint that you wrote as a double loop to using the unique operator:

class weight_distributor;

  // ...

  constraint unique_balls {
    unique { solution_array };
  }

endclass

You already had a constraint that each group can have at most MAX_WEIGHT in it:

class weight_distributor;

  // ...

  constraint max_weight_per_group {
    foreach (solution_array[i])
      solution_array[i].sum() < `MAX_WEIGHT_BUCKET;
  }

endclass

Because of the way array sizes are solved, it's not possible to write constraints that will ensure that you can compute a valid solution using simple calls randomize(). You don't need this, though, if you want to check whether a solution is valid. This is due to the constraints on array sizes in the between arrangement and solution_array.

Try this.! class ABC; rand bit[3:0] md_array [][]; // Multidimansional Arrays with unknown size

constraint c_md_array { 
 // First assign the size of the first dimension of md_array
 md_array.size() == 2; 

 // Then for each sub-array in the first dimension do the following:
 foreach (md_array[i]) {

    // Randomize size of the sub-array to a value within the range
    md_array[i].size() inside {[1:5]};

    // Iterate over the second dimension 
    foreach (md_array[i][j]) {

       // Assign constraints for values to the second dimension
       md_array[i][j] inside {[1:10]};
     }
  }
 }

endclass

module tb;

initial begin
  ABC abc = new;
  abc.randomize();
  $display ("md_array = %p", abc.md_array);
end

endmodule

https://www.chipverify.com/systemverilog/systemverilog-foreach-constraint