Toph: Another Update-Query Problem

0

Solution Idea:

The main idea behind the solution of this problem is simplifying the equation. For a query operation we need the answer of this equation-
1A_l + (1+d)A_l+1 + (1+2d)A_l+2 + (1+3d)A_l+3 + … + (1+(r-l)d)A_r
Now let the query range l r is 1 3. and the given array is A=[a1,a2,a3,a4,…]

So our quation will be-
1*a1 + (1+d)*a2 + (1+2d)*a3 + (1+3d)*a4
= a1 + a2 + d*a2 + a3 + 2d*a3 + a4 + 3d*a4
= (a1+a2+a3+a4) + d*(a2+ 2*a3 + 3*a4)

Now We can see that first part of this equation is only sum query which can be done using a segment tree and for 2nd part we can use a trick. We can pree calculate the sequence like this-
1*a1 + 2*a2 + 3*a3 + 4*a4 + 5*a5 + 6*a6 + 7*a7 + ……
When we need the 2nd part of the equation we can use this equation. We can get the 2nd part of the equation from this equation by this way-
(2*a2 + 3*a3 + 4*a4)-(a2+a3+a4) = (a2+ 2*a3 + 3*a4).

Now the above equation is also only a sum equation. We can apply any range sum query or range sum update on this equation and the the first sum equation.

So if we store this two equation in two segment tree then we can perform range update or query on the segment tree and get any range sum query from the segment tree and using the equation we can answer each query of the problem correctly.

```
#include &lt;bits/stdc++.h&gt;
#include &lt;ext/pb_ds/assoc_container.hpp&gt;
#include &lt;ext/pb_ds/tree_policy.hpp&gt;

#define pii              pair &lt;int,int&gt;
#define pll              pair &lt;long long,long long&gt;
#define sc               scanf
#define pf               printf
#define Pi               2*acos(0.0)
#define ms(a,b)          memset(a, b, sizeof(a))
#define pb(a)            push_back(a)
#define MP               make_pair
#define db               double
#define ll               long long
#define EPS              10E-10
#define ff               first
#define ss               second
#define sqr(x)           (x)*(x)
#define D(x)             cerr&lt;&lt;#x &quot; = &quot;&lt;&lt;(x)&lt;&lt;endl
#define VI               vector &lt;int&gt;
#define DBG              pf(&quot;Hi\n&quot;)
#define MOD              1000000007
#define CIN              ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define SZ(a)            (int)a.size()
#define sf(a)            scanf(&quot;%d&quot;,&amp;a)
#define sfl(a)           scanf(&quot;%lld&quot;,&amp;a)
#define sff(a,b)         scanf(&quot;%d %d&quot;,&amp;a,&amp;b)
#define sffl(a,b)        scanf(&quot;%lld %lld&quot;,&amp;a,&amp;b)
#define sfff(a,b,c)      scanf(&quot;%d %d %d&quot;,&amp;a,&amp;b,&amp;c)
#define sfffl(a,b,c)     scanf(&quot;%lld %lld %lld&quot;,&amp;a,&amp;b,&amp;c)
#define stlloop(v)       for(__typeof(v.begin()) it=v.begin();it!=v.end();it++)
#define loop(i,n)        for(int i=0;i&lt;n;i++)
#define loop1(i,n)       for(int i=1;i&lt;=n;i++)
#define REP(i,a,b)       for(int i=a;i&lt;b;i++)
#define RREP(i,a,b)      for(int i=a;i&gt;=b;i--)
#define TEST_CASE(t)     for(int z=1;z&lt;=t;z++)
#define PRINT_CASE       printf(&quot;Case %d: &quot;,z)
#define LINE_PRINT_CASE  printf(&quot;Case %d:\n&quot;,z)
#define CASE_PRINT       cout&lt;&lt;&quot;Case &quot;&lt;&lt;z&lt;&lt;&quot;: &quot;
#define all(a)           a.begin(),a.end()
#define intlim           2147483648
#define infinity         (1&lt;&lt;28)
#define ull              unsigned long long
#define gcd(a, b)        __gcd(a, b)
#define lcm(a, b)        ((a)*((b)/gcd(a,b)))

using namespace std;

//using namespace __gnu_pbds;
//typedef tree&lt;int, null_type, less&lt;int&gt;, rb_tree_tag, tree_order_statistics_node_update&gt; ordered_set;

/*----------------------Graph Moves----------------*/
//const int fx[]={+1,-1,+0,+0};
//const int fy[]={+0,+0,+1,-1};
//const int fx[]={+0,+0,+1,-1,-1,+1,-1,+1};   // Kings Move
//const int fy[]={-1,+1,+0,+0,+1,+1,-1,-1};  // Kings Move
//const int fx[]={-2, -2, -1, -1,  1,  1,  2,  2};  // Knights Move
//const int fy[]={-1,  1, -2,  2, -2,  2, -1,  1}; // Knights Move
/*------------------------------------------------*/

//int Set(int N,int pos){return N=N | (1&lt;&lt;pos);}
//int reset(int N,int pos){return N= N &amp; ~(1&lt;&lt;pos);}
//bool check(int N,int pos){return (bool)(N &amp; (1&lt;&lt;pos));}
/*------------------------------------------------*/

#define mx 100005
#define segment_tree int l=n*2,r=l+1,mid=(b+e)/2
struct data
{
ll sum, ssum, prop;
data()
{
sum=0,ssum=0,prop=0;
}
};

data tree[3*mx];

ll ara[mx];

ll interval_sum(ll b, ll e)
{
ll x=(e*(e+1))/2;
ll y=(b*(b-1))/2;
return (x-y+MOD)%MOD;
}

void push_down(int n, int b, int e)
{
if(tree[n].prop)
{
segment_tree;
tree[l].sum+=((mid-b+1)*tree[n].prop)%MOD;
tree[r].sum+=((e-mid)*tree[n].prop)%MOD;
tree[l].ssum+=(interval_sum(b,mid)*tree[n].prop)%MOD;
tree[r].ssum+=(interval_sum(mid+1,e)*tree[n].prop)%MOD;
tree[l].prop+=tree[n].prop%MOD;
tree[r].prop+=tree[n].prop%MOD;
tree[l].sum%=MOD;
tree[l].ssum%=MOD;
tree[l].prop%=MOD;
tree[r].sum%=MOD;
tree[r].ssum%=MOD;
tree[r].prop%=MOD;
tree[n].prop=0;
}
}

void init(int n, int b, int e)
{
if(b==e)
{
tree[n].sum=ara[b]%MOD;
tree[n].ssum=((ll)b*ara[b])%MOD;
tree[n].prop=0;
return;
}
segment_tree;
init(l,b,mid);
init(r,mid+1,e);
tree[n].sum=(tree[l].sum+tree[r].sum)%MOD;
tree[n].ssum=(tree[l].ssum+tree[r].ssum)%MOD;
tree[n].prop=0;
}

void update(int n, int b, int e, int i, int j, ll val)
{
if(b&gt;j || e&lt;i) return;
if(b&gt;=i &amp;&amp; e&lt;=j)
{
tree[n].sum+=((ll)(e-b+1)*val)%MOD;
tree[n].ssum+=(interval_sum(b,e)*val)%MOD;
tree[n].prop+=val;
tree[n].sum%=MOD;
tree[n].ssum%=MOD;
tree[n].prop%=MOD;
return;
}
push_down(n,b,e);
segment_tree;
update(l,b,mid,i,j,val);
update(r,mid+1,e,i,j,val);
tree[n].ssum=(tree[l].ssum+tree[r].ssum)%MOD;
tree[n].sum=(tree[l].sum+tree[r].sum)%MOD;
}

data query(int n, int b, int e, int i, int j)
{
if(b&gt;j || e&lt;i) return data();
if(b&gt;=i &amp;&amp; e&lt;=j)
return tree[n];
push_down(n,b,e);
segment_tree;
data p=query(l,b,mid,i,j);
data q=query(r,mid+1,e,i,j);
data ret;
ret.ssum=(p.ssum+q.ssum)%MOD;
ret.sum=(p.sum+q.sum)%MOD;
return ret;
}

int main()
{
//    freopen(&quot;in.txt&quot;,&quot;r&quot;,stdin);
//	  freopen(&quot;out.txt&quot;,&quot;w&quot;,stdout);

int t;
sf(t);
TEST_CASE(t)
{
int n,q;
sff(n,q);
loop1(i,n) sfl(ara[i]);
init(1,1,n);
LINE_PRINT_CASE;
while(q--)
{
int a,b,c,d;
sfff(a,b,c);
sf(d);
if(a==1)
{
update(1,1,n,b,c,d);
}
else
{
data ret=query(1,1,n,b,c);
ll sum=ret.sum;
ret=query(1,1,n,b+1,c);
ll ssum=(ret.ssum-(((ll)(b)*ret.sum)%MOD)+MOD)%MOD;
ssum*=(ll)d%MOD;
ssum%=MOD;
ll ans=(sum+ssum)%MOD;
printf(&quot;%lld\n&quot;,ans);
}
}

}

return 0;
}

```

SPOJ: SEGSQRSS – Sum of Squares with Segment Tree

0

Solution Idea:

This problem is a nice example of segment tree with lazy propagation. All you need to solve this kind of problem is to do some experiment with the formula and convert them into a suitable form. From which we can drive the segment tree solution.

In this problem given an integer array A=[a1,a2,a3,a4…]. You need to perform 3 kinds of operation on it.

