Idea: Roms

**Tutorial**

Tutorial is loading...

**Solution (pikmike)**

```
for tc in range(int(input())):
a, b, c = map(int, input().split())
print(1 if a < c else -1, end=" ")
print(b if c < a * b else -1)
```

Idea: Roms

**Tutorial**

Tutorial is loading...

**Solution (Roms)**

```
for _ in range(int(input())):
s = input()
print('DA' if min(s.count('0'), s.count('1')) % 2 == 1 else 'NET')
```

Idea: Roms

**Tutorial**

Tutorial is loading...

**Solution (Roms)**

```
for _ in range(int(input())):
s = input()
cur, mn, res = 0, 0, len(s)
for i in range(len(s)):
cur += 1 if s[i] == '+' else -1
if cur < mn:
mn = cur
res += i + 1
print(res)
```

1373D - Maximum Sum on Even Positions

Idea: vovuh

**Tutorial**

Tutorial is loading...

**Solution (vovuh)**

```
#include <bits/stdc++.h>
using namespace std;
int main() {
#ifdef _DEBUG
freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
#endif
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n);
for (auto &it : a) cin >> it;
vector<vector<long long>> dp(n + 1, vector<long long>(3));
for (int i = 0; i < n; ++i) {
dp[i + 1][0] = max(dp[i + 1][0], dp[i][0] + (i & 1 ? 0 : a[i]));
if (i + 2 <= n) dp[i + 2][1] = max(dp[i + 2][1], max(dp[i][0], dp[i][1]) + (i & 1 ? a[i] : a[i + 1]));
dp[i + 1][2] = max(dp[i + 1][2], max({dp[i][0], dp[i][1], dp[i][2]}) + (i & 1 ? 0 : a[i]));
}
cout << max({dp[n][0], dp[n][1], dp[n][2]}) << endl;
}
return 0;
}
```

Idea: BledDest

**Tutorial**

Tutorial is loading...

**Solution 1 (BledDest)**

```
#include<bits/stdc++.h>
using namespace std;
int n, k;
bool decimalLess(const string& s, const string& t)
{
if(s.size() != t.size())
return s.size() < t.size();
for(int i = 0; i < s.size(); i++)
if(s[i] != t[i])
return s[i] < t[i];
return false;
}
void upd(string& ans, const string& cur)
{
if(ans == "-1" || decimalLess(cur, ans))
ans = cur;
}
void read()
{
cin >> n >> k;
}
void solve()
{
string ans = "-1";
for(int i = 0; i <= 9; i++)
{
int cnt9 = n / 9;
if(i + k < 10)
cnt9 = 0;
for(int j = 0; j <= cnt9; j++)
{
if(i + k >= 10 && j == 0)
continue;
int curSum = (i + (i + k)) * (k + 1) / 2;
if(j != 0)
{
int cntBefore = 10 - i;
int cntAfter = k + 1 - cntBefore;
curSum = (i + 9) * cntBefore / 2 + cntBefore * 9 * (j - 1) + (1 + cntAfter) * cntAfter / 2;
}
curSum = n - curSum;
if(curSum < 0 || curSum % (k + 1) != 0)
continue;
string curNum = {char('0' + i)};
for(int z = 0; z < j - 1; z++)
curNum += "9";
int maxNum = 9;
if(i + k >= 10)
maxNum = 8;
curSum /= (k + 1);
while(curSum != 0)
{
int d = min(curSum, maxNum);
maxNum = 9;
curSum -= d;
curNum.push_back(char('0' + d));
}
reverse(curNum.begin(), curNum.end());
upd(ans, curNum);
}
}
cout << ans << endl;
}
int main()
{
int t;
cin >> t;
for(int i = 0; i < t; i++)
{
read();
solve();
}
}
```

**Solution 2 (pikmike)**

```
def get(s):
return str(s % 9) + '9' * (s // 9)
for tc in range(int(input())):
n, k = map(int, input().split())
k += 1
bst = 10**100
for d in range(10):
ends = 0
for i in range(k):
ends += (d + i) % 10
if ends > n:
continue
if d + k > 10:
for cnt in range(12):
s = 9 * cnt * (10 - d)
if s > n - ends:
break
for nd in range(9):
ns = s + (10 - d) * nd + (k - (10 - d)) * (nd + 1)
if ns > n - ends:
break
if (n - ends - ns) % k == 0:
bst = min(bst, int(get((n - ends - ns) // k) + str(nd) + '9' * cnt + str(d)))
elif (n - ends) % k == 0:
bst = min(bst, int(get((n - ends) // k) + str(d)))
print(-1 if bst == 10**100 else bst)
```

