How is this DP solution approached?

Question

I have been trying to solve this TopCoder problem since a while now, and I'm not able to come up with a DP-based solution to this problem (given below). I also found a solution(also given below) by someone else to the problem, but I can't even understand it.

Could anyone help me with the solution here? I don't understand what line of thought would lead to this solution? How do I go about establishing the recurrence relation in my mind? I have absolutely no clue how to approach this problem, or how the person who wrote that solution wrote it.

PS: I'm aware TopCoder has editorials for problems, but this one's hasn't been released. I don't know why.

Here's the problem

Fox Ciel has lots of homework to do. The homework consists of some mutually independent tasks. Different tasks may take different amounts of time to complete. You are given a int[] workCost. For each i, the i-th task takes workCost[i] seconds to complete. She would like to attend a party and meet her friends, thus she wants to finish all tasks as quickly as possible.

The main problem is that all foxes, including Ciel, really hate doing homework. Each fox is only willing to do one of the tasks. Luckily, Doraemon, a robotic cat from the 22nd century, gave Fox Ciel a split hammer: a magic gadget which can split any fox into two foxes.

You are given an int splitCost. Using the split hammer on a fox is instantaneous. Once a hammer is used on a fox, the fox starts to split. After splitCost seconds she will turn into two foxes -- the original fox and another completely new fox. While a fox is splitting, it is not allowed to use the hammer on her again.

The work on a task cannot be interrupted: once a fox starts working on a task, she must finish it. It is not allowed for multiple foxes to cooperate on the same task. A fox cannot work on a task while she is being split using the hammer. It is possible to split the same fox multiple times. It is possible to split a fox both before and after she solves one of the tasks.

Compute and return the smallest amount of time in which the foxes can solve all the tasks.

Here's the solution :

1:    
2:  const int maxN = 55;  
3:  int dp[maxN][maxN*2];  
4:  int N;  
5:  int splitC;  
6:  vector<int> workC;  
7:    
8:  int rec(int,int);  
9:  int FoxAndDoraemon::minTime(vector <int> workCost, int splitCost) {  
10:      
11:    sort(workCost.begin(), workCost.end());  
12:    N = workCost.size();  
13:    splitC = splitCost;  
14:    workC = workCost;  
15:       memset(dp, -1, sizeof(dp));  
16:      
17:    return rec(N-1, 1);  
18:  }  
19:    
20:  int rec(int jobs, int fox)  
21:  {  
22:    if(jobs == -1) return 0;  
23:      
24:    int& val = dp[jobs][fox];  
25:    if(val != -1) return val;  
26:    val = 0;  
27:      
28:    if( (jobs+1) <= fox) val = max(workC[jobs] , rec(jobs-1, fox-1));  
29:    else  
30:    {  
31:      //split fox  
32:      val = splitC + rec(jobs, fox + 1);  
33:        
34:      if( !(fox == 1 && jobs > 0) )  
35:        val = min(val, max(workC[jobs], rec(jobs-1, fox-1)));  
36:    }  
37:    return val;  
38:  }  
39:    

Answer 1

DP problems usually requires you to work out couple of examples and the only way to get good at it is to practice. Try solving some standard problem types in DP like longest increasing subsequence, knapsack, coins change, matrix multiplication, TSP etc. Try varients of these type.

As for the above problem, few things to note:

• You need N foxes to finish N tasks (1 fox will work on only 1 task). So, if you've already cloned N foxes you don't need to create anymore. And, if you have more than 1 task, you have to split the first fox.
• With each fox you can do two things
  • Split it and then calculate the minimum time taken
  • Don't split, but perform the current task and calculate the time it takes to perform remaining tasks with one less fox.
    • Note that you can only opt for not spliting if you have more than 1 Fox (or 1 Fox with 1 task).

This should give you an idea for the problem. I haven't thoroughly analyzed the problem, but the recursion doesn't seem to create overlapping calls ie if I have 3 tasks and 2 foxes, I'm only calling that state once and no more. So, the solution is a regular recursive solution and not a DP.

Answer 2

社论现在在TopCoder网站上发布，您可以在那里查看！