Before optimising your code, it is probably a good idea to write a few tests to ensure you don't break anything as you go. There is something quite good in your situation : your code is supposedly easy to test as you know the mathematical properties that your result should have : a = b * q + r with 0 <= r < b.

Writing something like :

std::cout << "j" << "*" << "q" << "+" << "r" << " = " << "t" << " (" << "i" << ")" << std::endl;
for (uint i = 2; i < 10; i++)
    for (uint j = 2; j < 10; j++)
    {
        uint q = 0;
        uint r = 0;
        DivisionDivideAndConquer(i, j, q, r);
        uint total = j * q + r;
        if (total != i)
                std::cout << j << "*" << q << "+" << r << " = " << total << " (" << i << ")" << std::endl;
    }

shows that there is something wrong in your result which is the first problem (Hint: the problem is in the shortcut). Trying to perform tests with j starting from 1 shows that there is another issue (Hint: a loop does not finish).

Actual optimisation

Think about the cases you are trying to handle or how you are trying to reduce the search range.

With the following code, you compute less in each iteration while making the search range smaller :

    // if too small then we have a new max
    if (possibleremainder < 0) {
        max = number - 1;
    }
    // too big we have a new min
    else if(possibleremainder >= static_cast<int>(den) )
    {
        min = number + 1;
    }
    else
    {
        //  got it!
        quo = number;
        rem = static_cast<uint>(possibleremainder);
        break;
    }

This function equals to your previous code with some simplification. Never be so aware of performance.

void DivisionDivideAndConquer(const unsigned int Num, const unsigned int Den, unsigned int& Quo, unsigned int& Rem)
{
    //  short cuts
    if (Num < Den)
    {
        Quo = 0;
        Rem = Den;
    }
    else
    {
        unsigned int min = 0;
        unsigned int max = Num;

        while (true)
        {
            unsigned int number = static_cast<unsigned int>((min + max) * 0.5);
            int possibleRemainder = (Num - (Den * number));

            // if too small then we have a new max
            if (possibleRemainder < 0) {
                (number == max ? max-- : max = number);
            }
            // too big we have a new min
            else if (possibleRemainder >= static_cast<int>(Den))
            {
                (number == max ? min++ : min = number);
            }
            else
            {
                //  got it!
                Quo = number;
                Rem = static_cast<unsigned int>(possibleRemainder);
            }
        }
    }
}

We can see:

• I used ternaries operators.
• I used a simple while (true) which IMHO is more readable than a for (;;) but the equivalent.

If you want to "improve" greatly or less your performance, you should change the cast static_cast function is the part of your code which affects more to the performance, but you are casting properly.

typedef unsigned int uint;

void divideAndConquer(const uint num, const uint den, uint& quo, uint& rem)
{
    if (num < den)
    {
        quo = 0;
        rem = num;
        return;
    }
    if(num == den)
    {
        quo = 1;
        rem = 0;
        return;
    }
    uint min = 0,
         max = num;
    while (1) {
        uint number = (max + min) >> 1;
        int  posRem = num - den * number;
        if(posRem < 0)
            max = number - 1;
        else if(uint(posRem) >= den)
            min = number + 1;
        else {
            quo = number;
            rem = uint(posRem);
            break;
        }
    } // End of while loop!
} // End of divideAndConquer

Names

I used typedef because I was tired of typing unsig.... (Just me being lazy)

I changed the name of the function because I prefer making class names capitalized and functions more of a descriptive action. Also, I felt saying division then divide redundant even though they weren't intended to mean the mathematical division:)

Also, made the variable names all lowercase because of the same reasons pertaining to the classes.

Note, posRem is not a good name... I just liked how it lines up with number:)lol

Dividing By 2

When dividing by two, the fastest way would be to do a bit shift. But, if the values are negative, the bit shift might not work. Since we are using uints we know that we won't get anything funky. (Explained more in the link)

Casting

You won't have any problems doing a normal type cast (unless you start hitting negative numbers) between int and uint. So, what I did was only type cast posRem because I know posRem is positive when I go to cast.

Reduced Logic

I spent a good while reducing the logic that you had and I was so excited and when I broke it down and simplified it (doesn't do the exact same thing but usually does better). Then I realized that @Josay (+1) came up with the same thing way before me...

Steps

I started looking at how many steps it took to do the divide and conquer and noticed something funny. Your code works great when the numbers divide evenly. Usually finishing in about one to three steps! And some do really good even when they don't, for example 100/7 it would take about seven steps. With the updated logic it comes out to five. But, 100/31 takes your logic five and the new one six. That is really bad on both considering that you could just subtract three times and realize you found the remainder and quotient. So, I brought in the old school way to ensure that the largest amount of steps taken will always be the quotient:

typedef unsigned int uint;

void divideAndConquer(const uint num, const uint den, uint& quo, uint& rem)
{
    if (num < den)
    {
        quo = 0;
        rem = num;
        return;
    }
    if(num == den)
    {
        quo = 1;
        rem = 0;
        return;
    }
    quo = 0;
    rem = num;

    uint min = 0,
         max = num;

    while (rem >= den) {
        uint number = (max + min) >> 1;
        int  posRem = num - den * number;
        if(posRem < 0)
            max = number - 1;
        else if(uint(posRem) >= den)
            min = number + 1;
        else {
            quo = number;
            rem = uint(poRem);
            return;
        }
        // Old school:)
        rem -= den;
        ++quo;
    } // End of while loop!
} // End of divideAndConquer

This still doesn't seem like the least amount of steps to accomplish this, but you know now that the time complexity cannot be larger than the quotient.

Hope this helps some!