Idea: adedalic

**Tutorial**

Tutorial is loading...

**Solution 1 (adedalic)**

```
#include<bits/stdc++.h>
using namespace std;
#define fore(i, l, r) for(int i = int(l); i < int(r); i++)
#define sz(a) int((a).size())
#define x first
#define y second
typedef long long li;
typedef pair<int, int> pt;
const int INF = int(1e9);
const li INF64 = li(1e18);
int n;
vector<int> a, b;
inline bool read() {
if(!(cin >> n))
return false;
a.resize(n);
fore(i, 0, n)
cin >> a[i];
b.resize(n);
fore(i, 0, n)
cin >> b[i];
return true;
}
struct func {
int minx, mink, maxk;
func() : minx(0), mink(0), maxk(0) {}
func(int minx, int mink, int maxk) : minx(minx), mink(mink), maxk(maxk) {}
};
func getFunc(int a, int b) {
if (a <= b)
return func(0, b - a, b);
else
return func(a - b, 0, b);
}
func merge(func a, func b) {
if (a.minx == -1 || b.minx == -1)
return func(-1, -1, -1);
if (a.maxk < b.minx)
return func(-1, -1, -1);
if (a.mink >= b.minx)
return func(a.minx, min(b.maxk, b.mink + (a.mink - b.minx)), min(b.maxk, b.mink + (a.maxk - b.minx)));
else {
int add = b.minx - a.mink;
return func(a.minx + add, b.mink, min(b.maxk, b.mink + (a.maxk - b.minx)));
}
}
inline void solve() {
func total = getFunc(a[0], b[0]);
fore(i, 1, n)
total = merge(total, getFunc(a[i], b[i]));
if (total.minx != -1 && total.minx <= total.mink)
cout << "YES\n";
else
cout << "NO\n";
}
int main() {
#ifdef _DEBUG
freopen("input.txt", "r", stdin);
int tt = clock();
#endif
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
int tc; cin >> tc;
while(tc--) {
read();
solve();
#ifdef _DEBUG
cerr << "TIME = " << clock() - tt << endl;
tt = clock();
#endif
}
return 0;
}
```

**Solution 2 (Ne0n25)**

```
#include <bits/stdc++.h>
using namespace std;
typedef long long li;
const int N = 1000 * 1000 + 13;
int n;
int a[N], b[N];
void solve() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
for (int i = 0; i < n; ++i) scanf("%d", &b[i]);
li need = 0, add = 0, extra = 2e9;
for (int i = n - 1; i >= 0; --i) {
if (b[i] < need) {
puts("NO");
return;
}
li val = b[i] - a[i];
li to_add = min(extra, max(0LL, val - need));
add += to_add;
extra = min(extra - to_add, b[i] - need - to_add);
need = max(0LL, need - val);
}
puts(add >= need ? "YES" : "NO");
}
int main() {
int t;
scanf("%d", &t);
for (int i = 0; i < t; ++i)
solve();
}
```

**Tutorial**

Tutorial is loading...

**Solution (Roms)**

