I hope so.

1145 -> 1331 (+186) idk what :)

How do you know that before the contest???

I wonder how do u predict this???

OMG prophet

???

That's because you might know the answer of the questions after the end of contest. So, if you want to increase your rating, please registered for rated before the contest is started.

before the competiton, the difficulty is unknown.

if you view problems first and decide whether to reated by its difficulty, it's not in line with the spirit of competition

It was just a weird looking binary search with l, r conditions inside a for loop

#include <bits/stdc++.h>
using namespace std;
namespace __gnu_pbds {}
using namespace __gnu_pbds;
#define fast ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define ll long long
#define ld long double
#define all(v) v.begin(),v.end()
#define F first
#define S second
#define pb push_back
#define mp make_pair
#define pi pair<int,int>
#define pii pair<int,pi>
#define rep(i,n) for(int i=0;i<n;i++)
#define rrep(i,n) for(int i=n-1;i>=0;--i)
#define cusrep(i,a,b,j) for(int i=a;i<b;i+=j)
#define rng(i,a,b) for(int i=a;i<b;i++)
#define rrng(i,a,b) for(int i=a;i>b;--i)
#define ar array


void run_case() {
    int n,x,y;
		cin >> n >> x >> y;
		int d = y - x;
		vector<int> c(n);
		rep(i,n) cin >> c[i];
		vector<ll> v(n-1);
		rep(i,n-1){
			ll t1 = 1LL * x * abs(c[i+1] - c[i]);
			if((t1%d)!=0){
				cout << -1;
				return;
			}
			ll t2 = 1LL * x * (c[i] - c[i+1]);
			v[i] = t2/d;
		}
		int l = 0;
		int r = c[0];
		ll ans = -1;
		while(l <= r){
			int m = (l + r) / 2;
			ll now = m;
			bool ok = true;
			rep(i,n-1){
				now = 1LL * v[i] + now;
				if(now < 0){
					l = m + 1;
					ok = false;
					break;
				} else if(now > c[i+1]){
					r = m - 1;
					ok = false;
					break;
				}
			}
			if(ok){
				ans = m;
				l = m + 1;
			}
			
		}
		if(ans==-1)
			cout << ans;
		else {
			ll fans = ans;
			ll now = ans;
			rep(i,n-1){
				now = 1LL * v[i] + now;
				fans+=now;
			}
			cout << fans;
		}
}

int main() {
	fast;
	int t;
	t = 1;
	while(t--){
      run_case();
	}
}

Same. E felt much easier than C this time.

Actually easy is subjective here, a lot of people do participate on multiple platforms, and the idea of C is pretty much common in these days rounds(across platforms) and even in past contests. Had it been a new problem, the number of submissions would have been proportionate to it's difficulty.

basically, some base math

I don't think it was necessarily hard, but it required the right observation(s) through math. For example, I made a silly mistake at one point which led to me wasting time implementing the wrong thing. (I had derived the required formula/equation really early in my math but kept going without noticing for some reason.)

Solve 4,and had something about D, them the contest ends

Do you mean easy ?

I agree

C is not very hard.It is only use "gcd" and "thinking deep".Although I don't passed in Contest.And it is only 30 lines in C++. https://atcoder.jp/contests/abc432/submissions/70993232

you solved it? C?

Agree

what is it — the easy generating function ? The previous D was just bfs .

bruhh bro you won't belive this 😭 I'm guessing that weight might be Y*A[0] when A is sorted for superstitious reason then pray it would AC or either disprove my guess and then solving X( + k ) + Y(A[i] — k) = W (W = Y*A[0] and finding minimum k) then boom it AC I don't even know how does it work but mannn math is prolly magic I do not comprehend it of what it does or I do understand why it even true that W = Y*A[0] 👍 well it might not I don't know I'm just dumb it may be the test that weak or I just guess the right shit this time but anyway 😭

nevermind I solved it just now, using if (D / d == 0) { instead of if (D % d == 0) { f***ed me up :(.

but it was D today. after spending 20 minutes on it, I skipped it and went to E, which was also too hard for me

cnt(x) will gives count of how many elements in A <= x and val(x) will gives sum of all elements of A that <= x, I implement this using segment tree to handle update of type 1, for answering of type 2 I look at number line and using logic to solve it using information from cnt(x) and val(x)

if ai < l it becomes l and if it is > r , it becomes r .. using fenwick u can compute the sum of numbers which are in [l,r] and you can maintain how many < l and > r no.s in another fenwick .

Refer image

not a pure math solution but, you get the minimum A[i] and multiply it by Y to get the max possible weight, and just initialize the other Ns to A[i] * Y. Then correct the remaining candies.

https://atcoder.jp/contests/abc432/submissions/70991682

I thought of Implementing Binary Search. But it was absolute Math

I made two arrays — mins and maxs. If Max of mins is greater than Min of maxs, then -1. Otherwise, Max of mins is the max possible weight. Each child gets it. bigCount += (MaxOfMins — mins[i]) / (big — small) ok, and all mins[i] % (big — small) should be equal, otherwise -1

If a child takes k big candies, we can rewrite his total candy weight as: k*Y + (a[i] — k)*X This simplifies to: a[i]*X + k*(Y — X) = a[i]*X + k*diff

When is equalization impossible?

1) If for any pair (i, j), the difference cannot be fixed using steps of diff: (a[i] — a[j]) * X % diff != 0 because adding multiples of diff can never make them equal.

2) If even the maximum big-candy child cannot be brought down to the minimum: max(a[i]) * X > min(a[i]) * Y

How many big candies to keep?

Binary search on how many big candies the maximum child can take. Check if for a mid = number of big candies: min(a[i]) * Y >= max(a[i]) * X + mid * diff If true → possible, otherwise adjust the search.

You need to just implement it lol, unfortunately there's nothing better :(. Basically what really helps is splitting up the rectangles and then moving them. My friend unforgettablepl has coded up a solution which is actually really clean if you ignore the diabolical variable names:

His code: https://atcoder.jp/contests/abc432/submissions/70996579

EDIT: If you want a saner version of the same idea, my code: https://atcoder.jp/contests/abc432/submissions/70997552

You don’t need to do a 3^n because you can simply remove 1 bit from your mask at a time and count how many masks with correct sum you reach on the way to 0. This works because if you have some group that has the correct sum, its complement must necessarily also be a correct sum, as otherwise it would be impossible to do.

this is just my 2cent so don't take it seriously, for each i we know that X*0 + Y*A[i] = Wi-max and after this we could adjust it down(decrease it) one time like to X(0 + 1) + Y(A[i] — 1) = Wi-max — (Y — x) or 2 time like X(0 + 2) + Y(A[i] — 2) = wi-max — 2*(Y — x), so after knowing Wi-max for each instance i we could adjust it down by (Y — X) repeatedly ! that means assuming all instance starting with maximum weight it can be solve if we can all adjust it down by (Y — X) for each of them till they meet at some common value since each time we adjust weight by decrease it with (Y — x) that means they(all Wi-max) must all share common residue modulo (Y — X) to be able to all drop their value to meet at the same common point in the first place, and we did just that by setting the common point to be highest possible which is Y*A[0] (after sorted A of course) anddd then all other Wi-max(Y*A[i]) can just drop them self down by (Y — X) repeatedly to meet at this common point ! since they all start further (when i > 0 , Wi-max >= Y*A[0] hold)