Search for solutions to quartic diophantine equation
This looks like a bug:

if (LHS == RHS &amp;&amp; (arrA[a] != arrB[b] != arrC[c] != arrD[d])) 


The operator != returns a boolean result. Its Associativity is also left to write. so the above is equivalent to:

if (LHS == RHS &amp;&amp; (((arrA[a] != arrB[b]) != arrC[c]) != arrD[d])) 


So:

arrA[a]         != arrB[b]     =&gt;  true or false
(true or false) != arrC[c]     =&gt;  true or false  (so usually true)
true            != arrD[d]     =&gt;  true or false  (so usually true)

LHS == RHS &amp;&amp; true             =&gt;  Looking for LHS == RHS


This is a bad way of writing a nested loop:

while (d &lt; 430000)
{       
    if (a == 430000)
    {           
        a = 0; 
        b++;        
    }       
    if (b == 430000) 
    {           
        a = 0; 
        b = 0; 
        c++;        
    }       
    if (c == 430000) 
    {           
        a = 0; 
        b = 0; 
        c = 0; 
        d++;        
    }               
    if (d == 430000) 
    {           
        break;      
    }   
    LHS = arrA[a] + arrB[b] + arrC[c];      
    RHS = arrD[d];
    // stuff
}


Just write:

for(int a = 0; a &lt; 430000; ++a) {
    for(int b = 0; b &lt; 430000; ++b) {
        for(int c = 0; c &lt; 430000; ++c) {
            for(int d = 0; d &lt; 430000; ++d) {
                LHS = arrA[a] + arrB[b] + arrC[c];      
                RHS = arrD[d];
                // stuff
            }
        }
    }
}


There is no point looping over all the values.

if a^4 + b^4 + c^4 &gt; 430000^4 then there is no point in running through the d loop as you will never find the value.

There is no point in checking all values of d. If you must use a search arrD then do a binary search of the array. This will vastly reduce the number of items checked in the innermost loop. Alternatively just find the cube root of the result using a maths function.

 double root = std::pow(LHS, 1.0/4.0);
 double base = std::floor(root); 
 if (floor * floor * floor * floor == LHS) {
     break;
 }


I am not convinced that calculating and saving all the powered values is going to save time. Also  you don't need to save the same result four times. Rather than have arrA and arrB and arrC and arrD have a single array arr. It is the index into the array that is important.

Also don't manually allocate this space with new use a vector&lt;double&gt;.

The question is a memory lookup faster than or slower than doing 4 multiplications (or callling std::pow(x, 4)). That is something you will need to time and find out.