```
#include <bits/stdc++.h>
using namespace std;
const int N = int(2e5) + 9;
int n, k;
int m;
int t[8 * N];
int add[8 * N];
int cnt[2 * N];
void push(int v, int l, int r) {
if (r - l != 1 && add[v] != 0) {
t[v * 2 + 1] += add[v];
t[v * 2 + 2] += add[v];
add[v * 2 + 1] += add[v];
add[v * 2 + 2] += add[v];
add[v] = 0;
}
}
void upd(int v, int l, int r, int L, int R, int x) {
if (L >= R) return;
if(l == L && r == R) {
t[v] += x;
add[v] += x;
return;
}
push(v, l, r);
int mid = (l + r) / 2;
upd(v * 2 + 1, l, mid, L, min(R, mid), x);
upd(v * 2 + 2, mid, r, max(L, mid), R, x);
t[v] = max(t[v * 2 + 1], t[v * 2 + 2]);
}
void upd(int l, int r, int x) {
upd(0, 0, n + n, l, r, x);
}
int get(int v, int l, int r, int L, int R) {
if (L >= R) return 0;
if (l == L && r == R) return t[v];
push(v, l, r);
int mid = (l + r) >> 1;
return max(get(v * 2 + 1, l, mid, L, min(R, mid))
, get(v * 2 + 2, mid, r, max(L, mid), R));
}
int get(int l, int r) {
return get(0, 0, n + n, l, r);
}
int getAns(set <int> &smx) {
if (smx.empty()) return 0;
return max(0, get(0, *smx.rbegin() + 1) - n);
}
void build(int v, int l, int r) {
if (r - l == 1) {
t[v] = l;
return;
}
int mid = (l + r) >> 1;
build(v * 2 + 1, l, mid);
build(v * 2 + 2, mid, r);
t[v] = max(t[v * 2 + 1], t[v * 2 + 2]);
}
int main(){
scanf("%d %d %d", &n, &k, &m);
build(0, 0, n + n);
set <pair<int, int> > s;
set <int> smx;
for (int i = 0; i < m; ++i) {
int x, y;
scanf("%d %d", &x, &y);
int pos = abs(x - k) + y - 1;
pair <int, int> p = make_pair(x, y);
if (s.count(p)) {
--cnt[pos];
if (cnt[pos] == 0) smx.erase(pos);
upd(0, pos + 1, -1);
s.erase(p);
} else {
++cnt[pos];
if (cnt[pos] == 1) smx.insert(pos);
upd(0, pos + 1, 1);
s.insert(p);
}
printf("%d\n", getAns(smx));
}
return 0;
}
```

Been waiting for this editorial for so long...

Can someone explain E — Sum of Digits more clearly...? Thank you in advance.

https://www.youtube.com/watch?v=MD552gJLNYk

"sub_comfirmation=1" ??

Finally :):)

Sir,Can you kindly help me regarding problem B?Can u kindly explain how alice and bob are giving the optimal moves according to the editorial? If the string is 1011010 alice shud remove that 01 or 10 on whose both sides the bits are same...

No matter which one pair Alice and Bob remove there is always same number of total moves(equal to

min(c0,c1)).So any possible move is going to be optimal.By taking several examples,i was able to deduce that but then How to relaize it during the contest??And I would also like to know how you deal with these problems that have these optimal moves in their problem statements?I find it difficult to decide what is optimality in terms of the given moves just like in this problem where each move as u say is optimal Thanks in advance if someone kindly replies to this

Think of it this way. You will not be able to make a move only when 0s or only 1s remain but not both. Because if both remain there will always be at least a pair of 0 and 1 adjacent and we will be able to remove this. In every move, the count of 0s and 1s get reduced by one each. So the total number of moves are always equal to minimum of count of 0s and 1s.

Sir,that much I have understood from the editorial.What I say is it is difficult for me to deduce what kind of move is actually an optimal move in terms of the given game.Sometimes,any move is optimal as in this given problem and sometimes there will be particular moves that will be optimal..

You can easily prove this by contradiction. Assume there is no more moves possible and the string has both

`0`

and`1`

. But if both 0 and 1 exist then there must be at least one 0 with 1 as its adjacent neighbor and vice-versa.Hence the opposite only wins when there is only 1 or 0 in the string.

vovuh is really back

Please help me, i can't figure out what is wrong in my code. my code

I am not sure about it but maybe the issue is with datatype, You can try to resubmit it with long.

It is giving 'signed integer overflow' with long.

Yeah, so change int to long long

It is already long long.

Try putting "ans = 0ll", I also faced similar situation but finally solved using it.

In D, what does the author mean by " started reversing the subarray but didn't end it"?

Reversing will not stop at this index. It will continue further

Problem 1 seemed to be harder than 2 and 3 to me!

1 was a bit harder than 2, 3 was fine

Did someone tried problem D with Binary search approach??

Can anyone please help me figure out why is this O(n) solution for F getting TLE on case — 9 https://codeforces.com/contest/1373/submission/85147824

Thanks in advance for the help.

use fast input like scanf

Thanks a ton for your help.

Hey 92anurag ! Can you please explain your approach to F? Thanks

Didn't get the solution of E. Can someone plz explain.

Hey Perry_Prasad_Platypus

Check out the detailed explanations of Problem E

I am sure you will understand the logic by the end :)

Bro, you are a newbie, no offense, but you should create a YT channel when you reach CM or master. Focus on studies.

It's a team account for our student chapter We don't take rated contests with this account Our team members are Experts, CMs and Masters :)

Oh, ok then, but why this account is rated?

