# 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;
}

```

# Light OJ: 1162 – Min Max Roads

0

```
#include &lt;bits/stdc++.h&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)             cout&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:\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;

/*----------------------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 n,q;
vector&lt;int&gt;g[mx],cost[mx];

int par[mx], dis[mx], level[mx];

int sparse_par[mx][20],sparse_max[mx][20], sparse_min[mx][20];

void dfs(int u, int cnt, int from)
{
par[u]=from;
level[u]=cnt;

for(int i=0;i&lt;SZ(g[u]);i++)
{
int v=g[u][i];
if(v!=from)
{
dis[v]=cost[u][i];
dfs(v,cnt+1,u);
}
}
}

void build_table()
{
ms(sparse_par,-1);

sparse_par[1][0]=par[1];
sparse_min[1][0]=INT_MAX;
sparse_max[1][0]=0;

for(int i=2;i&lt;=n;i++)
{
sparse_par[i][0]=par[i];
sparse_min[i][0]=dis[i];
sparse_max[i][0]=dis[i];
}

for(int j=1;1&lt;&lt;j&lt;n;j++)
{
for(int i=1;i&lt;=n;i++)
{
if(sparse_par[i][j-1]!=-1)
{
//                D(i);
//                D(j);

sparse_par[i][j]=sparse_par[sparse_par[i][j-1]][j-1];
sparse_max[i][j]=max(sparse_max[i][j-1],sparse_max[sparse_par[i][j-1]][j-1]);
sparse_min[i][j]=min(sparse_min[i][j-1],sparse_min[sparse_par[i][j-1]][j-1]);
//                D(sparse_par[i][j]);
//                D(sparse_max[i][j]);
//                D(sparse_min[i][j]);
}
}
}

}

pii query(int p, int q)
{
if(level[p]&lt;level[q]) swap(p,q);

int log=log2(level[p]);

int maxi=0,mini=INT_MAX;

for(int i=log;i&gt;=0;i--)
{
if(level[p]-(1&lt;&lt;i)&gt;=level[q])
{
maxi=max(maxi,sparse_max[p][i]);
mini=min(mini,sparse_min[p][i]);

p=sparse_par[p][i];

}
}

if(p==q)
{
return pii(mini,maxi);
}

for(int i=log;i&gt;=0;i--)
{
if(sparse_par[p][i]!=-1 &amp;&amp; sparse_par[p][i]!=sparse_par[q][i])
{
maxi=max(maxi,max(sparse_max[p][i],sparse_max[q][i]));
mini=min(mini,min(sparse_min[p][i],sparse_min[q][i]));
p=sparse_par[p][i];
q=sparse_par[q][i];
}
}

maxi=max(maxi,max(dis[p],dis[q]));
mini=min(mini,min(dis[p],dis[q]));

return pii(mini,maxi);

}

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)
{
sf(n);

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

dis[1]=0;
dfs(1,0,1);

build_table();

sf(q);

PRINT_CASE;

while(q--)
{
int a,b;
sff(a,b);
pii ans=query(a,b);
printf(&quot;%d %d\n&quot;,ans.ff,ans.ss);

}

for(int i=0;i&lt;=n;i++)
{
g[i].clear();
cost[i].clear();
}

}

return 0;
}

```

# Light OJ: 1128 – Greatest Parent

0

```
#include &lt;bits/stdc++.h&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)             cout&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:\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;

/*----------------------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));}
/*------------------------------------------------*/

int n,q;

int par[100005];
ll dis[100005];

int sparse_par[100005][20];

void build_talbe()
{
ms(sparse_par,-1);
for(int i=0; i&lt;n; i++)
{
sparse_par[i][0]=par[i];
}

for(int j=1; 1&lt;&lt;j &lt;n; j++)
{
for(int i=0; i&lt;n; i++)
{
sparse_par[i][j]=sparse_par[sparse_par[i][j-1]][j-1];
}
}
}

ll query(int p, ll v)
{

int log=log2(n);

for(int i=log; i&gt;=0; i--)
{

//        int a=sparse_par[p][i];
//        int b=dis[sparse_par[p][i]];

if(dis[sparse_par[p][i]]&gt;=v)
{
p=sparse_par[p][i];
}
}

return p;

}

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)
{
sff(n,q);

par[0]=0;
dis[0]=1;

loop1(i,n-1)
{
ll a,b;
sffl(a,b);
par[i]=a;
dis[i]=b;
}

build_talbe();

PRINT_CASE;

while(q--)
{
ll a,b;
sffl(a,b);
printf(&quot;%d\n&quot;,query(a,b));
}

}

return 0;
}

```

# Light OJ: 1101 – A Secret Mission

0

```
#include &lt;bits/stdc++.h&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)             cout&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:\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;

