Здравей не си забелязал, че в задачата под изброените решения има многоточие. Тоест не са ги  изброили всичките.
 
1 + -1 = 0
1 + 1 + -1 + -1 = 0
1 + -1 + 1 + -1 = 0
…

А това, че се получават неуникални сборове даващи 0, не трябва да те притеснява, това е  напълно нормално, тъй като има повтарящи се числа в първоначално даденото множество, но в  действителност те са си напълно уникални, защото при решаването на задачата ти трябва да  направиш всички комбинации между първото, второто, третото, четвъртото и петото число така,  а когато има повтарящи се числа като сега, просто се получават повторения на повтарящите се  числа участващи в нулевия сбор. 

В нашият случай имаме:
            
    int[] numbers = { 1, 1, 1, -1, -1 };

Комбинациите от 2 числа даващи сбор 0, в случая са:
1. 1 - 1 = 0
2. 1 - 1 = 0
3. 1 - 1 = 0
4. 1 - 1 = 0
5. 1 - 1 = 0
6. 1 - 1 = 0

Те са си уникални, защото това всъщност са:
1. първото число + четвъртото число = 0
2. първото число + петото число = 0
3. второто число + четвъртото число = 0
4. второто число + петото число = 0
5. третото число + четвъртото число = 0
6. третото число + петото число = 0

или

1. numbers[0] + numbers[3] = 0
2. numbers[0] + numbers[4] = 0
3. numbers[1] + numbers[3] = 0
4. numbers[1] + numbers[4] = 0
5. numbers[2] + numbers[3] = 0
6. numbers[2] + numbers[4] = 0

Аз съм решил задачата с битове.
Използвам битова маскa.
В битовата маска, бит със стойност 1 означава числото участва в новото подмножество, бит със  стойност 0 означава числото не участва в новото подмножество.
Битовата маска всъщност са ми коефициентите, пред всяко едно от дадените числа.

Ето и решенията на задачата:

числа:           1, 1, 1, -1, -1

битова маска:    1  0  0   1   0

резултат:        1        -1      = 0

числа:           1, 1, 1, -1, -1

битова маска:    1  0  0   0   1

резултат:        1            -1  = 0

числа:           1, 1, 1, -1, -1

битова маска:    0  1  0   1   0

резултат:           1     -1      = 0

числа:           1, 1, 1, -1, -1

битова маска:    0  1  0   0   1

резултат:           1         -1  = 0

числа:           1, 1, 1, -1, -1

битова маска:    0  0  1   1   0

резултат:              1  -1      = 0

числа:           1, 1, 1, -1, -1

битова маска:    0  0  1   0   1

резултат:              1      -1  = 0

числа:           1, 1, 1, -1, -1

битова маска:    1  1  0   1   1

резултат:        1+ 1     -1  -1  = 0

числа:           1, 1, 1, -1, -1

битова маска:    1  0  1   1   1

резултат:        1+    1  -1  -1  = 0

числа:           1, 1, 1, -1, -1

битова маска:    0  1  1   1   1

резултат:           1+ 1  -1  -1  = 0

Общо 9 възможни комбинации, даващи сбор 0.

А ето и кратко решение и описание как се стига до горните решения:

int coefficients = 0 //Това ми е битовата маска в случа само нули в битовете 

0 0 0 0 0 - битовете на цялото число 0

0 0 0 0 1 - битовете на цялото число 1

0 0 0 1 0 - битовете на цялото число 2

0 0 0 1 1 - битовете на цялото число 3

0 0 1 0 0 - битовете на цялото число 4

0 0 1 0 1 - битовете на цялото число 5

0 0 1 1 0 - битовете на цялото число 6

0 0 1 1 1 - битовете на цялото число 7

0 1 0 0 0 - битовете на цялото число 8

0 1 0 0 1 - битовете на цялото число 9

0 1 0 1 0 - битовете на цялото число 10

0 1 0 1 1 - битовете на цялото число 11

0 1 1 0 0 - битовете на цялото число 12

0 1 1 0 1 - битовете на цялото число 13

0 1 1 1 0 - битовете на цялото число 14

0 1 1 1 1 - битовете на цялото число 15

1 0 0 0 0 - битовете на цялото число 16

1 0 0 0 1 - битовете на цялото число 17

1 0 0 1 0 - битовете на цялото число 18

1 0 0 1 1 - битовете на цялото число 19

1 0 1 0 0 - битовете на цялото число 20

1 0 1 0 1 - битовете на цялото число 21

1 0 1 1 0 - битовете на цялото число 22

