Codeforces Round #848 (Div. 2) AE game-time thinking + correct solution

Qingda Konjac for the first time in the official div 2 div2A c Acin$d$$i$$v$$2$$Ac$ has five questions, and it is also the best performance of the little konjac in history. After this, my cf may also turn yellow.

A. Flip Flop Sum
Question meaning: given a $a——i$ array, the weight is only 1 or -1, we select two adjacent bits and flip them (1 to -1, -1 to 1), what is the maximum sum that can be obtained, n <= 2 e 5$n<=2e5$ .
Idea: Violently enumerate all adjacent bits and flip them to find the maximum sum.
the code

B. The Forbidden Permutation
title meaning: Given a length of $n$ permutation array$p$ , gives you the length inmmArray aa$with\; m$ and different elements$a$ , an array is bad if and only if all$1<=i<m$满足$pos(a_i)<pos\left(a_{(}{i}_{+}{1}_{)}\right)<pos\left(a_i\right)+d$，$pos\left(x\right)$ means$x$ value at$The\; position\; of\; the\; a$ array, the following operations can now be performed, we can exchange$Adjacent\; items\; of\; the\; p$ array, how many operations can we perform to make$a$ array is good,$n<=2e5,m<=2e5，a_i<=n$ .
The idea is to destroy the condition of the bad array. We found that what he requires is that all adjacent positions must be satisfied. We consider a minimum cost that is not satisfied. Consider two cases, consider a ( i + 1$a(i+1)$ move to$a\left(i\right)$ front or$a(i+1)$ move to$a(i)+After\; d$ , the cost can go to the minimum value.
the code

C. Flexible String
Meaning of the question: Give you two lengths of nnthe string aaof$n$$a$ 、$b$ , we define the value as$(l,r)$ for the number of satisfying requirements$(l<=r,l>=1,r<=n)$ , satisfy the requirement if and only if$a(l,r)==b(l,r)$ The substrings from l to r of string a are the same as the substrings from l to r of string b.
We define a$Q$ stack, we can do the following, we can putaaai a_i$of\; a$ string$a_i$Put it on $In\; the\; Q$ pile, then put$a_i$Replace with any character $c$, Q Q The number of different strings in the$Q$$K$ types, find the maximum value of the string after several operations, the title guarantees the string$a$、 b b The type of strings that appear in$b$$k<=10,n<=2e5$ .
Idea: Consider binary enumeration of 10, enumerate all legal states, and find the maximum value of the string corresponding to the state. Time complexity$O(2^k\ast n)$
code

D. Flexible String Revisit
title meaning: give you two lengths of nnthe binary stringaa$of\; n$$a$ 、$b$ , the value of the string is only$0,1$ , we can randomly select a subscript$i$ , after$ai$ inversion$(0to1,1to0)$ , ask the expected number of operations required to make the two strings the same.

Idea: consider transforming the problem and turn the problem into $ai$ sumbi biThe same number of$bi$$k$ , different numbers can be deduced as$n-k$ .
Then we put$ai$ sumbi biThe same number of$bi$$k$ is called state$k$ , we consider the state$k$ to statennThe expected operation of$n$$dp\left[k\right]$ times.
1. One operation, we chose$ai$ sum$The\; subscript\; in\; bi$ is the same, because it was the same before, it becomes different after inversion, then the state is transferred to the state$k-1$ .
2. One operation, we chose$ai$ sum$The\; subscripts\; in\; bi$ are not the same. Due to the inversion, the different subscripts become the same subscripts and shift to the state$k+1$ .
It can be deduced that the formula is:$$dp[k]=1+k/n\ast dp[k-1]+(n-k)/n\ast dp[k+1]$$ Take a look at this formula, we found that dp [ k − 1 ] and dp [ k + 1 ] dp[k - 1] and dp[k + 1] are
out of the formula$dp[k-1]anddp[k+1]$ , such a formula cannot find the answer.

We consider transforming the angle, we consider from state $k$ to state$k+1$ desired desired operation$dp\left[k\right]$ times, the answer is$dp\left[k\right]$ from$m$ to$n-The\; sum\; of\; 1$ , the cause is$m$ to$n$ , we first spend$dp\left[m\right]$ becomes$m+1$ , then spend$dp[m+1]$ becomes$m+2$ ... and so on cost$dp[n-1]$ to$n$ .
Consider state transitions.
1. One operation, we chose$ai$ sum$The\; subscripts\; in\; bi$ are not the same. Due to the inversion, the different subscripts become the same subscripts and shift to the state$k+1$ , the number of operations is 1.
2...Operate once, we choose$ai$ sum$The\; subscript\; in\; bi$ is the same, because it was the same before, it becomes different after inversion, then the state is transferred to the state$k-1$ , we start from state$k-1$ becomes$k+1$ needs to go through$dp[k-1]$ operation becomes state$k$ , then go through$dp\left[k\right]$ operations become state$k+1$ , the number of operations is$1+dp[k-1]+dp\left[k\right]$ .
The formula becomes:$$dp[k]=(n-k)/n+k/n\ast (1+dp[k-1]+dp[k])$$
considering simplification, the simplification process is as follows:

The final formula becomes $$dp[k]=n/(n-k)+k/(n-k)\ast dp[k-1]$$
Just transfer this formula, the initial value$dp[0]=1$ , because the transfer from 0 to 1 must be one time, because the same one is empty, you can only choose from different ones, and then find$m-(n-1)$的$dp\left[k\right]$ and can be.
the code

E. The Tree Has Fallen!
Title: Give you a tree with a size of $A\; tree\; of\; n$ , each point has value$ai$ , with$q$ times of inquiry, each inquiry starts with$r$ is the root, inuuSelect several points in the$u\; subtree\; so\; that\; the\; weight\; XOR\; sum\; of\; these\; points\; is\; the\; largest,\; and\; output\; the\; largest\; XOR\; sum.$
Idea: consider going offline, we turn all inquiries into questions$r$ for root,$The\; form\; of\; the\; largest\; XOR\; sum\; of\; the\; u$ subtree, and then we pass$dfs$ , first pass$dfs$ maintains sz[u] sz[u]rooted at 1Maximum XOR sum of$sz$$[$$u$$]$$dfs$ is similar to root$The\; idea\; of$$dp$ is maintained by$u$ is the maximum XOR sum (linear basis) of other node subtrees rooted at u, and then processes all queries offline.
Principle: The only difference between all maintained subtree information with two subtrees as the root is the path information between the two subtrees (the direction of the rooted tree is different), and then we can consider maintaining the information of 1 subtree first, Then use$The\; dfs$ feature (which can maintain the passing path information) can solve the problem.
The graphics and text of the principle will be updated in the future to facilitate understanding. Linear base merging is the basic content, so I won’t go into details here for the time being.
the code