About different-or hash

Re：distrusthash

Heterosyntactic hashing is an amazing algorithm that utilizes the specificity of the heterosyntactic operation and the principle that hashing reduces conflicts, and can be used to quickly find theWhether or not a combination occurs, whether or not a number in the sequence occurs\(k\) substandard

The algorithm is as the name suggests, dissimilarity + hashing.

Think of a certain song calledPPAP？

I have a \(\oplus\),I have an \(hash\).
(Uhh~) \(\oplus hash\) !

😅

differentiation

The most basic and important

Consider the fact that the different-or operation satisfies the law of exchange, i.e.\(a \oplus b=b\oplus a\)

Thus the dissimilarity values of different permutations of the combination are equal

This allows us to ignore the order and directly count the number of times the combination occurs.

hash (computing)

Due to the limited number of binary bits, there will be situations where the heterosynthesis is not correct, such as:\(1\oplus 2=5\oplus 6\)，\(1\oplus 2\oplus 3 = 4\oplus 8\oplus 12\)

Therefore it is necessary to hash the original data into larger numbersdiminishconflict probability

appliance

combinatorial issues

Let's go straight to a sample question.

here

There's no way someone who can't read English can't use a program to translate it, even though the translation program makes it look like a formula.

Directly along the lines of heterogeneous hashing, it is not difficult to write\(O(n^2)\) codes

int n,m;

mt19937_64 rnd(time(0));

unsigned long long code[N],chk[N],Xor[N],a[N];

signed main(){
	n=rd;
	for(int i=1;i<=n;i++){
		a[i]=rd;
	}
	
	for(int i=1;i<=n;i++){
		code[i]=rnd();
		chk[i]=chk[i-1]^code[i];
	}
	
	for(int i=1;i<=n;i++){
		Xor[i]=Xor[i-1]^code[a[i]];
	}
	
	int cnt=0;
	for(int i=1;i<=n;i++){
		for(int j=i;j<=n;j++){
			if((Xor[i-1]^Xor[j])==chk[j-i+1]){
				++cnt;
			}
		}
	}
	
	printf("%lld",cnt);
	return Elaina;
}

Turn it in with gusto... Mow~T up.

A look at the range of data:\(3*10^5\)

oh boy!\(O(n^2)\) affirmation(of clothes) classifier for number of washes Can't get through.

Consider further:

• The intervals that satisfy the condition must have\(1\) cap (a poem)Equal to the maximum value of the interval length \(max\)

Do two extensions to the right/left respectively:

found\(pos\) Record the last\(1\) The position of the current extension to the\(x\)

(coll.) fail (a student)\(x=1\) When the pointer is updated, the\(pos\)and reset\(mx\)

Or else you'll be primping back.\(mx=max(mx,x)\) number, a heterodyne hash is sufficient to determine whether it is legal or not.

int n,m;

int max(int a,int b){
	return a>b?a:b;
}

mt19937_64 rnd(time(0));

unsigned long long code[N],chk[N],Xor[N],a[N];

signed main(){
	n=rd;
	for(int i=1;i<=n;i++){
		a[i]=rd;
	}
	
	for(int i=1;i<=n;i++){
		code[i]=rnd();
		chk[i]=chk[i-1]^code[i];
	}
	
	for(int i=1;i<=n;i++){
		Xor[i]=Xor[i-1]^code[a[i]];
	}
	
	int cnt=0,pos=-1,cnt1=0,mx=0;
	for(int i=1;i<=n;i++){
		if(a[i]==1){
			pos=i,++cnt1,mx=1;
		}else if(pos!=-1){
			mx=max(mx,a[i]);
			if(i-mx+1<=pos)
				if((Xor[i]^Xor[i-mx])==chk[mx])
					++cnt;
		}
	}

	pos=-1;
	for(int i=n;i>=1;i--){
		if(a[i]==1){
			pos=i,++cnt1,mx=1;
		}else if(pos!=-1){
			mx=max(mx,a[i]);
			if(i+mx>=pos)
				if((Xor[i+mx-1]^Xor[i-1])==chk[mx])
					++cnt;
		}
	}
	
	printf("%lld",cnt+cnt1/2);
	return Elaina;
}

In fact when reversing it you can just REVERSE the array and run it again, so you don't have to copy and paste and type it twice.

And then it's AC.

The question of the number of occurrences

The essence of a binary different-or is to add each bit without rounding, i.e., each bit is added to take the modulus of 2, i.e.:

Suppose there is an operation\(③\)makes\(a\ ③\ a\ ③\ a=0\)namely

