AntiPalindromic Strings - c

Question

Actually this is one of the challenges from hackerearth. Here is the link to the problem : https://www.hackerrank.com/challenges/antipalindromic-strings
I somehow figured a way to find the answer. But the problem my code doesn't get accepted due to timeout. Please help me which part makes my code slower.
This is my code :
int anti_palindrome(long int n,long int m,int mod)
{
int prod;
prod=m;
if(n>1)
prod=prod*(m-1);
if(n>2)
{
n=n-2;
while(n)
{
prod=prod*(m-2);
n--;
}
}
return prod%mod;
}
int main()
{
char scanned[1000];
int input = 0;
int T=0;
int T_cur=0;
long int N,M;
char str[1000];
int mod=1000000007;
while(fgets(scanned,1000,stdin))
{
switch(input)
{
case 0: {
T=atoi(scanned);
input=1;
}
break;
case 1: {
T_cur++;
strcpy(str,scanned);
sscanf(str,"%d %d",&N,&M);
//printf("%lf %lf\n",N,M);
printf("%d\n",anti_palindrome(N,M,mod));
}
break;
}
if(T_cur==T)
break;
}
return 0;
}
Any one run of the program may need to process up to 105 N, M pairs, with N and M each between 1 and 109.

Answer 1

Please help me which part makes my code slower.
There aren't many parts to consider. Generally speaking, I/O is much slower than computation, but you haven't any more I/O than is needed, so let's disregard that for the moment.
Consider, then, your anti_palindrome() function. In the general case, it loops N times, performing three arithmetic operations and two assignments in each iteration. That's not expensive on a per-iteration basis, but you may have a billion iterations per test case, and ten thousand test cases, for a total of around 5x1014 mixed operations. That number of operations is going to take more than a few seconds.
While I'm at it, I observe that your algorithm is wrong anyway. You are supposed to report the answer modulo 109 + 7, but long before you get to the end of the computation, you will have overflowed the prod variable. The resulting behavior is undefined. If prod had an unsigned type then the behavior would be defined, but still wrong. Switching to pow() instead of a loop would improve the performance enormously, but would not solve this problem. You need something cleverer.

Answer 2

As m-2 is constant, write m= m-2; before the loop. Now, what remains is that n times prod=prod*m; is executed. This is equivalent to prod= prod*pow(m,n); The math library may have an efficient implementation of pow() that will prevent your timing issue.
In C you may have to cast the parameters to double, and the return value to long int.
int anti_palindrome(long int n,long int m,int mod)
{
int prod;
prod=m;
if(prod>1)
prod=prod*(m-1);
if(prod>2)
{
n=n-2;
m=m-2;
prod= prod*pow(m,n);
}
return prod%mod;
}