Optimal way to annihilate a list by removing items from the ends
Missing use of memoization
Your program is almost right, but you aren't using your memoization to the fullest potential.  When the array ends match, you don't check for the memoized value.  Therefore, a stress test of an array of 1000 elements with all the same values causes your program to run for a very long time.
Also, another optimization is that when the array ends match, you can always remove 2 instead of also trying to remove just 1 end (which can only be equal or worse than removing both ends).
Other things to note
Your use of 1010 as an array size is a bit odd.  First of all, you can use exactly 1000 as the problem stated.  Maybe you were afraid of a buffer overflow, but there isn't any.   Also you could use a #define instead of copy/pasting the value all over the place.  That way you could easily change the test size without accidentally missing one place or another.
You don't need to use long long for your array.  An int can hold values up to 10^9.
Corrected function
Here is your function with the memoization corrected:
int recur(unsigned int *arr,int i,int j){
    if(i &gt; j){
        return 0;
    }
    if(memoization[i][j])
        return memoization[i][j];
    if(arr[i] == arr[j])
        return memoization[i][j] = 1 + recur(arr,i+1,j-1);
    return memoization[i][j] = 1 + minOf2(recur(arr,i+1,j),recur(arr,i,j-1));
}

I made an array of 1000 elements all the same value and ran the function 10 times.  With the original code, it took 9.6 seconds.  With the corrected code it took 0.04 seconds.