# Light OJ: 1347 – Aladdin and the Magical Lamp

Solution Idea:
###############
Solution idea for this problem is following-
1. Concatenate 3 input string one after another and make one single string.
2. Build Suffix array and store every step rank.
3. Run sliding window or two pointer on sorted suffix array and find the range in which 3 string presents. and determine the LCP of beginning and ending string of that range segment.
4. Largest LCP value find during step 3 is the answer.

```
#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: &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;

/*----------------------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 30005

int SA[mx],tempSA[mx];
int RA[mx],tempRA[mx];
int c[mx];
//int LCP[mx],PLCP[mx],Phi[mx];
int P[18][mx],stp;
string str;
char s1[mx];
int n;

void counting_sort(int k)
{
int maxi=max(300,n);
ms(c,0);
for(int i=0; i&lt;n; i++)
{
int a=i+k&lt;n?RA[i+k]:0;
c[a]++;
}
for(int i=0,sum=0; i&lt;maxi; i++)
{
int x=c[i];
c[i]=sum;
sum+=x;
}

for(int i=0; i&lt;n; i++)
{
int a=SA[i]+k&lt;n?RA[SA[i]+k]:0;
int b=c[a];
c[a]++;
tempSA[b]=SA[i];
}

for(int i=0; i&lt;n; i++)
SA[i]=tempSA[i];
}

void build_Suffix_Array()
{
stp=0;
for(int i=0; i&lt;n; i++)
{
RA[i]=str[i];
SA[i]=i;
P[stp][i]=RA[i];
}

stp++;

for(int k=1; k&lt;n; k*=2)
{
counting_sort(k);
counting_sort(0);
int r=0;
tempRA[SA[0]]=r=0;
for(int i=1; i&lt;n; i++)
{
if(RA[SA[i]]==RA[SA[i-1]] &amp;&amp; RA[SA[i]+k]==RA[SA[i-1]+k])
tempRA[SA[i]]=r;
else
tempRA[SA[i]]=++r;
}
for(int i=0; i&lt;n; i++)
{
RA[i]=tempRA[i];
P[stp][i]=RA[i];
}
stp++;
if(RA[SA[n-1]]==n-1) break;
}
stp--;
}

int find_lcp(int x, int y)
{
int ret=0;
if(x==y) return n-x;
for(int k=stp; k&gt;=0 &amp;&amp; x&lt;n &amp;&amp; y&lt;n; k--)
{
if(P[k][x]==P[k][y])
{
x+=(1&lt;&lt;k);
y+=(1&lt;&lt;k);
ret+=(1&lt;&lt;k);
}
}
return ret;
}

int vis[5];

int getRange(int idx, int pos1, int pos2)
{
if(idx&lt;pos1) return 1;
if(idx&lt;pos2) return 2;
return 3;
}

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)
{
str.clear();
scanf(&quot;%s&quot;,s1);
str+=string(s1);
str+=&quot;@&quot;;
int pos1=SZ(str)-1;
scanf(&quot;%s&quot;,s1);
str+=string(s1);
str+=&quot;\$&quot;;
int pos2=SZ(str)-1;
scanf(&quot;%s&quot;,s1);
str+=string(s1);
str+=&quot;#&quot;;
n=SZ(str);
//        cout&lt;&lt;str&lt;&lt;endl;
build_Suffix_Array();

//        for(int i=0; i&lt;n; i++)
//            cout&lt;&lt;str.substr(SA[i])&lt;&lt;endl;

int ans=0;

int i=3,j=3;
ms(vis,0);
int cnt=0;
while(j&lt;n)
{
int a=getRange(SA[j],pos1,pos2);
if(vis[a]==0)
{
cnt++;
}
vis[a]++;
if(cnt==3)
{
int temp=find_lcp(SA[i],SA[j]);
ans=max(ans,temp);
}
while(cnt&gt;=3)
{
a=getRange(SA[i],pos1,pos2);
vis[a]--;
i++;
if(vis[a]==0)
cnt--;
if(cnt==3)
{
int temp=find_lcp(SA[i],SA[j]);
ans=max(ans,temp);
}
}
j++;
}
PRINT_CASE;
pf(&quot;%d\n&quot;,ans);
}

return 0;
}

```