### awoo's blog

By awoo, history, 5 weeks ago, translation,

1989A - Catch the Coin

Idea: BledDest

Tutorial
Solution (awoo)

1989B - Substring and Subsequence

Idea: BledDest

Tutorial
Solution (Neon)

1989C - Two Movies

Idea: BledDest

Tutorial
Solution (Neon)

1989D - Smithing Skill

Idea: BledDest

Tutorial

1989E - Distance to Different

Idea: BledDest

Tutorial
Solution (BledDest)

1989F - Simultaneous Coloring

Idea: BledDest

Tutorial
Solution (awoo)
• +96

 » 5 weeks ago, # |   0 Fast tutorial
 » 5 weeks ago, # |   +1 Interesting problemset
 » 5 weeks ago, # |   +6 For problem D I kind of simulated the process by brute force, submission: 267758186Notice that if crafting and smelting cost $a_i - b_i$ of 2 kinds of weapons is equal, then it's never better to craft a weapon with a higher initial material cost $a_j$ if crafting and smelting cost $a_j - b_j$ of one kind of weapon is greater, it can only be useful to craft it if its material cost $a_j$ is lower In my solution I simulate the process by going from lower operation cost $a_i - b_i$ and higher material cost $a_i$ to higher operation cost and lower material cost. On each step remaining metals with amount of ingots $c_k < a_i$ are useless for me, and any metals with $c_k \geq a_i$ will be reduced to metals with remaining quantity less than $a_i$, but at least $b_i$.I was expecting this solution to get hacked or fail system tests, but somehow it's still standing (although I've seen some similar solutions getting hacked). After pondering on why did it not get TLE, I realized that each unique remaining value of $c_k$ will be considered at most once, and since there are at most $10^6$ unique values of $c_k$ the total time complexity will be amortized.This solution is a result of me gaslighting myself that there are no more than $O(\sqrt{max(a_i)})$ unique differences $a_i - b_i$ (which is obviously not true).
•  » » 5 weeks ago, # ^ |   0 I did exactly the same, also waited to be hacked and then understood..
•  » » 5 weeks ago, # ^ |   0 can you please explain why you were able to use each value of ck atmost once? also, why does using lower_bound work here, shouldn't you use maximum amount of ingots for the best case (minimum difference)
•  » » » 5 weeks ago, # ^ |   0 Let's go over from a brute force solution to a more optimized one step by step: Iterating over all kinds of weapons and then for each weapon iterating over all kinds of ingots is $O(N \cdot M)$ Now let's group different kinds of ingots with the same remaining quantity together, since if you can calculate the amount of xp for a single kind of metal with remaining $c_k$ ingots, you can do the same for $X$ kinds of metals with $c_k$ remaining ingots. You could store counts in an array or in a map. Since there could be $M$ unique values of $c_k$ you still would be iterating over all kinds of metals, leading to $O(N \cdot M)$ complexity Now get rid of the values which we cannot smelt anything from, on each step it's useless to consider values $c_k$ lower than $a_i$, this is where lower_bound comes in. Also notice that after each smelting operation all values $c_k \geq a_i$ will get mapped to some values strictly less than $a_i$. Picture it like this: you pick the largest $a_0$ first, you erase all values $c_k \geq a_0$, then you pick second largest value $a_1$ and erase all values $a_1 \leq c_k < a_0$, so on and so forth. In total you will not iterate over more than $max(a_i) = 10^6$ unique values of $c_k$ (probably even less under given constraints).
•  » » 5 weeks ago, # ^ |   0 I did what you stated in 267754245, but it got hacked :( Could anyone tell me what I missed in my solution?
•  » » 5 weeks ago, # ^ |   0 yeah, i also do the same thing and waited to be hacked. As the blogger said, this complexity is hard to think through on the field. But as long as we find this similar to the monotone queue optimization DP property, coupled with memory search, it is easy to amorize the complexity. If you were a hack, you would have to make each a minus b different and find a number, and then take the remainder of each of these A minus b's different, which is obviously impossible to do.
•  » » 5 weeks ago, # ^ |   0 actually the first observation isn't it better to use the high initial material cost first ? like because that would let us have more ingots retained finally because of b ? better for future use. similarly for second one too we can argue the same its better to try using the higher cost aj if thats not possible to craft then go to aj having lower cost , for future benefit .
 » 5 weeks ago, # |   0 Detailed Video Editorial | English Language
 » 5 weeks ago, # |   0 Can anyone explain me why lcs was not working in problem B I was able to solve but still confused where it could have gone wrong
