Balance server capacity

Problem description:
There are at most eight servers in a data center. Each server has got a capacity/memory limit. There can be at most 8 tasks that need to be scheduled on those servers. Each task requires certain capacity/memory to run, and each server can handle multiple tasks as long as the capacity limit is not hit. Write a program to see if all of the given tasks can be scheduled or not on the servers?

Ex:
Servers capacity limits: 8, 16, 8, 32
Tasks capacity needs: 18, 4, 8, 4, 6, 6, 8, 8
For this example, the program should say ‘true’.

Ex2:
Server capacity limits: 1, 3
Task capacity needs: 4
For this example, program should return false.

Solution:
First impression would be using greedy algorith. Each time, put the max task in the max capacity server. But it won’t find the best answer for a lot of times. An counter-example is: Server capacity [4, 3], task[3, 2, 2].

So the solution should be use recursion to traverse the whole result possibilities. The sample code is following. It is a easy recursion case, no comment

1. public class ServerCapacityBalancer {
3.     public static void main(String[] args) {
4.         int[] server = {8, 16, 8, 32};
5.         int[] task = {18,8,8,8,6,6,4,4};
6.         int[] result = balanceServer(server, task);
7.         System.out.println(Arrays.toString(result));
9.     }
12.     public static int[] balanceServer(int[] server, int[] task){
13.         if(server==null||task==null){
14.             return null;
15.         }
16.         int[] result = new int[task.length];
17.         for(int i=0;i
18.             result[i] = -1;
19.         }
20.         balanceServerUtil(server, task, 0, result);
21.         return result;
22.     }
24.     //put task[n] in the server, and save the result
25.     public static boolean balanceServerUtil(int[] server, int[] task, int n, int[] result){
26.         if(n>=task.length){
27.             return true;
28.         }
29.         for(int i=0;i
30.             if(server[i]>=task[n]){
31.                 server[i] -= task[n];
32.                 result[n] = i;
33.                 if(balanceServerUtil(server, task, n+1, result)){
34.                     return true;
35.                 }
36.                 server[i] += task[n];
37.                 result[n] = -1;
38.             }
39.         }
40.         return false;
41.     }
42. }