You know a problem is beautiful when its an E but can still be solved by brute force.

In Problem D, may be I getting it wrong, please correct me. I am implementing the first approach for this test case.

10

7 8 4 5 7 6 8 9 7 3.

here, total sum for even position = 33

and, total sum for odd position = 31

v1 = [1, 1, -1, -1, -4], pairs are (8,7),(5,4),(6,7),(9,8),(3,7)

v2 = [-1, -1, 1, 1, 4], pairs are (7,8),(4,5),(7,6),(8,9),(7,3)

so reversing the first 4 elements provide 2. so 33 + 2 = 35.

I know I can get maximum value just by replacing 8,4. But what I missed from the editorial?

Add another dp that changes 1 with 2, 3 with 4 elements etc. You are now only trying to change 0 with 1, 2 with 3, and so on.

I don't know how u implemented but I guess u had not taken the case of subarray being started with a even positioned index. U missed comparisions of (i)th even index with (i+1)th odd index.

I slightly changed the ordering when the two consecutive elements were considered starting from odd position and got accepted Check this 85213408

In Problem D, can someone explain the DP Approach. I get the idea but I'm unable to implement.

`Transitions are pretty easy:`

Not for Me , I guess ! Please someone explain them Thanks!

Well I can try explainging the transitions. The transition dp(i+1,0) is straightforward.