That's what it is.\(3\) Arithmetic of Progressions

extend to\(k\) The feed system can be used to solve the problem of whether or not the\(k\) Sub-issues

ull xork(ull a,ull b,int k){
	vector<int> vec;
	while(a||b){
	    vec.push_back((a+b)%k);
	    a/=k;
	    b/=k;
	}
	
	ull res=0;
	ull p=1;
	
	for(auto x:vec){
	    res+=p*x;
	    p*=k;
	}
	
	return res;
}

ull xork(ull x,ull y,int k){
	int sum=0,p=1;
//	if(y%2==0) swap(x,y);
	while(x||y){
		sum+=(x%k+y%k)%k*p;
		p*=k;
		x/=k;
		y/=k;
	}
	return sum;
}

Let's look at a sample problem.

here

Logan (name)

In fact, the previous question can also be found in a translated version in Logu.

First we know the idea that to prove a sufficient condition we have to show that it is both sufficient and necessary; similarly, to prove that a number is equal to a certain value, we must make it both less than or equal to and greater than or equal to that value.
Migrating to this problem, we let the number of occurrences of all numbers\(cnt = 3\) That's what we're going to do.\(cnt \geq 3 \land cnt \leq 3\) These two constraints

The first constraint can just paste a random dissimilarity hash.

The key is the second constraint.

We consider using an algorithm similar to the double pointer:

Consider for a constraint II satisfying\([l, r]\) Each time the right pointer is moved to the right, it destroys the original "satisfy constraint two" property. In order to satisfy it again, we need to move the left pointer all the way to the right, i.e., delete numbers from left to right so that the interval satisfies constraint two again.

Let the value of the newly added right pointer\(a_r\) It is sufficient that the number of occurrences is less than or equal to three; since such a deletion will not necessarily lead to a situation in which "constraint two is not satisfied because of a decrease in the number of occurrences of the other numbers", for obvious reasons.

honorific title\(pre_r\) because of\([1, r]\) of the prefix dissimilarity and.

When the deletion is complete, we count the number of users who satisfy the\(pre_r = pre_{pos}\) both (... and...)\(pos \in [l, r]\) (used form a nominal expression)\(pos\) This can be done using a map or a hash table.

Then the problem is complete, with complexity\(\mathcal{O}(N \log_2 N)\) Or purely linear.

And then about... Forget it. See for yourself.

discuss

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define ll long long
#define ull unsigned long long
#define rd read()
#define mkp make_pair
#define psb push_back
#define Elaina 0
inline ll read(){
	ll f=1,x=0;
	char ch=getchar();
	for(;!isdigit(ch);ch=getchar()) f=(ch=='-'?-1:1);
	for(;isdigit(ch);ch=getchar()) x=(x<<3)+(x<<1)+ch-'0';
	return f*x;
}
const int mod=1e9+7;
const int N=1e6+100;
const int inf=0x7fffffff;
 
int n,k;
 
mt19937_64 rnd(time(0));
 
ull code[N],pre[N],a[N],num[N];
map<ull,ull> mp; 
 
ull xork(ull x,ull y,int k){
	ull sum=0,p=1;
	while(x||y){
		sum+=(x%k+y%k)%k*p;
		p*=k;
		x/=k;
		y/=k;
	}
	return sum;
}

 
signed main(){
	srand(time(0));
	
	n=rd,k=3;
	for(int i=1;i<=n;i++){
		a[i]=rd;
	}
	
	for(int i=1;i<=N;i++){
		code[i]=rnd()%(1ll<<63);
	}
	
	for(int i=1;i<=n;i++){
		pre[i]=xork(pre[i-1],code[a[i]],k);
	}
	
	int cnt=0;
	mp[0]=1;
	for(int l=0,r=1;r<=n;++r){
		++num[a[r]];
		while(num[a[r]]>3){
			--num[a[l]];
			if(l>0) --mp[pre[l-1]];
			++l;
		}
		cnt+=mp[pre[r]];
		++mp[pre[r]];
	}
	
	printf("%lld",cnt);
	return Elaina;
}

\(x^2\) concern

Determine whether the product of a sequence of\(x^2\) ( $ x$ is some integer)

This one is a bit better, according to the Unique Decomposition Theorem

Among them.\(\alpha_1 \leq \alpha_2 \leq \alpha_3 \leq \dots \leq \alpha_k\)All prime numbers.

imitate

Then it is sufficient when this sequence prime factor occurs all even number of times.

practice

small picture of the tail

Titi~❤ Hey, hey, hey, hey. My Titi❤.

My lord!_{It's not easy to make.} Give me a compliment.