type 0: Set all the element in the interval l to r to x.
type 1: Increase all the element in the interval l to r by x.
type 2: Print the value of square sum of the interval l to r. For example let l=1 and r=3. then you need to print a1^2 + a2^2 + a3^2.

At first think we have a pre-calculated square sum array. Then if we perform type 1 operation which is increase it by x then what scenario will happen?

Our sum now become (a1+x)^2 + (a2+x)^2 + (a3+x)^2. Let expand this equation-

(a1+x)^2 + (a2+x)^2 + (a3+x)^2
= a1^2+ 2*a1*x + x^2 + a2^2+ 2*a2*x + x^2 + a3^2+ 2*a3*x + x^2
= (a1^2 + a2^2 + a3^2) + 3*x^2 + 2*x*(a1 + a2 + a3)

for a range l to r the generalized equation is –

(a_l^2 + a_l+1^2 +….+ a_r^2) + (r-l+1)*x^2 + 2*x*(a_l + a_l+1 +….+ a_r)

We can store the information about sum, square_sum, type_0 lazy and type_1 lazy of an interval in each segment tree node. And perform type 1 operation then we can calculate then sum value for a node over a range by multiplication and square sum value by above equation.

For every type 0 operation we can simply put the value of sum and square sum by using some basic calculation and arithmetic multiplication operation.

And for every type 2 operation we just need to get the sum of square sum value over a range l to r.

So we can perform each of 3 operation using a segment tree with lazy propagation.

```
#include &lt;bits/stdc++.h&gt;
#include &lt;ext/pb_ds/assoc_container.hpp&gt;
#include &lt;ext/pb_ds/tree_policy.hpp&gt;

#define pii              pair &lt;int,int&gt;
#define pll              pair &lt;long long,long long&gt;
#define sc               scanf
#define pf               printf
#define Pi               2*acos(0.0)
#define ms(a,b)          memset(a, b, sizeof(a))
#define pb(a)            push_back(a)
#define MP               make_pair
#define db               double
#define ll               long long
#define EPS              10E-10
#define ff               first
#define ss               second
#define sqr(x)           (x)*(x)
#define D(x)             cerr&lt;&lt;#x &quot; = &quot;&lt;&lt;(x)&lt;&lt;endl
#define VI               vector &lt;int&gt;
#define DBG              pf(&quot;Hi\n&quot;)
#define MOD              1000000007
#define CIN              ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define SZ(a)            (int)a.size()
#define sf(a)            scanf(&quot;%d&quot;,&amp;a)
#define sfl(a)           scanf(&quot;%lld&quot;,&amp;a)
#define sff(a,b)         scanf(&quot;%d %d&quot;,&amp;a,&amp;b)
#define sffl(a,b)        scanf(&quot;%lld %lld&quot;,&amp;a,&amp;b)
#define sfff(a,b,c)      scanf(&quot;%d %d %d&quot;,&amp;a,&amp;b,&amp;c)
#define sfffl(a,b,c)     scanf(&quot;%lld %lld %lld&quot;,&amp;a,&amp;b,&amp;c)
#define stlloop(v)       for(__typeof(v.begin()) it=v.begin();it!=v.end();it++)
#define loop(i,n)        for(int i=0;i&lt;n;i++)
#define loop1(i,n)       for(int i=1;i&lt;=n;i++)
#define REP(i,a,b)       for(int i=a;i&lt;b;i++)
#define RREP(i,a,b)      for(int i=a;i&gt;=b;i--)
#define TEST_CASE(t)     for(int z=1;z&lt;=t;z++)
#define PRINT_CASE       printf(&quot;Case %d: &quot;,z)
#define LINE_PRINT_CASE  printf(&quot;Case %d:\n&quot;,z)
#define CASE_PRINT       cout&lt;&lt;&quot;Case &quot;&lt;&lt;z&lt;&lt;&quot;: &quot;
#define all(a)           a.begin(),a.end()
#define intlim           2147483648
#define infinity         (1&lt;&lt;28)
#define ull              unsigned long long
#define gcd(a, b)        __gcd(a, b)
#define lcm(a, b)        ((a)*((b)/gcd(a,b)))

using namespace std;

//using namespace __gnu_pbds;
//typedef tree&lt;int, null_type, less&lt;int&gt;, rb_tree_tag, tree_order_statistics_node_update&gt; ordered_set;

/*----------------------Graph Moves----------------*/
//const int fx[]={+1,-1,+0,+0};
//const int fy[]={+0,+0,+1,-1};
//const int fx[]={+0,+0,+1,-1,-1,+1,-1,+1};   // Kings Move
//const int fy[]={-1,+1,+0,+0,+1,+1,-1,-1};  // Kings Move
//const int fx[]={-2, -2, -1, -1,  1,  1,  2,  2};  // Knights Move
//const int fy[]={-1,  1, -2,  2, -2,  2, -1,  1}; // Knights Move
/*------------------------------------------------*/

//int Set(int N,int pos){return N=N | (1&lt;&lt;pos);}
//int reset(int N,int pos){return N= N &amp; ~(1&lt;&lt;pos);}
//bool check(int N,int pos){return (bool)(N &amp; (1&lt;&lt;pos));}
/*------------------------------------------------*/

#define mx 100005
#define segment_tree int l=n*2,r=l+1,mid=(b+e)/2
struct data
{
ll sum,sqrsum,lazy,upd;
};

data tree[3*mx];

ll ara[mx];

void push_down(int n, int b, int e)
{
segment_tree;
if(tree[n].upd)
{
tree[l].lazy=0;
tree[r].lazy=0;
tree[l].sum=(mid-b+1)*tree[n].upd;
tree[l].sqrsum=(mid-b+1)*sqr(tree[n].upd);
tree[r].sum=(e-mid)*tree[n].upd;
tree[r].sqrsum=(e-mid)*sqr(tree[n].upd);
tree[l].upd=tree[n].upd;
tree[r].upd=tree[n].upd;
tree[n].upd=0;
}
if(tree[n].lazy)
{
//        tree[l].lazy+=tree[n].lazy;
//        tree[l].status=1;
//        tree[r].lazy+=tree[n].lazy;
//        tree[r].status=1;
//        tree[n].status=0;
tree[l].sqrsum+=(tree[l].sum*(2*tree[n].lazy))+(mid-b+1)*sqr(tree[n].lazy);
tree[r].sqrsum+=(tree[r].sum*(2*tree[n].lazy))+(e-mid)*sqr(tree[n].lazy);
tree[l].sum+=(mid-b+1)*tree[n].lazy;
tree[r].sum+=(e-mid)*tree[n].lazy;
tree[l].lazy+=tree[n].lazy;
tree[r].lazy+=tree[n].lazy;
tree[n].lazy=0;
}
}

void init(int n, int b, int e)
{
if(b==e)
{
tree[n].sum=ara[b];
tree[n].sqrsum=sqr(ara[b]);
tree[n].lazy=0;
tree[n].upd=0;
return;
}
segment_tree;
init(l,b,mid);
init(r,mid+1,e);
tree[n].sum=tree[l].sum+tree[r].sum;
tree[n].sqrsum=tree[l].sqrsum+tree[r].sqrsum;
tree[n].lazy=0;
tree[n].upd=0;
}

void update(int n, int b, int e, int i, int j, ll val, int type)
{
if(b&gt;j || e&lt;i) return;
if(b&gt;=i &amp;&amp; e&lt;=j)
{
if(type==0)
{
tree[n].sum=(e-b+1)*val;
tree[n].sqrsum=(e-b+1)*sqr(val);
tree[n].lazy=0;
tree[n].upd=val;
}
else
{
tree[n].sqrsum+=(tree[n].sum*2*val)+((e-b+1)*sqr(val));
tree[n].sum+=(e-b+1)*val;
tree[n].lazy+=val;
}
return;
}

push_down(n,b,e);

segment_tree;

update(l,b,mid,i,j,val,type);
update(r,mid+1,e,i,j,val,type);
tree[n].sum=tree[l].sum+tree[r].sum;
tree[n].sqrsum=tree[l].sqrsum+tree[r].sqrsum;
}

ll query(int n, int b, int e, int i, int j)
{
if(b&gt;j || e&lt;i) return 0;
if(b&gt;=i &amp;&amp; e&lt;=j)
return tree[n].sqrsum;
push_down(n,b,e);
segment_tree;
ll p=query(l,b,mid,i,j);
ll q=query(r,mid+1,e,i,j);
return p+q;
}

int main()
{
//    freopen(&quot;in.txt&quot;,&quot;r&quot;,stdin);
//	  freopen(&quot;out.txt&quot;,&quot;w&quot;,stdout);

int t;
sf(t);
TEST_CASE(t)
{
int n,q;
sff(n,q);
loop1(i,n) sfl(ara[i]);
init(1,1,n);
LINE_PRINT_CASE;
while(q--)
{
int a,b,c,d;
sfff(a,b,c);
if(a==2)
{
ll ans=query(1,1,n,b,c);
printf(&quot;%lld\n&quot;,ans);
}
else
{
sf(d);
if(a==1)
update(1,1,n,b,c,d,1);
else
update(1,1,n,b,c,d,0);
}
}
}

return 0;
}

```

SPOJ: BTCODE_G – Coloring Trees

0

Solution Idea:

The solution idea of this problem is not so hard. This one can be solve with Heavy Light Decomposition. But as the time limit is very tight we need a lot of optimization. To solve this problem we need to convert the tree to an array using Euler tour or in-order traversal on the tree. Now there are 2 types of operation. Let consider each tree node as a special node which contain a 30 size array for storing it’s color information.

