I did have to try quite a few times :( but eventually it passed after handling the overflow (using binary search: https://atcoder.jp/contests/abc192/submissions/20332818).

You need to consider case where $$$x$$$ has length 1 as special case.

I hope AtCoder will learn me at one moment long long r = 1e18 + 10 is equal to 1e18 duo double precision error. This is the third (known) time I made the same mistake

Same situation with me

There a "few" corner cases as well. Also, yes you have to handle overflow.Submission

For x="1", the value of x is allways 1, independent of base n. So, why is there 0 or 1 solutions (as tutorial states). It should be m-1 possible values for n.

Can somebody explain?

You can fix overflow by not thinking of overflow ft. (__int128) My Submission

You can use Dijkstra’s shortest path algorithm.

consider the case when The length of $$$X$$$ is 1, The answer is $$$1$$$ if $$$X <= m$$$ or $$$0$$$ otherwise

if (sz(s) == 1) {cout << 1; return;}

The answer isn't always 1 in this case. For example: X = 9, M = 1

How could you say that??

It was one of the worst problemset that I have ever seen.

Problem A and B was easy, as always in atcoder.Problem C was tooo easy. Problem D was also really easy, just you should know about precision error. And problem E was just a dijkstra. (And I didn't read problem F)

Can you tell me why are you using Val variable as long double in your AC solution , It is meant to have only integer values I think. One thing more , Why aren't you considering the situation when Val overflows?.

Thanks...It worked..

I am unable to get my code work around handmade case #2.

On putting certain asserts I also found out the my binary search is not working as expected.

// ok returns true when for a given base, value exceeds m
// l is maximum_digit_in_x + 1 whereas r is 1e18
	while (l < r) {
		ll mid = l + ((r - l) / 2);
		if (ok(mid)) {
			r = mid;
		} else {
			l = mid + 1;
		}
	}
	assert(l == r);

If I am using mid = (l + r) / 2 and then putting asserts, then it is not giving Runtime error on Handmade #1 Link

Can anyone have a look at my submission and tell me what am I doing wrong.

So does it mean , that there won't be overflow for sum in long double? , and one more silly question why was c++ boost created when Long Double can handle cases. sorry if you feel it is way too stupid.

The idea is that there is no point of arriving later than you can, because you can always wait at the destination, so it's better to find the shortest path. And I believe that with this fact you can just repeat a proof for dijkstra algorithm, maybe with some small fixes.

You can also replace each vertex with infinitely many vertices, one for each moment of time. Then you have some directed edges between vertices, and also directed edges of weight 1 between copies of the same vertex. Then you can just run dijkstra on this graph, and it will work because this is just a directed graph (infinite graph, but whatever). I don't know your exact algorithm, but it should be easy to prove that what you do is more or less equal to running dijkstra on this graph, thus it is correct.

Let the sum of elements you will mix be S.

Brute force over the value of K from 1 to N (the number of elements you will mix), suppose you want to check K = 3, then you should take 3 elements from the array such that the sum of these elements is S and the following conditions holds:

1. S%3 = X%3 (because this sum will be increased by K each second until reach X).

2. Their sum S is maximum (because this will decrease the time we need to reach X).

The last part (choosing K elements such that S%k = X%K and their sum S is maximum) can be done using dynamic programming, let dp[i][rem][mod] represents the maximum sum you can get when you are at index i and has to take rem elements and the sum of elements you taken so far modulus K equals mod, then you try to take or leave each element and return the optimal answer.

Note that the value returned from dp will never exceed X, Because the max value you can get is 1e9 and X is at least 1e9.