1 0 1 1 1 - битовете на цялото число 23

1 1 0 0 0 - битовете на цялото число 24

1 1 0 0 1 - битовете на цялото число 25

1 1 0 1 0 - битовете на цялото число 26

1 1 0 1 1 - битовете на цялото число 27

1 1 1 0 0 - битовете на цялото число 28

1 1 1 0 1 - битовете на цялото число 29

1 1 1 1 0 - битовете на цялото число 30

1 1 1 1 1 - битовете на цялото число 31

Формулата за броя на всички възможни комбинации е:
2^n - където n = броя на елементите на първоначално даденото множество.
В в случая множество с  5 елемента, а именно числата { 1, 1, 1, -1, -1 };
И се получават 2^5 = 32 възможни комбинации.

Като ние започваме от 0 до ((2^n) -1) = Общо 2^n комбинации от числата.
В нашият случай от 0 до 31. Общо 32 комбинации от числата

Това са всички възможни комбинации като при:
0 0 0 0 0 - не участва нито едно от числата (така нареченото празно множество, тоест такова  което е без елементи вътре в себе си, няма нито един елемент, празно) (имаме множество с 0  елемента)

0 0 0 0 1 - участва само най-дясното число (имаме множество с 1 елемент)

0 0 0 1 1 - участват само двете най-десни числа (имаме множество с 2 елемента)

1 0 0 1 1 - участват само най-лявото число и двете най-десни числа (имаме множество с 3  елемента)

1 1 1 1 1 - участват всички числа (имаме множество с 5 елемента)

и така нататък..

Както виждате ако си сложим на coefficients стойност 0 и после започнем да го увеличаваме с  единица, като стигнем до 31 включително ще получим всички възможни комбинации от битове,  сътоветно всички комбинации(подмножества) от числа, които можем да образуваме. Само, че в  случая сме сложили на coefficients 31 и намаляваме до 1 включително, което не променя решенията, просто  ще излизат в обратен ред, на този, който биха излезли ако бяхме започнали с 0 и увеличаме до  31. Само две забележки не стигаме до 0, а до 1, нулата не я използваме защото при нея не  участва нито един от елементите на нашето първоначално множество. Също така не използваме и  подмножествата които имат само 1 елемент, тоест това са стойностите на coefficients със сетнат само един бит в цялото число. Под  сетнат само един бит в цялото число, имам предвид, че имаме само 1 бит със стойност 1-ца в цялото число. В  задачата по-долу първо проверяваме дали в coefficients има сетнат само 1 бит, и ако това е  така, тогава прескачаме тази итерация на цикъла с командата continue; Това което continue  прави е, отива директно в края на цикъла. От там нататък е ясно, прави се декрементацията на  coefficients (coefficients--) и отново се изпълнява тялото на цикъла.

int[] numbers = { 1, 1, 1, -1, -1 };

int coefficientCombinations = (int) Math.Pow(2, numbers.Length) - 1;

for (int coefficients = coefficientCombinations; coefficients > 0; coefficients--)

{

    if(onlyOneBitSet(coefficients))

    {

        continue;

    }

    int sum = 0;

    for (int index = 0; index < numbers.Length; index++)

    {

        int bitIndex = (numbers.Length - 1) - index;

        int numberIndex = index;

        int coefficient = getBit(coefficients, bitIndex);

        sum += coefficient * numbers[numberIndex];

    }

    if (sum == 0)

    {

        //Print the Sum

    }

}

static int getBit(int coefficients, int bitIndex)

{

    return (coefficients >> bitIndex) & 1;

}

static bool onlyOneBitSet(int coefficients)

{

    int setBitCount = 0;

    int highestBit = 31;

    for(int i = 0; i <= highestBit; i++)

    {

        if(((coefficients >> i) & 1) == 1)

        {

            setBitCount++;

        }

    }

   if(setBitCount == 1)

    {

        return true;

    }

    else

    {

        return false;

    }

}

Здравейте.

Ако няма повторения на елементите (например при числа 5 -5 4 -4 10, да се проверяват 5 -5, -5 5, т.н.), то при равни числа в инпута би трябвало да е ОК, както спомена и flashest.

Аз съм ползвал генерирани "отвън" комбинации, но може би и те ползват побитовия алгоритъм, който най-вероятно е най-бързият.

Задачи с комбинации съм имал и в практиката, когато ни ги преподаваха в гимназия, не осъзнавах, че някога ще ми потрябват :)

Моето решение:

http://pastebin.com/JDmbwu9x