Now let a paint operation is 1 a b. Now add +1 to array index [b] of discovery_time(a)node and -1 to array index [b] of finishing_time[a) node.

For each query operation 2 a b we need to check for each color. Now at first determine the LCA of node a and b in the original given graph. Now for the i’th color we need to count the summation of array[i] from root node to discovery_time(a) node. Let this summation is x. Then we need count the summation of array[i] from root node to discovery_time(b) node. Let this summation is y. Here we add root to LCA node’s value twice but we don’t need this. So we need to subtract this from the sum. So we need count the summation of array[i] from root node to discovery_time(LCA) node. Let this is z. Now if we subtract 2*z then we will delete the LCA node’s value so wee need to add this value too.

So Total number of i’th color node in the path from a to b is

=x+y-(2*z)+ array[i] value of LCA node.

We can do this for each of 30 color and When we get a color which fill every node in the range a to b then we will print YES otherwise NO.

I have implemented this solution using segment tree but got TLE several time. Then I implement the same idea using BIT and got AC. I think the main idea behind the TLE in segment tree is wee need to copy the 30 size array element several time in segment tree. Which will take some time. As the time limit is very tight, the segment tree solution is inefficient.

```
#include &lt;bits/stdc++.h&gt;
#include &lt;ext/pb_ds/assoc_container.hpp&gt;
#include &lt;ext/pb_ds/tree_policy.hpp&gt;

#define pii              pair &lt;int,int&gt;
#define pll              pair &lt;long long,long long&gt;
#define sc               scanf
#define pf               printf
#define Pi               2*acos(0.0)
#define ms(a,b)          memset(a, b, sizeof(a))
#define pb(a)            push_back(a)
#define MP               make_pair
#define db               double
#define ll               long long
#define EPS              10E-10
#define ff               first
#define ss               second
#define sqr(x)           (x)*(x)
#define D(x)             cerr&lt;&lt;#x &quot; = &quot;&lt;&lt;(x)&lt;&lt;endl
#define VI               vector &lt;int&gt;
#define DBG              pf(&quot;Hi\n&quot;)
#define MOD              1000000007
#define CIN              ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define SZ(a)            (int)a.size()
#define sf(a)            scanf(&quot;%d&quot;,&amp;a)
#define sfl(a)           scanf(&quot;%lld&quot;,&amp;a)
#define sff(a,b)         scanf(&quot;%d %d&quot;,&amp;a,&amp;b)
#define sffl(a,b)        scanf(&quot;%lld %lld&quot;,&amp;a,&amp;b)
#define sfff(a,b,c)      scanf(&quot;%d %d %d&quot;,&amp;a,&amp;b,&amp;c)
#define sfffl(a,b,c)     scanf(&quot;%lld %lld %lld&quot;,&amp;a,&amp;b,&amp;c)
#define stlloop(v)       for(__typeof(v.begin()) it=v.begin();it!=v.end();it++)
#define loop(i,n)        for(int i=0;i&lt;n;i++)
#define loop1(i,n)       for(int i=1;i&lt;=n;i++)
#define REP(i,a,b)       for(int i=a;i&lt;b;i++)
#define RREP(i,a,b)      for(int i=a;i&gt;=b;i--)
#define TEST_CASE(t)     for(int z=1;z&lt;=t;z++)
#define PRINT_CASE       printf(&quot;Case %d: &quot;,z)
#define LINE_PRINT_CASE  printf(&quot;Case %d:\n&quot;,z)
#define CASE_PRINT       cout&lt;&lt;&quot;Case &quot;&lt;&lt;z&lt;&lt;&quot;: &quot;
#define all(a)           a.begin(),a.end()
#define intlim           2147483648
#define infinity         (1&lt;&lt;28)
#define ull              unsigned long long
#define gcd(a, b)        __gcd(a, b)
#define lcm(a, b)        ((a)*((b)/gcd(a,b)))

using namespace std;

//using namespace __gnu_pbds;
//typedef tree&lt;int, null_type, less&lt;int&gt;, rb_tree_tag, tree_order_statistics_node_update&gt; ordered_set;

/*----------------------Graph Moves----------------*/
//const int fx[]={+1,-1,+0,+0};
//const int fy[]={+0,+0,+1,-1};
//const int fx[]={+0,+0,+1,-1,-1,+1,-1,+1};   // Kings Move
//const int fy[]={-1,+1,+0,+0,+1,+1,-1,-1};  // Kings Move
//const int fx[]={-2, -2, -1, -1,  1,  1,  2,  2};  // Knights Move
//const int fy[]={-1,  1, -2,  2, -2,  2, -1,  1}; // Knights Move
/*------------------------------------------------*/

//int Set(int N,int pos){return N=N | (1&lt;&lt;pos);}
//int reset(int N,int pos){return N= N &amp; ~(1&lt;&lt;pos);}
//bool check(int N,int pos){return (bool)(N &amp; (1&lt;&lt;pos));}
/*------------------------------------------------*/

#define mx 200005

vector&lt;int&gt;g[mx];
pii times[mx];
int dfsnum;
int parent[mx],level[mx],node_cnt[2*mx];

void dfs(int u, int p)
{
times[u].ff=++dfsnum;
parent[u]=p;
for(int i=0; i&lt;SZ(g[u]); i++)
{
int v=g[u][i];
if(v==p) continue;
level[v]=level[u]+1;
dfs(v,u);
}
times[u].ss=++dfsnum;
}

int dp[mx][21];

int func_lca(int idx, int p)
{
if(p==0)
{
return dp[idx][p]=parent[idx];
}
int &amp;ret=dp[idx][p];
if(ret!=-1) return ret;
int u=func_lca(idx,p-1);
ret=func_lca(u,p-1);
return ret;
}

int lca_query(int p, int q)
{
if(level[q]&gt;level[p]) swap(p,q);
for(int i=20;i&gt;=0;i--)
{
int a=func_lca(p,i);
if(level[a]&gt;=level[q])
p=a;
}

if(p==q) return p;

for(int i=20;i&gt;=0;i--)
{
int a=func_lca(p,i);
int b=func_lca(q,i);
if(a!=b)
{
p=a;
q=b;
}
}

return parent[p];
}

int tree[31][2*mx];

void update(int id, int idx, int val)
{
for(;idx&lt;=dfsnum &amp;&amp; idx;idx+=idx&amp;-idx)
tree[id][idx]+=val;
}

int query(int id, int idx)
{
int ret=0;
for(;idx;idx-=idx&amp;-idx)
ret+=tree[id][idx];
return ret;
}

int main()
{
//    freopen(&quot;in.txt&quot;,&quot;r&quot;,stdin);
//	  freopen(&quot;out.txt&quot;,&quot;w&quot;,stdout);

int n;
sf(n);
for(int i=1; i&lt;n; i++)
{
int a,b;
sff(a,b);
g[a].pb(b);
g[b].pb(a);
}

dfs(0,0);

int qq;
sf(qq);

for(int i=0;i&lt;n;i++)
{
node_cnt[times[i].ff]=1;
node_cnt[times[i].ss]=-1;
}

partial_sum(node_cnt,node_cnt+(2*mx),node_cnt);

ms(dp,-1);

while(qq--)
{
int a,b,c;
sfff(a,b,c);
if(a==1)
{
update(c,times[b].ff,1);
update(c,times[b].ss,-1);
}
else
{
if(times[b].ff&gt;times.ff)
swap(b,c);

bool ans=0;

int lca=lca_query(b,c);

for(int i=1;i&lt;=30;i++)
{
int x=query(i,times.ff);
int y=query(i,times[b].ff);
int z=query(i,times[lca].ff);
x=(x+y-(2*z));
x+=query(i,times[lca].ff)-query(i,times[lca].ff-1);
y=node_cnt[times[b].ff]+node_cnt[times.ff]-(2*node_cnt[times[lca].ff])+(node_cnt[times[lca].ff]-node_cnt[times[lca].ff-1]);
if(x)
{
if(x==y)
ans=1;
break;
}
}

if(ans==0)
printf(&quot;NO\n&quot;);
else
printf(&quot;YES\n&quot;);

}
}
return 0;
}

```

SPOJ: SUMSUM – Enjoy Sum with Operations

0

Solution Idea:

This one is a interesting problem. The main idea behind the problem is combinatorics. At first we need to count the number of 1 bit and number of 0 bit in the i_th position of a given number. Then we need to do some combinatorial calculation.

Now think about an array of 4 number A=[1,0,1,0]. If we perform OR operation in the range 1 to 4 what will we get? We get 5 as answer. If we form pair from this number and perform OR operation between then then we will get the answer. Now as here is 4 element so we can perform pair in 4*(4-1)/2 = 6 ways. Now comes the tricky part. For OR operation how many pair will contribute nothing ?? Here is 2 zero and we can form 1 pair from this two element who will not contribute anything. So for i_th bit position the contribution for OR operation is number_of_active_pair*(2^i).

For AND operation we need to consider the number of pair can be form by 1 bit and for XOR the number of pair will be number_of_one_bit*number_of_zero_bit.

We can consider a number as an array of 30 element whose value is either 0 or 1 and perform above operation.