•  » » 5 weeks ago, # ^ |   +3 lcs does not work because as per the question we need to find the longest contiguous substring of b that occurs as a subsequence in a. for example if a="ab" and b="sasb" the lcs is "ab" with length 2 but as we can see it is not useful for us as in our final string there must be a 's' between 'a' and 'b'. the answer string would be "sabsb" with length 5.
•  » » 5 weeks ago, # ^ |   0 Actually you needed to find the longest contiguous substring of b that occurs as a subsequence in a. It can be done using LCS algorithm only, it just need 1 little modification in the else part. Instead of finding max(dp[i — 1][j], dp[i][j — 1]), we can do this for (int i = 1; i <= n; i++) { for (int j = 1; j <= m; j++) { if (a[i - 1] == b[j - 1]) dp[i][j] = 1 + dp[i - 1][j - 1]; else dp[i][j] = dp[i - 1][j]; } } for (int i = 1; i <= m; i++) mx = max(mx, dp[n][i]); 
•  » » » 4 weeks ago, # ^ |   0 can you elaborate it aa bit more?i was trying the same thing but i don't know how this works.
 » 5 weeks ago, # | ← Rev. 2 →   +1 I don't understand, why not use greedy for values ​​of x <= A in D?
•  » » 2 weeks ago, # ^ | ← Rev. 2 →   0 actually we can get accepted by using greedy.here's the link.
 » 5 weeks ago, # |   0 I calculated the string using a bruteforce. It seems to be missing a testcase. What is it that I am missing in this: https://mirror.codeforces.com/contest/1989/submission/267683386
•  » » 5 weeks ago, # ^ |   0 you are ignoring the order when using the hashmap, for this test case for example: 1 cba abc the answer should be 5
•  » » » 5 weeks ago, # ^ |   0 Sorry the link was wrong, could you check this solution: https://mirror.codeforces.com/contest/1989/submission/267710157
•  » » » » 5 weeks ago, # ^ |   0 in the first while you ignore only characters from b that do not appear in a, this is not necessarily optimal, for example in this case: 1 abc acabc your code gives 6, when it should be 5.even if "ac" appears in the string a, it is better to ignore this prefix in the optimal solution.
•  » » » » » 5 weeks ago, # ^ |   0 Got it now. Thanks!
 » 5 weeks ago, # |   0 267914972 can anyone please explain why this might be giving a TLE? Is that the priority queue? I used it as a max-heap as I believe I should use maximum possible ingots each time, for the minimum difference in crafting and smelting
•  » » 5 weeks ago, # ^ |   0 i did the same and got tle.
 » 5 weeks ago, # |   0 problem B test case sample can drive you insane they can work with any wrong algorithm you come up with
•  » » 5 weeks ago, # ^ |   0 So LCS is one of the wrong algorithms?
•  » » » 5 weeks ago, # ^ |   0 yes, I used LCS earlier and got scammed
•  » » » » 5 weeks ago, # ^ |   0 Actually you needed to find the longest contiguous substring of b that occurs as a subsequence in a. It can be done using LCS algorithm only, it just need 1 little modification in the else part. Instead of finding max(dp[i — 1][j], dp[i][j — 1]), we can do this for (int i = 1; i <= n; i++) { for (int j = 1; j <= m; j++) { if (a[i - 1] == b[j - 1]) dp[i][j] = 1 + dp[i - 1][j - 1]; else dp[i][j] = dp[i - 1][j]; } } for (int i = 1; i <= m; i++) mx = max(mx, dp[n][i]); 
•  » » » » » 5 weeks ago, # ^ |   0 I got it.The ordinary LCS cannot tell which string is substring and which is subsequence.
 » 5 weeks ago, # |   0 can anyone please explain why i'm getting wrong answer on B 267919922
•  » » 5 weeks ago, # ^ |   0 The order of the elements in the string are important by just counting the elements, you are ignoring the order .
 » 5 weeks ago, # |   +2 As usual, BledDest blesses us with high-quality problems!
 » 5 weeks ago, # |   0 Can someone please help me with D. I can't figure out why this is giving TLE on testcase 5
 » 5 weeks ago, # |   0 Are D tests weak? My solution uses memoization with a vector of maps and passes in 2.8 seconds. My solution relies on the fact that if the net costs are very high or very low, then all of the metal is expended quickly. For this reason I think the worst case would be on the order of O(log n sqrt(max) n)? Submission: https://mirror.codeforces.com/contest/1989/submission/267939272
 » 5 weeks ago, # | ← Rev. 4 →   0 my solution for question e was this : https://mirror.codeforces.com/contest/1989/submission/267952069
 » 5 weeks ago, # |   0 tried solving B using dp, why doesn't it work?https://mirror.codeforces.com/contest/1989/submission/267759332
•  » » 5 weeks ago, # ^ |   0 If you are using LCS logic,it will not work in this question.
•  » » 5 weeks ago, # ^ |   0 Actually you needed to find the longest contiguous substring of b that occurs as a subsequence in a. It can be done using LCS algorithm only, it just need 1 little modification in the else part. Instead of finding max(dp[i — 1][j], dp[i][j — 1]), we can do this for (int i = 1; i <= n; i++) { for (int j = 1; j <= m; j++) { if (a[i - 1] == b[j - 1]) dp[i][j] = 1 + dp[i - 1][j - 1]; else dp[i][j] = dp[i - 1][j]; } } for (int i = 1; i <= m; i++) mx = max(mx, dp[n][i]); 
 » 5 weeks ago, # |   0 267826797 ques b) can anyone why its not giving right output or on which test case it fails
