I could get only $$$166/300$$$. So won't comment much on this problem, you can check other's approaches :)

It was a direct problem based on the definition of expected value and dynamic programming.
$$$dp[i]$$$ denotes the expected length for number = $$$i$$$.
Base case : $$$dp[1] = 0$$$
Now expected value = $$$\sum_{}^{} p * val $$$, where $$$p$$$ denotes the probability of a particular event and $$$val$$$ is the expected value after going to that event.
Here we can go to all the divisors of $$$i$$$ except $$$i$$$, so our expression will look like :
$$$\sum_{}^{} \frac{1 \, + \, dp[factor]}{count \, of \, factors \, of \, i}$$$

There are two ways to compute the sum, one is the basic one of iterating over the square root of each number to find the factors and do the given summation. Time complexity will be $$$O(n\sqrt{n})$$$.
Another method is to use a sieve kind of iteration as the total number of factors will be $$$O(nlogn)$$$.
I coded it with $$$O(n\sqrt{n})$$$ during the contest.
Final answer would be : $$$\frac{1}{n}\sum_{1}^{n}dp[i]$$$

Keep a set of ranges in the form of a pair $$$[l,r]$$$.
Suppose you have to insert a range $$$[x,y]$$$, so you only need to update just the ranges which overlap with the current range $$$[x,y]$$$.
So you can do a binary search using $$$lower bound$$$ or $$$upper bound$$$ functions to find the start of the ranges already present in our set.
Erase all the pairs which overlap with the current range to be inserted and then insert the current range. Don't forget to update the $$$x$$$ and $$$y$$$ values as in the overlap $$$x$$$ may decrease or $$$y$$$ may increase.

Note that the length of $$$A$$$ is at max $$$15$$$, so it can be taken as a hint to solve the problem using bitmask $$$dp$$$.

I used $$$dp[i][j][k]$$$, where $$$i$$$ denotes the current index I am at, $$$j$$$ denotes the bitmask of already taken indices from the array $$$A$$$, and $$$k$$$ is $$$0$$$ or $$$1$$$, $$$0$$$ denotes I have to place smaller element and $$$1$$$ denotes I have to place larger element.
Now the transition is easy. Let me know if you are struggling with the transitions.

Think about the cost for fixed vertices u and v.

All parts of the cost are independent of each other, except third and fourth part depend together on the return path.

The first part, A[u] is independent of path taken.

For second part, we must choose the path with minimum sum of weights.

The sum of 3rd and 4th part is sum of weigths in return path + no of edges in return path * B[u]. Either minimize the sum of weights or minimize the no of edges. Take the minimum of both cases.

Use Floyd-Warshall algorithm for computations.

We create the following two sets of two 2-d arrays:

1. dp1[i][j] = min'm sum of weights of a path b/w i and j. edges1[i][j] = no of edges in that path with min'm sum of weights.

2. edges2[i][j] = min'm no of edges on a path b/w i and j. dp2[i][j] = sum of weights on that path with min'm no of edges.

Between any 2 vertices i and j, the two possible costs are:

1. Min'm weight: A[j] + dp1[i][j] + dp1[i][j] + edges1[i][j] * B[j].

2. Min'm edges: A[j] + dp1[i][j] + dp2[i][j] + edges2[i][j] * B[j].

Hence, cost between two vertices i and j is minimum of both cases.

Now, we can use Floyd-Warshall Algorithm to compute the values of all four arrays in O(N^3).

After this, for every vertex i, we can iterate over all N vertices to find the one with minimum cost.

The given graph is not simple. So while constructing the initial adjacency matrix, dp and edges, you need to check for self-loops (ignore them) and multiple edges (store the one with min'm weight).

#include<bits/stdc++.h>
using namespace std;
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
#define int               long long
#define all(x)            (x).begin(),(x).end()
#define ordered_set tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>    //s.find_by_order(i),  st.order_of_key(x) elements strictly less then x
#define speed ios_base::sync_with_stdio(false);  cin.tie(NULL)


int dp[5002][5002];
vector<int> v;
int solve(int i, int x, int rem1, int rem2)
{

	if (rem1 == 0 && rem2 == 0)
		return 0;

	if (dp[rem1][rem2] != -1)
		return dp[rem1][rem2];

	int ans = 1e18;
	if (rem1 > 0)
	{
		ans = v[i + x - 1] - v[i];
		i += x;
		ans += solve(i, x, rem1 - 1, rem2);
	}
	if (rem2 > 0)
	{
		int sz = x + 1, temp = 0;
		temp += v[i + sz - 1] - v[i];
		i += sz;
		temp += solve(i, x, rem1, rem2 - 1);
		ans = min(ans, temp);
	}
	return dp[rem1][rem2] = ans;
}

signed main()
{
	speed;
	int n, b;
	cin >> n >> b;
	memset(dp, -1, sizeof(dp));

	for (int i = 0; i < n; i++)
	{
		int x;
		cin >> x;
		v.push_back(x);
	}
	sort(v.begin(), v.end());
	int sz = n / b;
	int total = b;
	cout << solve(0, sz, b - n % b, n % b) << '\n';


	return 0;
}