```
#include &lt;bits/stdc++.h&gt;
#include &lt;ext/pb_ds/assoc_container.hpp&gt;
#include &lt;ext/pb_ds/tree_policy.hpp&gt;

#define pii              pair &lt;int,int&gt;
#define pll              pair &lt;long long,long long&gt;
#define sc               scanf
#define pf               printf
#define Pi               2*acos(0.0)
#define ms(a,b)          memset(a, b, sizeof(a))
#define pb(a)            push_back(a)
#define MP               make_pair
#define db               double
#define ll               long long
#define EPS              10E-10
#define ff               first
#define ss               second
#define sqr(x)           (x)*(x)
#define D(x)             cerr&lt;&lt;#x &quot; = &quot;&lt;&lt;(x)&lt;&lt;endl
#define VI               vector &lt;int&gt;
#define DBG              pf(&quot;Hi\n&quot;)
#define MOD              1000000007
#define CIN              ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define SZ(a)            (int)a.size()
#define sf(a)            scanf(&quot;%d&quot;,&amp;a)
#define sfl(a)           scanf(&quot;%lld&quot;,&amp;a)
#define sff(a,b)         scanf(&quot;%d %d&quot;,&amp;a,&amp;b)
#define sffl(a,b)        scanf(&quot;%lld %lld&quot;,&amp;a,&amp;b)
#define sfff(a,b,c)      scanf(&quot;%d %d %d&quot;,&amp;a,&amp;b,&amp;c)
#define sfffl(a,b,c)     scanf(&quot;%lld %lld %lld&quot;,&amp;a,&amp;b,&amp;c)
#define stlloop(v)       for(__typeof(v.begin()) it=v.begin();it!=v.end();it++)
#define loop(i,n)        for(int i=0;i&lt;n;i++)
#define loop1(i,n)       for(int i=1;i&lt;=n;i++)
#define REP(i,a,b)       for(int i=a;i&lt;b;i++)
#define RREP(i,a,b)      for(int i=a;i&gt;=b;i--)
#define TEST_CASE(t)     for(int z=1;z&lt;=t;z++)
#define PRINT_CASE       printf(&quot;Case %d: &quot;,z)
#define LINE_PRINT_CASE  printf(&quot;Case %d:\n&quot;,z)
#define CASE_PRINT       cout&lt;&lt;&quot;Case &quot;&lt;&lt;z&lt;&lt;&quot;: &quot;
#define all(a)           a.begin(),a.end()
#define intlim           2147483648
#define infinity         (1&lt;&lt;28)
#define ull              unsigned long long
#define gcd(a, b)        __gcd(a, b)
#define lcm(a, b)        ((a)*((b)/gcd(a,b)))

using namespace std;

//using namespace __gnu_pbds;
//typedef tree&lt;int, null_type, less&lt;int&gt;, rb_tree_tag, tree_order_statistics_node_update&gt; ordered_set;

/*----------------------Graph Moves----------------*/
//const int fx[]={+1,-1,+0,+0};
//const int fy[]={+0,+0,+1,-1};
//const int fx[]={+0,+0,+1,-1,-1,+1,-1,+1};   // Kings Move
//const int fy[]={-1,+1,+0,+0,+1,+1,-1,-1};  // Kings Move
//const int fx[]={-2, -2, -1, -1,  1,  1,  2,  2};  // Knights Move
//const int fy[]={-1,  1, -2,  2, -2,  2, -1,  1}; // Knights Move
/*------------------------------------------------*/

//int Set(int N,int pos){return N=N | (1&lt;&lt;pos);}
//int reset(int N,int pos){return N= N &amp; ~(1&lt;&lt;pos);}
bool check(int N,int pos){return (bool)(N &amp; (1&lt;&lt;pos));}
/*------------------------------------------------*/

#define mx 100005

int tree[28][mx];

void update(int id, int idx, int val)
{
for(;idx&lt;mx &amp;&amp; idx;idx+=idx&amp;-idx)
tree[id][idx]+=val;
}

ll query(int id, int idx)
{
ll ret=0;
for(;idx;idx-=idx&amp;-idx)
ret+=tree[id][idx];
return ret;
}

int ara[mx];

int main()
{
//    freopen(&quot;in.txt&quot;,&quot;r&quot;,stdin);
//	  freopen(&quot;out.txt&quot;,&quot;w&quot;,stdout);

int n,q;
sff(n,q);
for(int i=1;i&lt;=n;i++) sf(ara[i]);

for(int i=1;i&lt;=n;i++)
{
for(int j=0;j&lt;28;j++)
{
if(check(ara[i],j))
update(j,i,1);
}
}

while(q--)
{
int a,b,c;
sf(a);
if(a==1)
{
sff(b,c);
for(int i=0;i&lt;28;i++)
{
if(check(ara,i))
update(i,c,-1);
}
ara=b;
for(int i=0;i&lt;28;i++)
{
if(check(ara,i))
update(i,c,1);
}
}
else
{
char ss[10];
scanf(&quot; %s&quot;,&amp;ss);
string str=string(ss);
sff(b,c);
ll temp[30];
for(int i=0;i&lt;28;i++)
{
temp[i]=query(i,c);
}
for(int i=0;i&lt;28;i++)
{
temp[i]-=query(i,b-1);
}

ll ans=0;

for(int i=0;i&lt;28;i++)
{
ll one=temp[i];
ll zero=(c-b+1)-one;
ll pairs=0;
if(str==&quot;OR&quot;)
{
ll total=one+zero;
pairs=(total*(total-1))/2;
pairs-=(zero*(zero-1))/2;
}
else if(str==&quot;AND&quot;)
{
pairs=(one*(one-1))/2;
}
else if(str==&quot;XOR&quot;)
{
pairs=one*zero;
}
ans+=(1LL&lt;&lt;i)*pairs;
}

printf(&quot;%lld\n&quot;,ans);
}
}

return 0;
}

```

SPOJ: FREQUENT – Frequent values

0

Solution Idea:

In this problem an array of non-decreasing order is given. In each query a range l and r is given. You have to tell the maximum frequency of a number in the range l to r.

Now as the given array is in non-decreasing order. So you can replace array a = {1 1 1 2 2 3 3 3 3} by another array b = {3 2 4}. After this compression the problem is converted to a Range Maximum query problem which can be easily solved by segment tree or sparse table. Now for each query determine the index in the compress array and perform range maximum query on that range.

Think about the first and index of the query range. You need to handle them separately.

```
#include &lt;bits/stdc++.h&gt;
#include &lt;ext/pb_ds/assoc_container.hpp&gt;
#include &lt;ext/pb_ds/tree_policy.hpp&gt;

#define pii              pair &lt;int,int&gt;
#define pll              pair &lt;long long,long long&gt;
#define sc               scanf
#define pf               printf
#define Pi               2*acos(0.0)
#define ms(a,b)          memset(a, b, sizeof(a))
#define pb(a)            push_back(a)
#define MP               make_pair
#define db               double
#define ll               long long
#define EPS              10E-10
#define ff               first
#define ss               second
#define sqr(x)           (x)*(x)
#define D(x)             cerr&lt;&lt;#x &quot; = &quot;&lt;&lt;(x)&lt;&lt;endl
#define VI               vector &lt;int&gt;
#define DBG              pf(&quot;Hi\n&quot;)
#define MOD              1000000007
#define CIN              ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define SZ(a)            (int)a.size()
#define sf(a)            scanf(&quot;%d&quot;,&amp;a)
#define sfl(a)           scanf(&quot;%lld&quot;,&amp;a)
#define sff(a,b)         scanf(&quot;%d %d&quot;,&amp;a,&amp;b)
#define sffl(a,b)        scanf(&quot;%lld %lld&quot;,&amp;a,&amp;b)
#define sfff(a,b,c)      scanf(&quot;%d %d %d&quot;,&amp;a,&amp;b,&amp;c)
#define sfffl(a,b,c)     scanf(&quot;%lld %lld %lld&quot;,&amp;a,&amp;b,&amp;c)
#define stlloop(v)       for(__typeof(v.begin()) it=v.begin();it!=v.end();it++)
#define loop(i,n)        for(int i=0;i&lt;n;i++)
#define loop1(i,n)       for(int i=1;i&lt;=n;i++)
#define REP(i,a,b)       for(int i=a;i&lt;b;i++)
#define RREP(i,a,b)      for(int i=a;i&gt;=b;i--)
#define TEST_CASE(t)     for(int z=1;z&lt;=t;z++)
#define PRINT_CASE       printf(&quot;Case %d: &quot;,z)
#define LINE_PRINT_CASE  printf(&quot;Case %d:\n&quot;,z)
#define CASE_PRINT       cout&lt;&lt;&quot;Case &quot;&lt;&lt;z&lt;&lt;&quot;: &quot;
#define all(a)           a.begin(),a.end()
#define intlim           2147483648
#define infinity         (1&lt;&lt;28)
#define ull              unsigned long long
#define gcd(a, b)        __gcd(a, b)
#define lcm(a, b)        ((a)*((b)/gcd(a,b)))

using namespace std;

//using namespace __gnu_pbds;
//typedef tree&lt;int, null_type, less&lt;int&gt;, rb_tree_tag, tree_order_statistics_node_update&gt; ordered_set;

/*----------------------Graph Moves----------------*/
//const int fx[]={+1,-1,+0,+0};
//const int fy[]={+0,+0,+1,-1};
//const int fx[]={+0,+0,+1,-1,-1,+1,-1,+1};   // Kings Move
//const int fy[]={-1,+1,+0,+0,+1,+1,-1,-1};  // Kings Move
//const int fx[]={-2, -2, -1, -1,  1,  1,  2,  2};  // Knights Move
//const int fy[]={-1,  1, -2,  2, -2,  2, -1,  1}; // Knights Move
/*------------------------------------------------*/

//int Set(int N,int pos){return N=N | (1&lt;&lt;pos);}
//int reset(int N,int pos){return N= N &amp; ~(1&lt;&lt;pos);}
//bool check(int N,int pos){return (bool)(N &amp; (1&lt;&lt;pos));}
/*------------------------------------------------*/

#define mx 100005

pii block[mx];

int dp[mx][20];

int ara[mx],id[mx],cnt=0,table[mx];

int func(int idx, int p)
{
if(idx&gt;cnt) return 0;
if(p==0)
{
return dp[idx][p]=table[idx];
}
int &amp;ret=dp[idx][p];
if(ret!=-1) return ret;
ret=max(func(idx,p-1),func(idx+(1&lt;&lt;(p-1)),p-1));
return ret;
}

int query(int l, int r)
{
if(r&lt;l) return 0;
if(l==r) return table[l];
int log=(int)log2(r-l);
return max(func(l,log),func(r-(1&lt;&lt;log)+1,log));
}

int main()
{

//    freopen(&quot;in.txt&quot;,&quot;r&quot;,stdin);
//	  freopen(&quot;out.txt&quot;,&quot;w&quot;,stdout);

int n,q;
while(sf(n))
{
if(n==0) break;
sf(q);
for(int i=1; i&lt;=n; i++)
{
sf(ara[i]);
}
cnt=0;
ms(table,0);
ms(dp,-1);
//        ms(block,0);
//        ms(id,0);
for(int i=1; i&lt;=n; i++)
{
int j=i;
cnt++;
block[cnt].ff=i;
while(ara[j]==ara[i] &amp;&amp; j&lt;=n)
{
id[j]=cnt;
table[cnt]++;
j++;
}
j--;
block[cnt].ss=j;
i=j;
}

while(q--)
{
int a,b;
sff(a,b);
if(id[a]==id[b])
{
printf(&quot;%d\n&quot;,b-a+1);
}
else
{
int l=id[a];
int r=id[b];
int ans=0;
ans=max(ans,block[l].ss-a+1);
l++;
ans=max(ans,b-block[r].ff+1);
r--;
ans=max(ans,query(l,r));
printf(&quot;%d\n&quot;,ans);
}
}

}

return 0;
}

```