•  » » 5 weeks ago, # ^ |   0 bc bxbc
 » 5 weeks ago, # | ← Rev. 2 →   0 I tried to solve Problem C, I am calculating x, y pos & neg in similar way as shown in the editorial. after that i tried greedy approach, i got rid of the for loop and made both x and y equal by doing this. int temp; // assume x >= y temp=min(x-y,pos); y+=temp , pos-=temp; temp=min(x-y,neg); x-=temp , neg-=temp; now we have a simple case where x==y which can be solved easily by doing this x+=(pos>>1) , y+=(pos>>1); x-=(neg>>1) ,y-=(neg>>1); if((pos^neg)%2 && (neg%2)) { x--; } cout<
 » 5 weeks ago, # |   0 For people why LCS is not working for problem b actually you needed to find the longest contiguous substring of b that occurs as a subsequence in a. It can be done using LCS algorithm only, it just need 1 little modification in the else part. Instead of finding max(dp[i — 1][j], dp[i][j — 1]), we can do this for (int i = 1; i <= n; i++) { for (int j = 1; j <= m; j++) { if (a[i - 1] == b[j - 1]) dp[i][j] = 1 + dp[i - 1][j - 1]; else dp[i][j] = dp[i - 1][j]; } } for (int i = 1; i <= m; i++) mx = max(mx, dp[n][i]); 
 » 5 weeks ago, # |   +2 F can be solved by using the well-known Radecki algorithm
 » 5 weeks ago, # |   0 For problem D i have written same solution as given in tutorial but it is giving TLE on test case 9267975922 can anyone justify?
•  » » 5 weeks ago, # ^ |   0 no fastIO
•  » » » 5 weeks ago, # ^ |   0 got accepted thanks!
 » 5 weeks ago, # | ← Rev. 2 →   0 [resolved]
 » 5 weeks ago, # |   0 For D, I think I'm doing the same thing that's mentioned in the tutorial but I'm getting TLE. Can someone please help me here? I don't know what's causing the TLE. https://mirror.codeforces.com/contest/1989/submission/268040829
•  » » 5 weeks ago, # ^ |   0 I got it. IO was slow :( Adding ios::sync_with_stdio(false); resolved it
•  » » » 5 weeks ago, # ^ |   0 Bro you are a lifesaver. Thank you.
 » 5 weeks ago, # |   +1 Can anyone tell me how to do B by graphs?
 » 5 weeks ago, # |   0 Appreciate the Todd Howard reference in Q4
 » 5 weeks ago, # |   0 any one knows why the DP on problem C is wrongis it not always optimal to take the maximum min at each state ? I tried making a simple dp[n][2] dp[i][0] means to take the first option and extend from the maximum min from dp[i-1] and dp[i][0] means to take the second option and also extend max min from dp[i-1]can some help why this is wrong ? here is my submission https://mirror.codeforces.com/contest/1989/submission/268130928
•  » » 4 weeks ago, # ^ |   0 hey you got the answer? i was using the same approach but so far no luck with dp
•  » » » 4 weeks ago, # ^ | ← Rev. 2 →   0 no it's not solvable with dp it's not always optimal to only extend the maximum min, sometimes you need to extend a non optimal sub answer to reach the optimal final answer so it's not dp at all I guess. try to think greedy .
 » 5 weeks ago, # |   0 Can anyone please explain why this Code is not working? I can't find where I have made a mistake. Is my approach wrong?
 » 4 weeks ago, # |   0 Amazing editorial of D!!!
 » 4 weeks ago, # |   0 can someone tell why this submission is wrong 268881012 for problem C
 » 4 weeks ago, # |   0 Was it intentional that O(nlogn) solutions of D Fail or is my implementation just garbage? python code
 » 4 weeks ago, # |   0 Someone please explain why this solution is taking so long for larger values of c = 1e9, even after optimisation. It is supposed to run in O(max(a_i)*n) time but it's not. #include #include using namespace std; int main(){ int n, m; cin >> n >> m; vector a(n+1, 0), b(n+1, 0); vector c(m+1, 0ll); for(int i=1; i<=n; i++) cin >> a[i]; for(int i=1; i<=n; i++) cin >> b[i]; for(int i=1; i<=m; i++) cin >> c[i]; long long mx = 0ll; for(int i=1; i<=m; i++) mx = max(mx, c[i]); int mxA = 1e9, best =1e9; for(int i=1; i<=n; i++) mxA = max(mxA, a[i]), best = min(best, a[i]-b[i]); // for all c[i], in 1 to m, if c[i] is greater than max(a_i), make it down to c[i] <= max(a_i) vector dp(mxA+1, 0ll); // dp[0] will be used to store the answer for(int i=1; i<=m; i++){ if(c[i] > mxA){ long long k = (c[i]-mxA)/best; dp[0] += 2ll*k; c[i] -= k*best; } } // once, all the c[i] have become down to c[i] <= max(a_i), apply dp to maximise exp. for(int i=1; i<=mxA; i++){ for(int j=1; j<=n; j++) if(i >= a[j]) dp[i] = max(dp[i], dp[i -(a[j]-b[j])]+2); } // sum all the experiences for(int i=1; i<=m; i++) dp[0] += dp[c[i]]; cout << dp[0] << endl; return 0; }