# Mo team learning notes

Time：2022-4-26

And indicate the original author: @ blog Park: continue_ 1025, creation is not easy, please understand.

## Ordinary Mo team

### Introduce a small example

\(zl\)My sister has a string of numbers. Because students are too bald, now he wants to ask you\(m(m≤1e5)\)Times, of which\(L\)reach\(R\)Number of interval occurrences\(3\)How many times and above?

### Solution

#### Segment tree

Inefficient and difficult to maintain.

\(p.s.\)\(lmpp\)The giant said if\(3\)If you can wait for one time, the line segment tree is more efficient. The giants can try it by themselves. The dishes are not demonstrated here)

So introduceMo team——An off-line algorithm for interval problems

### 0. Origin of algorithm name

Mo team algorithm, in which “Mo” refers to the national team Mo Tao giant, ccccorz.

### 1. Basic principles

Mo team isBeautiful violence

Let’s go back to the beginning and help\(zl\)Sister.

\(Continue\)He was a fool, so he made a violent attack;

``````for(int i=l;i<=r;i++)
{
cnt[a[i]]++;
if(cnt[a[i]]>=3)
ans++;
}``````

If you call like this every time you ask, obviously,\(O(nm)\)Our algorithm is to make\(zl\)My sister is embarrassed. （\(zl\)Sister: are you serious?

Smart you picked up the fool\(Continue\)It’s a pity to throw away the violence.

So you begin to transform the violent result just now.

You think, now that we know\([L,R]\)Well, the result\([L-1,R]\)\([L+1,R]\)\([L,R-1]\)\([L,R+1]\)Can’t the results be easily obtained together?

This is a good thing, so you extend this property to all inquiries.

In detail, for convenience, we might as well refer to the four answers obtained from the promotion asExtension interval, the original interval corresponding to the interval will be extended\([L,R]\)callOriginal interval。 As long as we knowOriginal intervalThe answer, then the requestExtension intervalThen you can ask.

So now the question is:“How to make the inquiry interval a promotion interval”。 Further, since we were unable to change the inquiry, the question became“How to make the extended interval match the “query interval”

Obviously, we can passConstantly modify the original intervalThe way, come onmatchingConsistent with the inquiry intervalExtension interval

Obviously, thisChanging rangeWe can operate through\(while\)Loop implementation.

But if every time\(while\), our code is still a fool’s code——meeting\(T\)It was terrible\(g2020\) \(lvt\) \(&&\) \(dlz\)(big man)

So the next step is the Mo team in real application:Block+\(sort\)

### 2. Basic Mo team

With some of the above inferences, now you realize that every time you askAdjust the size of the original interval according to the size of the query interval, and since the query interval is not the same (otherwise the question will be meaningless), soThis operation is inevitable

Under certain circumstances, we should make the operation as fast as possible, so as to achieve beautiful violence.

By analyzing the above process again, we find that the main time consumption of this operation comes fromThe process of locking the required intervalSo we should try our bestReduce the difference between the generalization intervals required each time, in order toThe number of times of changing the range is reduced and the efficiency is improved.

The only way to achieve this is to sort the query intervals

This is the name of the beautiful Mo team\(sort\)part

As for the ranking criteria, it is natural to rely onBlockCome on~

Since we require the two intervals to be as similar as possible, we should meet the monotonicity, otherwise it will waste time.

As shown in the figure.

Note: the purple curve represents the length to be moved each time the section is locked.

Figure 1 shows the unsorted effect. We can see that the shadow part is moved repeatedly, which is a waste of time.

As long as it is sorted into Figure 2, the intervals to be moved will no longer overlap~

The nodes are reasonably divided into different intervals by blocks, so that they can be compared quickly.

WeSort by the block where the left endpoint is located. If it is in the same block, compare the right endpoint。 In this way, we can scientifically and effectively reduce the time~

### 3. Code