Timus: 1523. K-inversions

0

Solution Idea:

```
#include &lt;bits/stdc++.h&gt;
//#include &lt;ext/pb_ds/assoc_container.hpp&gt;
//#include &lt;ext/pb_ds/tree_policy.hpp&gt;

#define pii              pair &lt;int,int&gt;
#define pll              pair &lt;long long,long long&gt;
#define sc               scanf
#define pf               printf
#define Pi               2*acos(0.0)
#define ms(a,b)          memset(a, b, sizeof(a))
#define pb(a)            push_back(a)
#define MP               make_pair
#define db               double
#define ll               long long
#define EPS              10E-10
#define ff               first
#define ss               second
#define sqr(x)           (x)*(x)
#define D(x)             cerr&lt;&lt;#x &quot; = &quot;&lt;&lt;(x)&lt;&lt;endl
#define VI               vector &lt;int&gt;
#define DBG              pf(&quot;Hi\n&quot;)
#define MOD              1000000000
#define CIN              ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define SZ(a)            (int)a.size()
#define sf(a)            scanf(&quot;%d&quot;,&amp;a)
#define sfl(a)           scanf(&quot;%lld&quot;,&amp;a)
#define sff(a,b)         scanf(&quot;%d %d&quot;,&amp;a,&amp;b)
#define sffl(a,b)        scanf(&quot;%lld %lld&quot;,&amp;a,&amp;b)
#define sfff(a,b,c)      scanf(&quot;%d %d %d&quot;,&amp;a,&amp;b,&amp;c)
#define sfffl(a,b,c)     scanf(&quot;%lld %lld %lld&quot;,&amp;a,&amp;b,&amp;c)
#define stlloop(v)       for(__typeof(v.begin()) it=v.begin();it!=v.end();it++)
#define loop(i,n)        for(int i=0;i&lt;n;i++)
#define loop1(i,n)       for(int i=1;i&lt;=n;i++)
#define REP(i,a,b)       for(int i=a;i&lt;b;i++)
#define RREP(i,a,b)      for(int i=a;i&gt;=b;i--)
#define TEST_CASE(t)     for(int z=1;z&lt;=t;z++)
#define PRINT_CASE       printf(&quot;Case %d: &quot;,z)
#define LINE_PRINT_CASE  printf(&quot;Case %d:\n&quot;,z)
#define CASE_PRINT       cout&lt;&lt;&quot;Case &quot;&lt;&lt;z&lt;&lt;&quot;: &quot;
#define all(a)           a.begin(),a.end()
#define intlim           2147483648
#define infinity         (1&lt;&lt;28)
#define ull              unsigned long long
#define gcd(a, b)        __gcd(a, b)
#define lcm(a, b)        ((a)*((b)/gcd(a,b)))

using namespace std;

//using namespace __gnu_pbds;
//typedef tree&lt;int, null_type, less&lt;int&gt;, rb_tree_tag, tree_order_statistics_node_update&gt; ordered_set;

/*----------------------Graph Moves----------------*/
//const int fx[]={+1,-1,+0,+0};
//const int fy[]={+0,+0,+1,-1};
//const int fx[]={+0,+0,+1,-1,-1,+1,-1,+1};   // Kings Move
//const int fy[]={-1,+1,+0,+0,+1,+1,-1,-1};  // Kings Move
//const int fx[]={-2, -2, -1, -1,  1,  1,  2,  2};  // Knights Move
//const int fy[]={-1,  1, -2,  2, -2,  2, -1,  1}; // Knights Move
/*------------------------------------------------*/

//int Set(int N,int pos){return N=N | (1&lt;&lt;pos);}
//int reset(int N,int pos){return N= N &amp; ~(1&lt;&lt;pos);}
//bool check(int N,int pos){return (bool)(N &amp; (1&lt;&lt;pos));}
/*------------------------------------------------*/

#define mx 20006

ll tree[12][mx];
ll ara[mx],ara2[12][mx];

void update(int id, int idx, ll val)
{
for(; idx&lt;mx &amp;&amp; idx; idx+=idx&amp;-idx)
tree[id][idx]+=val;
}

ll query(int id, int idx)
{
ll ret=0;
for(; idx; idx-=idx&amp;-idx)
ret+=tree[id][idx];
return ret;
}

//vector&lt;ll&gt;v;

int main()
{

//    freopen(&quot;in.txt&quot;,&quot;r&quot;,stdin);
//	  freopen(&quot;out.txt&quot;,&quot;w&quot;,stdout);

int n,k;
sff(n,k);
//    v.pb(0);
loop1(i,n)
{
sfl(ara[i]);
ara2[1][i]=1;
//        v.pb(ara[i]);
}
//    sort(all(v));

ll ans=0;
for(int j=1; j&lt;k; j++)
{
for(int i=n; i&gt;0; i--)
{
//        int id=lower_bound(all(v),ara[i])-v.begin();
int id=ara[i];
ara2[j+1][i]=query(j,id)%MOD;
update(j,id+1,ara2[j][i]);
//        update(0,id-1,-1);
}
}

//    for(int i=n; i&gt;0; i--)
//    {
////        int id=lower_bound(all(v),ara[i])-v.begin();
//        int id=ara[i];
//        ans+=query(1,id);
//        update(1,id+1,ara2[i]);
////        update(1,id-1,-ara2[i]);
//    }

for(int i=1; i&lt;=n; i++)
ans+=ara2[k][i];

printf(&quot;%lld\n&quot;,ans%MOD);

return 0;
}

```

SPOJ: TRIPINV – Mega Inversions

0

Solution Idea:

```
#include &lt;bits/stdc++.h&gt;
#include &lt;ext/pb_ds/assoc_container.hpp&gt;
#include &lt;ext/pb_ds/tree_policy.hpp&gt;

#define pii              pair &lt;int,int&gt;
#define pll              pair &lt;long long,long long&gt;
#define sc               scanf
#define pf               printf
#define Pi               2*acos(0.0)
#define ms(a,b)          memset(a, b, sizeof(a))
#define pb(a)            push_back(a)
#define MP               make_pair
#define db               double
#define ll               long long
#define EPS              10E-10
#define ff               first
#define ss               second
#define sqr(x)           (x)*(x)
#define D(x)             cerr&lt;&lt;#x &quot; = &quot;&lt;&lt;(x)&lt;&lt;endl
#define VI               vector &lt;int&gt;
#define DBG              pf(&quot;Hi\n&quot;)
#define MOD              1000000007
#define CIN              ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define SZ(a)            (int)a.size()
#define sf(a)            scanf(&quot;%d&quot;,&amp;a)
#define sfl(a)           scanf(&quot;%lld&quot;,&amp;a)
#define sff(a,b)         scanf(&quot;%d %d&quot;,&amp;a,&amp;b)
#define sffl(a,b)        scanf(&quot;%lld %lld&quot;,&amp;a,&amp;b)
#define sfff(a,b,c)      scanf(&quot;%d %d %d&quot;,&amp;a,&amp;b,&amp;c)
#define sfffl(a,b,c)     scanf(&quot;%lld %lld %lld&quot;,&amp;a,&amp;b,&amp;c)
#define stlloop(v)       for(__typeof(v.begin()) it=v.begin();it!=v.end();it++)
#define loop(i,n)        for(int i=0;i&lt;n;i++)
#define loop1(i,n)       for(int i=1;i&lt;=n;i++)
#define REP(i,a,b)       for(int i=a;i&lt;b;i++)
#define RREP(i,a,b)      for(int i=a;i&gt;=b;i--)
#define TEST_CASE(t)     for(int z=1;z&lt;=t;z++)
#define PRINT_CASE       printf(&quot;Case %d: &quot;,z)
#define LINE_PRINT_CASE  printf(&quot;Case %d:\n&quot;,z)
#define CASE_PRINT       cout&lt;&lt;&quot;Case &quot;&lt;&lt;z&lt;&lt;&quot;: &quot;
#define all(a)           a.begin(),a.end()
#define intlim           2147483648
#define infinity         (1&lt;&lt;28)
#define ull              unsigned long long
#define gcd(a, b)        __gcd(a, b)
#define lcm(a, b)        ((a)*((b)/gcd(a,b)))

using namespace std;

//using namespace __gnu_pbds;
//typedef tree&lt;int, null_type, less&lt;int&gt;, rb_tree_tag, tree_order_statistics_node_update&gt; ordered_set;

/*----------------------Graph Moves----------------*/
//const int fx[]={+1,-1,+0,+0};
//const int fy[]={+0,+0,+1,-1};
//const int fx[]={+0,+0,+1,-1,-1,+1,-1,+1};   // Kings Move
//const int fy[]={-1,+1,+0,+0,+1,+1,-1,-1};  // Kings Move
//const int fx[]={-2, -2, -1, -1,  1,  1,  2,  2};  // Knights Move
//const int fy[]={-1,  1, -2,  2, -2,  2, -1,  1}; // Knights Move
/*------------------------------------------------*/

//int Set(int N,int pos){return N=N | (1&lt;&lt;pos);}
//int reset(int N,int pos){return N= N &amp; ~(1&lt;&lt;pos);}
//bool check(int N,int pos){return (bool)(N &amp; (1&lt;&lt;pos));}
/*------------------------------------------------*/

#define mx 100006

ll tree[2][mx];
ll ara[mx],ara2[mx];

void update(int id, int idx, ll val)
{
for(; idx&lt;mx &amp;&amp; idx; idx+=idx&amp;-idx)
tree[id][idx]+=val;
}

ll query(int id, int idx)
{
ll ret=0;
for(; idx; idx-=idx&amp;-idx)
ret+=tree[id][idx];
return ret;
}

//vector&lt;ll&gt;v;

int main()
{

//    freopen(&quot;in.txt&quot;,&quot;r&quot;,stdin);
//	  freopen(&quot;out.txt&quot;,&quot;w&quot;,stdout);

int n;
sf(n);
//    v.pb(0);
loop1(i,n)
{
sfl(ara[i]);
//        v.pb(ara[i]);
}
//    sort(all(v));

ll ans=0;

for(int i=n; i&gt;0; i--)
{
//        int id=lower_bound(all(v),ara[i])-v.begin();
int id=ara[i];

ara2[i]=query(0,id);
update(0,id+1,1);
//        update(0,id-1,-1);
}

for(int i=n; i&gt;0; i--)
{
//        int id=lower_bound(all(v),ara[i])-v.begin();
int id=ara[i];
ans+=query(1,id);
update(1,id+1,ara2[i]);
//        update(1,id-1,-ara2[i]);
}

printf(&quot;%lld\n&quot;,ans);

return 0;
}

```

Codeforces: 61 E. Enemy is weak

2

Solution Idea:

In this problem we need to count the number of triple inverse triplets on a given array. A triple inverse triplet is three positions i, j, k on an array A=[] such that i < j  Aj > Ak.

Now to solve this problem we need some range update and query data structure like segment tree or binary indexed tree. The idea is at first compress the array by mapping the numbers from range 1 to 10^6. After that read the array from reverse order and query the value of that mapped index on segment tree(let this mapped index is id)and store it on an array let name this array ara2=[]. After that increment the value of the index id+1 to n. It means that when we read any number from id+1 to n we can know that current number id have impact on this number. Here id is the k_th element of the triplet and all the number from id+1 to n is the j_th element of the triplet. Now each ara2[] index hold the number of inverse pair starting at id.

Now read the array element from the reverse order again and do the same thing. This time we need another segment tree. This time when we stand on position id add the value of the segment tree of position id to the answer and update all position in the range id+1 to n by ara2[index_of_id]. Do this for the whole array.

We can repeat this technique for 4,5,6 element inversion too.

```
#include &lt;bits/stdc++.h&gt;
#include &lt;ext/pb_ds/assoc_container.hpp&gt;
#include &lt;ext/pb_ds/tree_policy.hpp&gt;

#define pii              pair &lt;int,int&gt;
#define pll              pair &lt;long long,long long&gt;
#define sc               scanf
#define pf               printf
#define Pi               2*acos(0.0)
#define ms(a,b)          memset(a, b, sizeof(a))
#define pb(a)            push_back(a)
#define MP               make_pair
#define db               double
#define ll               long long
#define EPS              10E-10
#define ff               first
#define ss               second
#define sqr(x)           (x)*(x)
#define D(x)             cerr&lt;&lt;#x &quot; = &quot;&lt;&lt;(x)&lt;&lt;endl
#define VI               vector &lt;int&gt;
#define DBG              pf(&quot;Hi\n&quot;)
#define MOD              1000000007
#define CIN              ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define SZ(a)            (int)a.size()
#define sf(a)            scanf(&quot;%d&quot;,&amp;a)
#define sfl(a)           scanf(&quot;%lld&quot;,&amp;a)
#define sff(a,b)         scanf(&quot;%d %d&quot;,&amp;a,&amp;b)
#define sffl(a,b)        scanf(&quot;%lld %lld&quot;,&amp;a,&amp;b)
#define sfff(a,b,c)      scanf(&quot;%d %d %d&quot;,&amp;a,&amp;b,&amp;c)
#define sfffl(a,b,c)     scanf(&quot;%lld %lld %lld&quot;,&amp;a,&amp;b,&amp;c)
#define stlloop(v)       for(__typeof(v.begin()) it=v.begin();it!=v.end();it++)
#define loop(i,n)        for(int i=0;i&lt;n;i++)
#define loop1(i,n)       for(int i=1;i&lt;=n;i++)
#define REP(i,a,b)       for(int i=a;i&lt;b;i++)
#define RREP(i,a,b)      for(int i=a;i&gt;=b;i--)
#define TEST_CASE(t)     for(int z=1;z&lt;=t;z++)
#define PRINT_CASE       printf(&quot;Case %d: &quot;,z)
#define LINE_PRINT_CASE  printf(&quot;Case %d:\n&quot;,z)
#define CASE_PRINT       cout&lt;&lt;&quot;Case &quot;&lt;&lt;z&lt;&lt;&quot;: &quot;
#define all(a)           a.begin(),a.end()
#define intlim           2147483648
#define infinity         (1&lt;&lt;28)
#define ull              unsigned long long
#define gcd(a, b)        __gcd(a, b)
#define lcm(a, b)        ((a)*((b)/gcd(a,b)))

using namespace std;

//using namespace __gnu_pbds;
//typedef tree&lt;int, null_type, less&lt;int&gt;, rb_tree_tag, tree_order_statistics_node_update&gt; ordered_set;

/*----------------------Graph Moves----------------*/
//const int fx[]={+1,-1,+0,+0};
//const int fy[]={+0,+0,+1,-1};
//const int fx[]={+0,+0,+1,-1,-1,+1,-1,+1};   // Kings Move
//const int fy[]={-1,+1,+0,+0,+1,+1,-1,-1};  // Kings Move
//const int fx[]={-2, -2, -1, -1,  1,  1,  2,  2};  // Knights Move
//const int fy[]={-1,  1, -2,  2, -2,  2, -1,  1}; // Knights Move
/*------------------------------------------------*/

//int Set(int N,int pos){return N=N | (1&lt;&lt;pos);}
//int reset(int N,int pos){return N= N &amp; ~(1&lt;&lt;pos);}
//bool check(int N,int pos){return (bool)(N &amp; (1&lt;&lt;pos));}
/*------------------------------------------------*/

#define mx 1000006

ll tree[2][mx];
ll ara[mx],ara2[mx];

void update(int id, int idx, ll val)
{
for(; idx&lt;mx &amp;&amp; idx; idx+=idx&amp;-idx)
tree[id][idx]+=val;
}

ll query(int id, int idx)
{
ll ret=0;
for(; idx; idx-=idx&amp;-idx)
ret+=tree[id][idx];
return ret;
}

vector&lt;ll&gt;v;

int main()
{

//    freopen(&quot;in.txt&quot;,&quot;r&quot;,stdin);
//	  freopen(&quot;out.txt&quot;,&quot;w&quot;,stdout);

int n;
sf(n);
v.pb(0);
loop1(i,n)
{
sfl(ara[i]);
v.pb(ara[i]);
}
sort(all(v));

ll ans=0;

for(int i=n; i&gt;0; i--)
{
int id=lower_bound(all(v),ara[i])-v.begin();
ara2[i]=query(0,id);
update(0,id+1,1);
//        update(0,id-1,-1);
}

for(int i=n; i&gt;0; i--)
{
int id=lower_bound(all(v),ara[i])-v.begin();
ans+=query(1,id);
update(1,id+1,ara2[i]);
//        update(1,id-1,-ara2[i]);
}

printf(&quot;%lld\n&quot;,ans);

return 0;
}

```

Codeforces: 877E. Danil and a Part-time Job

0

Solution Idea:

Run a dfs on the given for getting the Euler tour order or inorder traversal order. Then the tree is converted to a liner 1D array. Now we can apply range query and update on this array.

Now use a range update query data structure. Here I have used segment tree. Now initialize the tree with the initial value and now our job is to just toggle a subtree of the given tree and perform query operation. Use a propagation for the update and answer the query.

```
#include &lt;bits/stdc++.h&gt;
#include &lt;ext/pb_ds/assoc_container.hpp&gt;
#include &lt;ext/pb_ds/tree_policy.hpp&gt;

#define pii              pair &lt;int,int&gt;
#define pll              pair &lt;long long,long long&gt;
#define sc               scanf
#define pf               printf
#define Pi               2*acos(0.0)
#define ms(a,b)          memset(a, b, sizeof(a))
#define pb(a)            push_back(a)
#define MP               make_pair
#define db               double
#define ll               long long
#define EPS              10E-10
#define ff               first
#define ss               second
#define sqr(x)           (x)*(x)
#define D(x)             cerr&lt;&lt;#x &quot; = &quot;&lt;&lt;(x)&lt;&lt;endl
#define VI               vector &lt;int&gt;
#define DBG              pf(&quot;Hi\n&quot;)
#define MOD              1000000007
#define CIN              ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define SZ(a)            (int)a.size()
#define sf(a)            scanf(&quot;%d&quot;,&amp;a)
#define sfl(a)           scanf(&quot;%lld&quot;,&amp;a)
#define sff(a,b)         scanf(&quot;%d %d&quot;,&amp;a,&amp;b)
#define sffl(a,b)        scanf(&quot;%lld %lld&quot;,&amp;a,&amp;b)
#define sfff(a,b,c)      scanf(&quot;%d %d %d&quot;,&amp;a,&amp;b,&amp;c)
#define sfffl(a,b,c)     scanf(&quot;%lld %lld %lld&quot;,&amp;a,&amp;b,&amp;c)
#define stlloop(v)       for(__typeof(v.begin()) it=v.begin();it!=v.end();it++)
#define loop(i,n)        for(int i=0;i&lt;n;i++)
#define loop1(i,n)       for(int i=1;i&lt;=n;i++)
#define REP(i,a,b)       for(int i=a;i&lt;b;i++)
#define RREP(i,a,b)      for(int i=a;i&gt;=b;i--)
#define TEST_CASE(t)     for(int z=1;z&lt;=t;z++)
#define PRINT_CASE       printf(&quot;Case %d: &quot;,z)
#define LINE_PRINT_CASE  printf(&quot;Case %d:\n&quot;,z)
#define CASE_PRINT       cout&lt;&lt;&quot;Case &quot;&lt;&lt;z&lt;&lt;&quot;: &quot;
#define all(a)           a.begin(),a.end()
#define intlim           2147483648
#define infinity         (1&lt;&lt;28)
#define ull              unsigned long long
#define gcd(a, b)        __gcd(a, b)
#define lcm(a, b)        ((a)*((b)/gcd(a,b)))

using namespace std;

//using namespace __gnu_pbds;
//typedef tree&lt;int, null_type, less&lt;int&gt;, rb_tree_tag, tree_order_statistics_node_update&gt; ordered_set;

/*----------------------Graph Moves----------------*/
//const int fx[]={+1,-1,+0,+0};
//const int fy[]={+0,+0,+1,-1};
//const int fx[]={+0,+0,+1,-1,-1,+1,-1,+1};   // Kings Move
//const int fy[]={-1,+1,+0,+0,+1,+1,-1,-1};  // Kings Move
//const int fx[]={-2, -2, -1, -1,  1,  1,  2,  2};  // Knights Move
//const int fy[]={-1,  1, -2,  2, -2,  2, -1,  1}; // Knights Move
/*------------------------------------------------*/

//int Set(int N,int pos){return N=N | (1&lt;&lt;pos);}
//int reset(int N,int pos){return N= N &amp; ~(1&lt;&lt;pos);}
//bool check(int N,int pos){return (bool)(N &amp; (1&lt;&lt;pos));}
/*------------------------------------------------*/

#define mx 200005
#define segment_tree int l=n*2,r=l+1,mid=(b+e)/2
pii info[mx];
vector&lt;int&gt;g[mx];
int cnt=0;
int maps[mx],ara[mx];

void dfs(int u, int par)
{
info[u].ff=++cnt;
maps[cnt]=u;
for(int i=0;i&lt;SZ(g[u]);i++)
{
int v=g[u][i];
if(v==par) continue;
dfs(v,u);
}
info[u].ss=cnt;
}

struct data
{
int val, prop;
};

data tree[3*mx];

void push_down(int n, int b, int e)
{
if(tree[n].prop%2)
{
segment_tree;
tree[l].val=(mid-b+1)-tree[l].val;
tree[l].prop++;
tree[r].val=(e-mid)-tree[r].val;
tree[r].prop++;
tree[n].prop=0;
}
}

void init(int n, int b, int e)
{
if(b==e)
{
tree[n].val=ara[maps[b]];
tree[n].prop=0;
return;
}
segment_tree;
init(l,b,mid);
init(r,mid+1,e);
tree[n].val=tree[l].val+tree[r].val;
}

void update(int n, int b, int e, int i, int j)
{
if(b&gt;j || e&lt;i) return;
if(b&gt;=i &amp;&amp; e&lt;=j)
{
tree[n].val=(e-b+1)-tree[n].val;
tree[n].prop++;
return;
}
push_down(n,b,e);
segment_tree;
update(l,b,mid,i,j);
update(r,mid+1,e,i,j);
tree[n].val=tree[l].val+tree[r].val;
}

int query(int n, int b, int e, int i, int j)
{
if(b&gt;j || e&lt;i) return 0;
if(b&gt;=i &amp;&amp; e&lt;=j) return tree[n].val;
push_down(n,b,e);
segment_tree;
int p=query(l,b,mid,i,j);
int q=query(r,mid+1,e,i,j);
return p+q;
}

char str[10];

int main()
{

//    freopen(&quot;in.txt&quot;,&quot;r&quot;,stdin);
//	  freopen(&quot;out.txt&quot;,&quot;w&quot;,stdout);

int n;
sf(n);
for(int i=2;i&lt;=n;i++)
{
int a;
sf(a);
g[a].pb(i);
}

for(int i=1;i&lt;=n;i++) sf(ara[i]);
dfs(1,1);
init(1,1,n);
int q;
sf(q);
while(q--)
{
int a;
scanf(&quot; %s %d&quot;,str,&amp;a);
if(str[0]=='g')
{
int x=query(1,1,n,info[a].ff,info[a].ss);
printf(&quot;%d\n&quot;,x);
}
else
{
update(1,1,n,info[a].ff,info[a].ss);
}
}

return 0;
}

```

Codeforces Gym: 101484 E. Double Fence

0

Solution Idea:

Let P1 and P2 be respectively the set of points of the first polygon and the set of points of the second polygon. Let ch(X) be the set of points on the convex hull of the set of points X, including colinear points on the edges. A polygon is strictly inside the other if ch(P1 U P2 equals to P1 or P2.
```
#include&lt;vector&gt;
#include&lt;list&gt;
#include&lt;map&gt;
#include&lt;set&gt;
#include&lt;deque&gt;
#include&lt;queue&gt;
#include&lt;stack&gt;
#include&lt;bitset&gt;
#include&lt;algorithm&gt;
#include&lt;functional&gt;
#include&lt;numeric&gt;
#include&lt;utility&gt;
#include&lt;iostream&gt;
#include&lt;sstream&gt;
#include&lt;iomanip&gt;
#include&lt;cstdio&gt;
#include&lt;cmath&gt;
#include&lt;cstdlib&gt;
#include&lt;cctype&gt;
#include&lt;string&gt;
#include&lt;cstring&gt;
#include&lt;cstdio&gt;
#include&lt;cmath&gt;
#include&lt;cstdlib&gt;
#include&lt;ctime&gt;
#include&lt;climits&gt;
#include&lt;complex&gt;
#define mp make_pair
#define pb push_back
using namespace std;
const double eps=1e-8;
const double pi=acos(-1.0);
const double inf=1e20;
const int maxp=200007;
int dblcmp(double d)
{
if (fabs(d)&lt;eps)return 0;
return d&gt;eps?1:-1;
}
inline double sqr(double x)
{
return x*x;
}

struct point
{
double x,y;
point()             {                                    }
point(double _x,double _y)
{
x = _x;
y = _y;
}
void input()
{
scanf(&quot;%lf%lf&quot;,&amp;x,&amp;y);
}
void output()
{
printf(&quot;%.2f %.2f\n&quot;,x,y);
}
bool operator==(point a)const
{
return dblcmp(a.x - x) == 0 &amp;&amp; dblcmp(a.y - y) == 0;
}
bool operator&lt;(point a)const
{
return dblcmp(a.x - x) == 0 ? dblcmp(y - a.y) &lt; 0 : x &lt; a.x;
}
point operator-(point a)const
{
return point(x-a.x, y-a.y);
}
double len()
{
return hypot(x, y);
}
double len2()
{
return x * x + y * y;
}
double distance(point p)
{
return hypot(x - p.x, y - p.y);
}
{
return point(x + p.x, y + p.y);
}
point sub(point p)
{
return point(x - p.x, y - p.y);
}
point mul(double b)
{
return point(x * b, y * b);
}
point div(double b)
{
return point(x / b, y / b);
}
double dot(point p)
{
return x*p.x+y*p.y;
}
double det(point p)
{
return x*p.y-y*p.x;
}
{
point p=*this;
return fabs(atan2(fabs(a.sub(p).det(b.sub(p))),a.sub(p).dot(b.sub(p))));
}
point trunc(double r)
{
double l=len();
if (!dblcmp(l))return *this;
r/=l;
return point(x*r,y*r);
}
point rotleft()
{
return point(-y,x);
}
point rotright()
{
return point(y,-x);
}
point rotate(point p,double angle)
{
point v=this-&gt;sub(p);
double c=cos(angle),s=sin(angle);
return point(p.x+v.x*c-v.y*s,p.y+v.x*s+v.y*c);
}
};

struct line
{
point a,b;
line()              {                                    }
line(point _a,point _b)
{
a=_a;
b=_b;
}
bool operator==(line v)
{
return (a==v.a)&amp;&amp;(b==v.b);
}
line(point p,double angle)
{
a=p;
if (dblcmp(angle-pi/2)==0)
{
}
else
{
}
}
//ax+by+c=0
line(double _a,double _b,double _c)
{
if (dblcmp(_a)==0)
{
a=point(0,-_c/_b);
b=point(1,-_c/_b);
}
else if (dblcmp(_b)==0)
{
a=point(-_c/_a,0);
b=point(-_c/_a,1);
}
else
{
a=point(0,-_c/_b);
b=point(1,(-_c-_a)/_b);
}
}
void input()
{
a.input();
b.input();
}
{
if(b&lt;a)swap(a,b);
}
double length()
{
return a.distance(b);
}
double angle()
{
double k=atan2(b.y-a.y,b.x-a.x);
if (dblcmp(k)&lt;0)k+=pi;
if (dblcmp(k-pi)==0)k-=pi;
return k;
}
int relation(point p)
{
int c=dblcmp(p.sub(a).det(b.sub(a)));
if (c&lt;0)return 2;
if (c&gt;0)return 1;
return 0;
}
bool pointonseg(point p)
{
return dblcmp(p.sub(a).det(b.sub(a)))==0&amp;&amp;dblcmp(p.sub(a).dot(p.sub(b)))&lt;=0;
}
bool parallel(line v)
{
return dblcmp(b.sub(a).det(v.b.sub(v.a)))==0;
}
int segcrossseg(line v)
{
int d1=dblcmp(b.sub(a).det(v.a.sub(a)));
int d2=dblcmp(b.sub(a).det(v.b.sub(a)));
int d3=dblcmp(v.b.sub(v.a).det(a.sub(v.a)));
int d4=dblcmp(v.b.sub(v.a).det(b.sub(v.a)));
if ((d1^d2)==-2&amp;&amp;(d3^d4)==-2)return 2;
return (d1==0&amp;&amp;dblcmp(v.a.sub(a).dot(v.a.sub(b)))&lt;=0||
d2==0&amp;&amp;dblcmp(v.b.sub(a).dot(v.b.sub(b)))&lt;=0||
d3==0&amp;&amp;dblcmp(a.sub(v.a).dot(a.sub(v.b)))&lt;=0||
d4==0&amp;&amp;dblcmp(b.sub(v.a).dot(b.sub(v.b)))&lt;=0);
}
int segcrossseg_inside(line v)
{
if(v.pointonseg(a) || v.pointonseg(b) || pointonseg(v.a) || pointonseg(v.b)) return 0;
int d1=dblcmp(b.sub(a).det(v.a.sub(a)));
int d2=dblcmp(b.sub(a).det(v.b.sub(a)));
int d3=dblcmp(v.b.sub(v.a).det(a.sub(v.a)));
int d4=dblcmp(v.b.sub(v.a).det(b.sub(v.a)));
if ((d1^d2)==-2&amp;&amp;(d3^d4)==-2)return 1;
return (d1==0&amp;&amp;dblcmp(v.a.sub(a).dot(v.a.sub(b)))&lt;=0||
d2==0&amp;&amp;dblcmp(v.b.sub(a).dot(v.b.sub(b)))&lt;=0||
d3==0&amp;&amp;dblcmp(a.sub(v.a).dot(a.sub(v.b)))&lt;=0||
d4==0&amp;&amp;dblcmp(b.sub(v.a).dot(b.sub(v.b)))&lt;=0);
}
int linecrossseg(line v) //*this seg v line
{
int d1=dblcmp(b.sub(a).det(v.a.sub(a)));
int d2=dblcmp(b.sub(a).det(v.b.sub(a)));
if ((d1^d2)==-2)return 2;
return (d1==0||d2==0);
}
int linecrossline(line v)
{
if ((*this).parallel(v))
{
return v.relation(a)==3;
}
return 2;
}
point crosspoint(line v)
{
double a1=v.b.sub(v.a).det(a.sub(v.a));
double a2=v.b.sub(v.a).det(b.sub(v.a));
return point((a.x*a2-b.x*a1)/(a2-a1),(a.y*a2-b.y*a1)/(a2-a1));
}
double dispointtoline(point p)
{
return fabs(p.sub(a).det(b.sub(a)))/length();
}
double dispointtoseg(point p)
{
if (dblcmp(p.sub(b).dot(a.sub(b)))&lt;0||dblcmp(p.sub(a).dot(b.sub(a)))&lt;0)
{
return min(p.distance(a),p.distance(b));
}
return dispointtoline(p);
}
point lineprog(point p)
{
}
point symmetrypoint(point p)
{
point q=lineprog(p);
return point(2*q.x-p.x,2*q.y-p.y);
}
};

struct polygon
{
int n=0;
point p[maxp];
line l[maxp];
void input(int _n)
{
n=_n;
for (int i=0; i&lt;n; i++)   p[i].input();
}
{
p[n++]=q;
}
void getline()
{
for (int i=0; i&lt;n; i++)
l[i]=line(p[i],p[(i+1)%n]);
}
struct cmp
{
point p;
cmp(const point &amp;p0)
{
p=p0;
}
bool operator()(const point &amp;aa,const point &amp;bb)
{
point a=aa,b=bb;
int d=dblcmp(a.sub(p).det(b.sub(p)));
if (d==0)
return dblcmp(a.distance(p)-b.distance(p))&lt;0;
return d&gt;0;
}
};
void norm()
{
point mi=p[0];
for (int i=1; i&lt;n; i++)mi=min(mi,p[i]);
sort(p,p+n,cmp(mi));
}
void getconvex(polygon &amp;convex)
{
int i;
sort(p,p+n);
convex.n=n;
for (i=0; i&lt;min(n,2); i++) convex.p[i]=p[i];
if (n&lt;=2)return;
int &amp;top=convex.n;
top=1;
for (i=2; i&lt;n; i++)
{
while (top&amp;&amp;convex.p[top].sub(p[i]).det(convex.p[top-1].sub(p[i]))&lt;0)
top--;
convex.p[++top]=p[i];
}
int temp=top;
convex.p[++top]=p[n-2];
for (i=n-3; i&gt;=0; i--)
{
while (top!=temp&amp;&amp;convex.p[top].sub(p[i]).det(convex.p[top-1].sub(p[i]))&lt;0)
top--;
convex.p[++top]=p[i];
}
}
bool isconvex()
{
bool s[3];
memset(s,0,sizeof(s));
int i,j,k;
for (i=0; i&lt;n; i++)
{
j=(i+1)%n;
k=(j+1)%n;
s[dblcmp(p[j].sub(p[i]).det(p[k].sub(p[i])))+1]=1;
if (s[0]&amp;&amp;s[2])return 0;
}
return 1;
}

};

int main()
{
int n,m;
scanf(&quot;%d %d&quot;,&amp;n,&amp;m);
polygon a,b,ab;
for(int i=0; i&lt;n; i++)
{
double x,y;
scanf(&quot;%lf %lf&quot;,&amp;x,&amp;y);
}
for(int i=0; i&lt;m; i++)
{
double x,y;
scanf(&quot;%lf %lf&quot;,&amp;x,&amp;y);
}

polygon cha, chb, chab;

//    a.getconvex(cha);
//    b.getconvex(chb);
ab.getconvex(chab);

sort(a.p,a.p+a.n);
sort(b.p,b.p+b.n);
sort(chab.p,chab.p+chab.n);

//       cout&lt;&lt;ab.n&lt;&lt;endl;
//    for(int i=0;i&lt;ab.n;i++)
//        cout&lt;&lt;ab.p[i].x&lt;&lt;&quot; &quot;&lt;&lt;ab.p[i].y&lt;&lt;endl;
//
//    cout&lt;&lt;&quot;---------------------&quot;&lt;&lt;endl;
//
//    cout&lt;&lt;chab.n&lt;&lt;endl;
//    for(int i=0;i&lt;chab.n;i++)
//        cout&lt;&lt;chab.p[i].x&lt;&lt;&quot; &quot;&lt;&lt;chab.p[i].y&lt;&lt;endl;

if(a.n==chab.n)
{
bool check=0;
for(int i=0; i&lt;a.n; i++)
if(a.p[i]==chab.p[i]) continue;
else
{
check=1;
break;
}
if(check==0)
{
printf(&quot;YES\n&quot;);
return 0;
}
}

if(b.n==chab.n)
{
bool check=0;
for(int i=0; i&lt;b.n; i++)
if(b.p[i]==chab.p[i]) continue;
else
{
check=1;
break;
}
if(check==0)
{
printf(&quot;YES\n&quot;);
return 0;
}
}

printf(&quot;NO\n&quot;);
return 0;

}

```