The transition dp(i+2,1):-> Suppose the array is ---(----)--- and the array elements within paranthesis denotes the subarray(from index 4 to 8) we need to reverse then when we are at index 4 then we start to reverse the subarray and the transition will be from 4 we need to got 6 with values reversed hence we need to take the value of dp(4,0) but at index 6 we will make a transition to 8 and notice that when making this transition the maximum value will be for dp(6,1) not dp(4,1). This type of reversal is taken into account because the reversal of an array of size 2x is same as reversing array of size 2 in x moves hence dp(i+2,1)=max(dp(i+2,1,max(dp(i,0),dp(i,1))+(i%2==0?a(i+1):a(i))

The last transition dp(i+1,2):-> Now suppose we are at an index where we have ended reversing the subarray then at this index what transitions we are left with are the max sum until index i + the sum at remaining even indices therefore the transition looks like dp(i+1,2)=max(dp(i+1,2),max(dp(i,0),dp(i,1),dp(i,2)+(i%2==0?a(i):a(i+1)).

For transition dp(i,0) It means the answer on the prefix till i and in which we didn't make any reverse. Here actually stores the sum of prefix even position values.

For transition dp(i,1) It means the answer on the prefix till i and from where the reverse is started. if i is even and we started to reverse from that index that means the value of index i+1(i+1 th index value will going to be even parity index for reversing) will be contributing on the answer for dp(i,1) and if i is even and we started reverse from that index that means the value of i will be contributing on the answer for dp(i,1).

For transition dp(i,2) It means the answer on the prefix till i and from where the reverse will be finished. If i is even the value of index i will be contributed to the answer, otherwise nothing more will be contributed. Because if i is odd then it is already added to the answer as the reversing started formerly.

(sorry for my poor english)

your explanation is really good thanks a lot.

https://codeforces.com/contest/1373/submission/85228862

Problem:We need to determine the maximum sum that we can get after reversingat mostone subsegment of the sequence, and this sum is defined to be that of the elements at even indicesafterthe operation.Solution:Since we are changing at most one subsegment, we need to keep track of those changes, simultaneously while maintaining the maximum sum. Say, we need to update the range[l, r)(I'm deliberately using the notation with right endpoint open, you'll see why). This range will partition the sequence into three sub-ranges:[1, l)(the range to the left of updated range),[l, r)(the updated range), and[r, n + 1)(the range to the right of updated range). For each of these three sub-ranges, we'll maintain onedp-array(this explains why there aredp[][0],dp[][1],dp[][2]). Now onto the second dimension.1. The Left Part:dp[i][0]is the maximum sum that you get wheniis in the left part. To maintain this, we just follow the definition of the sum(ifiis even, we include it, otherwise, we discard it):2. The Middle Part:dp[i][1]is the maximum sum that you get wheniis in a segment that we intend to reverse. Note that it isn't necessary that the segment must start ati, it can be anywhere in-between. Now since reversing odd length ranges doesn't benefit even a penny, we'll simply ignore them and incrementiby2for this array as we make transitions. To maintain this, we'll just take the maximum ofdp[i - 2][0](meaning the middle segment starts at i) anddp[i - 2][1](it started somewhere earlier in the past but it continues still). The cost at this index just depends on the parity ofi(as with everything else in this question apparently): ifiis even, we keep element ati + 1(since that'll be odd, and if we don't keep it we'd be ignoring it when we make the next jump of 2), otherwise, we simply keep the element ati:3. The Right Part:dp[2][i]is the maximum sum that you get wheniis in the segment where the reversal has already happened. It could either happen atthisindex or has already been sometime back in the past (or probably it never happened or never will be). To maintain it is to simply take the maximum of all these three possibilities. And the cost again depends on the parity ofi: if it's odd, ignore it (because either it has been taken care of by the lastdp[1][ ], meaningi = ror it's strictly in the right so it meets ignorance there too). If it's even, it's included nevertheless. Notice that the cost is exactly similar to the left part (as it should be).Finally, the answer is just the maximum of

dp[n][0], dp[n][1],anddp[n][2]depending on arguments that I believe you canpretty easilycome up with now :)I unable to understand why we take a[i+1] for even index and a[i] for odd index in the middle part. Can you explain it in detail?

Read the question properly. I'm sure you'll get it.

Hint:we're flipping the middle segment, remember?wish everyone could explain like you. loved it. although you have something to fix in the middle zone i think. 'dp[i — 2][0] (meaning the middle segment starts at i)' might be ' dp[i — 2][0] (meaning the middle segment starts at i-2)'. and in the third zone, dp[i+1][2] = max(dp[i][1],dp[i][2]) + (i%2 == 0)*a[i] might be enough i reckon

superb explanation

Not sure tho, but i think u made a typo in the middle part, u wrote dp[i+2][0] instead of dp [i+2][1] ?

Thanks, that

actuallywas a typo. I fixed it along with some other typos that were there earlier.One more and easiest solution of D can be as follows :

Firstly sum all values at even indices and replace them with value*-1 i.e.(arr[i] = -1*arr[i]) and after that find maximum sum subarray of even length using dp whose recurrence is simply

dp[i] = max({0,arr[i]+arr[i+1],arr[i]+arr[i+1]+dp[i+2]) .

My Code

Thank You and Happy Coding!!!

great approach, thanks for sharing.

nice approach but i am curious to know how and why this approach came to your mind??

Can you please explain how did u think this logic ?

Thanks, it was brilliant approach! Kind of "modified Kadane's algorithm" and making sure that the length is always even..It was the closest approach in the direction I was thinking.

Can anyone please explain logic of C... I did't get it.

Firstly calculate the prefix sums of the string.

Now let's look till which index we can go using the initialized values.

When x=0, (Suppose x is the initialized value.)

We can go till the first time we get -1 in the prefix sum.

When x=1, We can go till the first time we get -2 in the prefix sum.

In this way for x=n We can go till the first time we get -(n+1) in the prefix sum.

So if we keep track of the first index prefix sum we get we can easily calculate till which length we can go using that initialize value. And the very first time for which initialize value we don't get any negative prefix sum that time we can go till end.

Suppose the string --+-.

Corresponding prefix sum -1,-2,-1,-2.

Here for x=0, we can go till index 1 (Suppose 1 indexed string) for x=1, we can go till index 2 for x=2, we can go till index 3 for x=3, we can go till the end (As we didn't get -3 in prefix sum) So the answer is = 1+2+3+4 = 7

Thank you very much !

Thanks man

then why if curr<mn: mn=curr

Please detail Es tutorial with proofs and explain more clearly.

Hey AM_I_Learning

Check out the detailed explanations of Problem E

I am sure you will understand the logic by the end :)

After checking your video editorial only I asked you in comments there also for proof and also I asked here for someone to prove why this 9 philosophy works, but I have build some intuition now, which allow me to accept this.approach.

UPD :- you replied nicely on YouTube, post it here as well so that it helps many others.

After watching the video: Link

Below is my reply on YT comment where someone asked my why it's giving the min value of X.

It's simple, we are looping through all possible values of nines (number of nines at the middle) and all possible values of the last digit d Now for a particular value of (nines, D) we are getting the sum of digits of the prefix which I am forming greedily which ensures that for a particular pair (nines, D) the number formed is smallest. And we store ans as the minimum of all possible X which is getting formed with the given pair of (nines, D) Watching the video will help :)

thank you for your helpful video, i understand it now, btw i don't know why you got so many downvotes =)))

I think the reason behind so many downvotes is that he is using a fake account.

This is not a fake account brother Actually we are a team of coders and upload videos through a common account.

If anyone wants to do 1373E - Sum of Digits by Number Theory " short and precise" , you can see my submission here 85157600 I have given proper comments. Let me know if you have difficulty understanding any part of it.

godsend!!

I just have 2 questions, why are we looping from -1 to 120, the indices for array can stretch further and why are we going from -100 to 9 in the inner loop? Thanks

The value of P is just an approximation of where the number lies.

After we get the approx. position of the P. We brute force through for arr[] as it is not simple to know where the next (k+1) sum is equal to n, as it is using sum of digits of the number. And I stretched the ranges to [-1,120] and [-100,9] just to be safe. Also I was lazy to find a proper range for those.

i ∈ [-1,120] is used to shift through arr[x+i],

while i ∈ [-100,9] is used for arr[x]+i; // arr[] as in code

If you see though some examples you will see it is a safe range and if an answer don't come in it, then an ans is not possible

Got it! Thanks!!

can someone explain editorial solution of F..i am not able understand it from editorial

For Problem D, just use Kadane’s Algorithm twice ,

Just take the array of differences (Odd index — Even index) ;

At last add the maximum in sum(even indexes)

Here's my submission : 85055641

great solution..i wasn't able to understand other solutions this was quite easy to understand thanks...

Thanks bro, I'm glad it was of help. Don't know why people downvoted it though.

85227537 Some help with this..

This can also be referred

can you please explain your approach why you are taking difference pairs and how it is leading to max sum?

In my code the "even" variable" stores the sum of the even indexes. After that the "max" variable" uses Kadane's Algo for difference pairs(Odd — Even, because we need to maximize Even)so we check what sequence of Odd and Even should be interchanged, After interchanging, the sum of even indexes of the new array will be previous "even" sum + "max" difference of the sequence of pair which gives maximum means that if we reverse those pairs we will obtain the maximum for Even indexes.

And to know why it gives max result see Kadane's algo.

Thanks,this really helped!

Thanks for the explanation

Thanks,this helped a lot!

This is a really nice and clear solution :-)

The dynamic programming approach with those dp[][] hmm... I guess I still need to think about it to understand it :-(

I still cannot understand A :(

"At first notice that if there exists a value for the second shop, then the value divisible by b also exists. " Why will it exist?

"For any x you can round it up to the nearest multiple of b." Where has this been used in the answer?

"then the value with 1 modulo b also exists (exactly 1 donut on top of some number of full boxes)." I really dont get this idea

Why have we split to x=b and x=1.

Thanks

I also couldn't fully follow the solution from the editorial. What really help me is to visualize the problem. We have two functions: f = a*x and g = (floor(x/b)+1)*c. The g function looks like stairs. If you draw these two function, the solution is very intuitive. For example from the graph it will be clear that there are three cases (I) a>=c, (II) a<=c/b and (III) c/b<a<c. Only the case (III) is a bit non-trivial where either shop can be cheaper.

Hope it helps.

This helps but I cant see how hack each case further

For item a, buying any amount of things will have the same price per thing. For item b, the cheapest price per thing will be when you buy b things. The most expensive will be when you buy 1 thing because you are forced to round it up to b since b > 1. From these deductions the answer is simple — to answer q1 compare prices for buying 1 thing: a < c — to answer q2 compare prices for buying b things: c < a * b

solution of D using kadane's algorithm code

For those who need some help with understanding the editorial :)

Check out the detailed explanations of:

Problem E

Problem D

Problem C

Problem B

Problem A

An alternative solution for problem F which uses this fact: There always exists a solution where nothing of $$$b_i$$$ is used to cover $$$a_{i+1}$$$ for some $$$i$$$ (this is true since we can transform any solution where this is not true to one where it is true by some sort of shifting).

If we know this $$$i$$$ we can just start assigning there with a greedy algorithm. To find $$$i$$$ in linear time we can just assume it to be $$$0$$$ and start with the greedy algorithm. If at some point we encounter an error we know that non of the indices between $$$0$$$ and our current position is a valid choice for $$$i$$$. So we can just choose $$$i$$$ as our current position and continue in the same way.

After the greedy algorithm reaches $$$n$$$, we have found one value for $$$i$$$ that either is correct or none such value for $$$i$$$ exists. We can then just run the greedy algorithm from $$$i$$$ and check if it works.

my implementation: 85071270

Could you elaborate a bit more on why when we get error while assigning values with greedy approach then indices from 0 to current position aren't a valid choice for i?

the error occurs because we can't satisfy a demand $$$a_j$$$. If we would choose any starting position between 0 and j we would have even less from $$$b$$$ available because everything would shift to the left.

Or alternatively, if we start at $$$0$$$ we can use we can use some of $$$b_0$$$ and all of $$$b_1$$$ for $$$a_1$$$ but if we start at $$$1$$$ we can't use some part of $$$b_0$$$. Thus every choice between $$$0$$$ and $$$i$$$ would result in an error at position $$$i$$$ (maybe even earlier).

OK thanks. I get it now

Video solution for problem G:

Link to the video: https://youtu.be/Nuym8ejFH_w

[Problem E] Can anyone proof that the answer should be in the form of "(prefix) (nines) (d)", where "prefix" does not end with 9, "nines" is a series of 9 and "d" is a single digit? For example, the answer might be like 198999992 (prefix = "198", nines = "99999", d = "2"). Or, am I making a mistake?

"Oops"

In that case, the answer is still in the form: "prefix" = 4998, "nines" = (empty) and "d" = 9

Sorry seems like I misunderstood your question.... anyway the proof you are looking for comes from the fact when you find the smallest decimal numbers for which give digit sum : 1,2,3,4,..... the obtained series are: 1,2,3,4,5,6,7,8,9,19,29,39,49,59,69...199,299,399,499,.......1999,2999,3999,..... you can see it in by submission the formed arr[] 85157600

your code is giving 799897 for 150 2 which does not match pattern

Sorry, but I didn't quite get you. Which pattern are you matching it with??

this pattern (any number)(nines)(not a nine)

It is following the pattern:

but the last number has to be a single digit

no the last digit need not to single, it can be greater than or equal to 0.

they wrote this(don't forget that the last digit should not be 9) in tutorial

Bro, the tutorial is talking about middle part (x)

(7998)(9)(7)

Finally, I come up with the proof. At first, we have to notice that ALL numbers can be expressed by the form "(

prefix) (nines) (d)" as in my previous comment. Please note thatprefixandninesare allowed to be empty. Then we just greedily constructprefixpart (of course to minimize the answer) while checking constraints:k+1 numbers is equal tonprefixdoes not end with 9Thanks by that proof.

Can someone explain Solution 2 for problem F?

can anyone pls tell me what is happening in the question plus and minus

just iterate from i = 0 to inf by taking cur = i, and for each iteration traverse the string from 0 to s.size(). while traversing if the character is '-' so decrease cur by 1 (cur--) otherwise increase it(cur++). if the cur < 0 so stop traversing otherwise stop iteration. Hope its help.thankyou.

D can also be solved using a sliding window approach. Did anyone else do that? I wanna check if I can reduce the lines of code in my solution :D

I find B so elegant. I submitted a suboptimal solution that also passed, I guess because it was B both were allowed. But the editorial solution is so so elegant!

Can someone explain the second solution of F?

In prob E, how can we be sure that the 2nd LAST digit of the answer should not be 9 (in the case our last digit may go over 9 only, like 99 100 101)

on the problem D .. "first array DEONTE the profit"....

Why did I get time limit exceeded on problem F when I solve it in o(n * log(maxval)), by binary searching how many houses the first station contributes to the second city? https://codeforces.com/contest/1373/submission/85451412

Nevermind, I managed to get accepted. The problem was using cin for input, I switched to scanf.

Can someone help me with problem c? I really did not get why these formulas used?

can someone please help me in this submission link https://codeforces.com/contest/1374/submission/85383254 problem (E) i am getting error in test case 5.

Can someone explain the dp solution of question D in detail?

can any one explain me why i am getting TLE on 5th test case

my sublission is 85516199

you will get TLE when the test case is many -1 -1 -1 -1 ... -1,at this time ,your code is O(n*n)

okay,thanks

Don't need two dimensional DP for problem D, & I do believe this an easier dp to understand. https://codeforces.com/contest/1373/submission/86189153 If you require an explanation just comment.

Please do explain your code

Ok so the best ans can either be the sum without any reversals or : 'prefix up til i + reversed sum from i to j + suffix from j onward'. Since a reversal can start from any index i we will evaluate for all indices.

So dp(i) is the best sum from i to end such that the reversal starts at i or there is no reversal.

If i is odd, then dp(i) = max(dp(i + 2) + a[i], suffix) now whats happening here is that we can start reversing from this point on which would the mean to remove a[i + 1] ie even indexed position value & add a[i] instead and then take the best sum from i + 2 onward (omitting the even indexed value). We can also choose to do nothing & if we do make that choice then we have to take the suffix according to the definition of the dp (if you're wondering why I didn't take dp(i + 1) you'll find in doing so there is a risk to do multiple subarray reversals which isn't allowed & also because it goes against the definition of the dp).

If i is even, then dp(i) = max(dp(i + 2) + a[i + 1], suffix) same reasoning as odd, to reverse we'll just add value at i + 1 instead of i & that will basically work as a reversal or if we do nothing just use the suffix uptill ith index.

Now since our dp table is ready we can compute the ans like so, for all i: ans = max(prefix from 0 to i — 1 + dp(i), ans). Since all dp's are best sums from i and onward, such that reversal start from i, the only choice for the sum before i is the preifx sum.

If there are any more queries just comment.

Thank you so much Man !! I finally understood how to solve this.

You're welcome :)

can someone explain problem c

If anyone need Detail Explanation(not a video tutorial) of D (without DP,prefixsum) Here

Can someone explain the solution 2 by Neon for problem F?

can some one explain how can i made this code more efficient (pluses and minuses) my submission is 85773685

For problem D, I am unable to understand the 2nd and 3rd transitions for the dynamic programming approach.

I came up with a greedy solution for F:

First make each $$$i$$$ th station give as much as possible to the $$$i$$$ th city without going over $$$a[i]$$$ and give the rest to the $$$(i + 1) \bmod n$$$ th city.

Then make each $$$i$$$ th station transfer as much excess as possible from the $$$i$$$ th city to the $$$(i + 1) \bmod n$$$ th city.

Code: 86164186

This was my first guess, and it turned out to be correct. I'm wondering why this works though, is anyone able to prove it?

how can we get 4 for testcase 42 7 for problem E

nlogn soln for F :) We just need to check for every subarray of circle that sum of bridges surrounding to cities (considered in subarray) is greater than equal to sum of households in cities (considered in subarray).

link to my submission

I think we should add +1 or −1 to all values on some prefix.

So this sentence does not make sense.

For Probelm D, in the transition for dp[i+1][2] why are we taking max over dp[i][0] ? If we have stopped reversing the array then dp[i][0] can never lead to dp[i+1][2] since 0 means we have not reversed the array. Am I missing something? Same code without dp[i][0] expression passes the test cases. Here is the link

What is the Hall's theorem based solution for F ?

For every circular segment, you need to ensure that the total number of connections provided to them is not less than the number of households. It can be shown that this condition is sufficient and necessary using Hall's theorem. This results in a simple $$$O(n)$$$ algorithm. 94510173

How does the dp transition in D ensure that there won't be multiple flips. For example — if dp[i][1] at some stage gets bigger than dp[i][0] and so in calculating dp[i+1][2], we used the former but later dp[i][0] gets larger and so,we use it in the calculation.

My solution For problem D is giving wrong answer.

Problem is with maxSubarrayfunction which calculates maximum subarray in an array. I ran same function on geeks for geeks and leetcode and it is getting accepted there. Can someone point out any problem with that function.In the author's solution for D., How will we make sure that we have reversed the array only once?

in dp[i+2][1] we are accounting for only max of dp[i][0] and dp[i][1]..which means that either the reverse will start from current index or is still in progress.we are not accounting for dp[i][2] in this which means there is no such reverse that has been completed before i+2.

Alternative solution to 1373G - Pawns (suboptimal for this problem, but maybe useful for similar problems where you can't use segment tree):

Let $$$v$$$ be a sorted vector with the current values of $$$i$$$ (defined like in the editorial). The goal is to find the maximum value of $$$v_j - j$$$.

You can use sqrt decomposition. The idea is to keep $$$v$$$ in a data structure divided into buckets of size around $$$\sqrt m$$$. You should keep the maximum value of $$$v_j - j$$$ for each bucket. Note that it's possible to update a bucket manually and to calculate the maximum in the whole vector, both in $$$O(\sqrt m)$$$.

The data structure may become unbalanced, but it can be fixed by rebuilding it from scratch every $$$\sqrt m$$$ queries.

Submission: 129511005