I understand all the above. Next is a template code of ordinary Mo team. General questions can be changed into patterns. (of course, it can’t be regarded as the team with power and the team on the tree)

\(Problem\):HH Necklace

This question\(luogu\)It is the card of Mo team (but there is still a fairy giant card). The positive solution is a tree array.Practice is just here。 A6 points and T4 points are almost the same. Mainly thought, thought!

``````#include
#include
#include
#include

using namespace std;

const int maxn=2e6+10;
const int inf=1<<30;

{
int s=0;
int f=1;
char ch=getchar();
while(ch'9')
{
if(ch=='-')
f=-1;
ch=getchar();
}
while(ch>='0'&&ch<='9')
{
s=(s<<1)+(s<<3)+ch-'0';
ch=getchar();
}
return s*f;
}

int n,m;
struct Num
{
int l,r; // Query interval
int num; // Answers to questions
int id; // Order of inquiry
}a[maxn];

int temp[maxn];

int bel[maxn]; //belong

bool cmp(Num x,Num y)
{
return ((bel[x.l]==bel[y.l]) && (x.ry)
swap(x,y);
a[i].l=x;
a[i].r=y;
a[i].id=i;
}

sort(a+1,a+m+1,cmp);

int l=1,r=0;
for(int i=1;i<=m;i++)
{
int x=a[i].l;
int y=a[i].r;

//Process of locking interval
while(l>x)
while(ly)
Dele(temp[r]),--r;

a[i].num=ans;
}

sort(a+1,a+m+1,cmp2); // The offline algorithm outputs the answers in the original order

for(int i=1;i<=m;i++)
printf("%d\n",a[i].num);
return 0;
}``````

stay\(zl\)Inspired by my sister’s grateful eyes, go further!

## Power Mo team

### Introduce a small example

\(zl\)My sister has a string of numbers. Because he is so cute, now I add an operation on the basis of the original: put the second\(k\)Number becomes\(num\)

### Solution

Since the query operation is still reserved for the current problem, we still consider using Mo team to solve it.

Due to the operation of modifying the value, we need Mo team to store the data. Therefore, we introduce a new structure:Power Mo team

### 1. Basic principles

The basic principle of the weighted Mo team is the same as that of the ordinary Mo team.

A violent fool\(Continue\)I think so:
`As long as the modification related to the current interval is entered every time, it will be modified immediately`

Obviously, this will\(TLE\), because the interval may be uncertain.

It’s a lot like the problem we had when we first dealt with the basic Mo team. So this time, we use the same\(sort\)To solve it.

We add a keyword\(tim\) \((time)\), which recordsThe sequence number of the modification operation affected by the current query\(sort\)The time will be\(tim\)As the third keywordIn this way, it can not only ensure the correctness of the basic team’s handling of inquiry operations, but also deal with modification operations in time. Because the complexity of modification operation is low, it will not be changed\(TLE\)It’s too late.

Modify to create a structure separately,\(perfect\)

### 3. Code

\(Problem\)Number color

There is a giant in the solution of this problem. He used the idea of transformation when modifying the operation. My code is much worse, soPortalJust put it here. You can go and see it.

This problem is still a Kamo team, so if the number of blocks is set to a constant, there will be no card.

Many bigwigs are divided into blocks\(k\)Set to(ah, yes, this picture is copied), because it’s the fastest. Its specific proof stampThe big man’s solution, the food is better than me. I can’t come and understand it（

## End.

### Acknowledge

thank\(zl\)My little sister unconsciously provided me with spiritual support.

Thank myself for being a big dish.

## IOS development judges whether the mobile phone has escaped from prison

This paper mainly introduces three ways to detect prison break 1. Judge by the prison break documents added after prison break Judge whether these files exist, add them to the array and traverse the array. If there is any file, it is considered to be a prison break – (BOOL)isJailBreak { NSArray *jailbreak_tool_paths = @[ […]