/*----------------------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));}
/*------------------------------------------------*/

typedef pair&lt;int,pii &gt; piii;

vector&lt; piii &gt; g1;

vector&lt;int&gt;g[50005],cost[50005];

int n,m;

int par[50004];

int find_par(int u)
{
return par[u]=(par[u]==u)?u:find_par(par[u]);
}

int dis[50005],level[50005];

void dfs(int u, int cnt, int from)
{
level[u]=cnt;
par[u]=from;

for(int i=0; i&lt;SZ(g[u]); i++)
{
int v=g[u][i];

if(level[v]==-1)
{
dis[v]=cost[u][i];
dfs(v,cnt+1,u);
}
}

}

int sparse_par[50005][16];
int sparse_max[50005][16];

void build_table()
{

ms(sparse_par,-1);

for(int i=1; i&lt;=n; i++)
sparse_par[i][0]=par[i],sparse_max[i][0]=dis[i];

for(int i=1; 1&lt;&lt;i &lt;=n; i++)
{
for(int j=1; j&lt;=n; j++)
if(sparse_par[j][i-1]!=-1)
{
sparse_par[j][i]=sparse_par[sparse_par[j][i-1]][i-1];
sparse_max[j][i]=max(sparse_max[j][i-1],sparse_max[sparse_par[j][i-1]][i-1]);
}
}

}

int query(int p, int q)
{
int a=p,b=q;

if(level[p]&lt;level[q]) swap(p,q);

int log=log2(level[p]);

int ret=0;

for(int i=log; i&gt;=0; i--)
{
if(level[p]-(1&lt;&lt;i) &gt;=level[q])
{
ret=max(ret,sparse_max[p][i]);
p=sparse_par[p][i];
}
}

if(p==q) return ret;

for(int i=log; i&gt;=0; i--)
if(sparse_par[p][i]!=-1 &amp;&amp; sparse_par[p][i]!=sparse_par[q][i])
{
ret=max(ret,max(sparse_max[p][i],sparse_max[q][i]));
p=sparse_par[p][i],q=sparse_par[q][i];
}
ret=max(ret,max(dis[p],dis[q]));
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)
{

g1.clear();

sff(n,m);
for(int i=0; i&lt;m; i++)
{
int a,b,c;
sfff(a,b,c);
g1.pb(piii(c,pii(a,b)));
}

sort(all(g1));

//        reverse(all(g1));

int cnt=0;

for(int i=1; i&lt;=n; i++) par[i]=i,g[i].clear(),cost[i].clear();

for(int i=0; i&lt;SZ(g1) &amp;&amp; cnt&lt;n-1; i++)
{
int a=g1[i].ss.ff;
int b=g1[i].ss.ss;
int c=g1[i].ff;
int u=find_par(a);
int v=find_par(b);

if(u!=v)
{
par[v]=u;
g[a].pb(b);
g[b].pb(a);
cost[a].pb(g1[i].ff);
cost[b].pb(g1[i].ff);
cnt++;
}
}

ms(level,-1);
dis[1]=0;

dfs(1,0,1);

build_table();

int q;
sf(q);
PRINT_CASE;

while(q--)
{
int a, b;
sff(a,b);
printf(&quot;%d\n&quot;,query(a,b));
}

}

return 0;
}

```

# Light OJ: 1081 – Square Queries

0

Solution Idea: Build a 2D sparse table for the given array. Then query the answer form the sparse table.

```
#include &lt;bits/stdc++.h&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)             cout&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:\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;

/*----------------------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));}
/*------------------------------------------------*/

int n,q;

int ara[505][505];
int sparse[505][505][16];

void build()
{
for(int k=0; (1&lt;&lt;k)&lt;=n; k++)
{
for(int i=0; i+(1&lt;&lt;k)-1&lt;n; i++)
for(int j=0; j+(1&lt;&lt;k)-1&lt;n; j++)
{
if(k==0)
sparse[i][j][k]=ara[i][j];
else
{
int a=1&lt;&lt;(k-1);
sparse[i][j][k]=max(max(sparse[i][j][k-1],sparse[i+a][j][k-1]),max(sparse[i][j+a][k-1],sparse[i+a][j+a][k-1]));
}
}
}
}

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)
{
sff(n,q);

loop(i,n) loop(j,n) sf(ara[i][j]);

build();

PRINT_CASE;

while(q--)
{
int i,j,s;
sfff(i,j,s);
int k=log2(s);
int a=1&lt;&lt;k;
i--;
j--;
int ans=max(max(sparse[i][j][k],sparse[i+s-a][j][k]),max(sparse[i][j+s-a][k],sparse[i+s-a][j+s-a][k]));
pf(&quot;%d\n&quot;,ans);

}

}

return 0;
}

```