Finding the shortest path in a tree - algorithm

Question

I'm having troubles to find a solution to the following question.
Suppose a company needs to have a machine over the next five year period. Each new machine costs $100,000. The annual cost of operating a machine during its ith year of operation is given as follows: C1 = $6000, C2 = $8000 and C3 = $12,000. A machine may be kept up to three years before being traded in. This means that a machine can be either kept or traded with in the first two years and has to be traded when its age is three. The trade in value after i years is t1= $80,000, t2 = $60,000 and t3 = $50,000. How can the company minimize costs over the five year period (year 0 to year 5) if the company is going to buy a new machine in the year 0?
Devise an optimal solution based on dynamic programming.
This problem can be represent using a tree. Here's the diagram.
Now I think that finding the shortest path in the above tree will give me the optimal solution. But I have no idea how to do that. Here are my questions,
Is there a classic problem regarding this question? (Like Travelling salesman problem or Change-making problem)
If yes, then What is it? What are the methods to solve it?
If not, then how to solve this problem.
Any other suggestions are also welcome.
Guys, I want some guidance and help for this question. (Do NOT think this as a request to get my homework done from you.) I have found a full Java implementation for this question here. But it does not use dynamic programming to solve the problem. Thank you in advance.

Answer 1

The company wants to minimize the cost over 5 year period. In the year 0 they are going to buy a machine & each year they have to decide whether the machine is being kept or traded. In order to arrive at an optimal solution, we have to make a set of choices at each end of the year. As we make each choice, sub problems of the same from often arise.
Thus we arrives at a position where given sub problem may arise from more than one partial set of choices. When devising an optimal solution based on dynamic programming, we can solve the problem by combining the solutions to sub problems.
Let the stages correspond to each year. The state is the age of the machine for that year. The decisions are whether to keep the machine or trade it in for a new one. Let Ft(x) be the minimum cost incurred from time t to time 5, given the machine is x years old in time t.
Base cases:
Since we have to trade machine in the end of 5 year F5(x)=-S[x]
In the year 0 we buy a new machine F0(1)=N+M[1]+F1(0)
In the range of 5 years and at most 3 years of age : 0
Keep existing machine at most 3 years : Ft(3)=N+M[0]+Ft+1(0) ; t≠0,1,2
def Fxy(self,time,age):
if self.Matrix[time][age]==None: <- Overlaping subproblems avoided
if(time>5 or age>2):
return 0
if time==5:
self.Matrix[time][age]=T=self.S[age]
self.Flag[time][age]='TRADE'
elif time==0:
self.Matrix[time][age]=K=self.N+self.M[0]+self.Fxy(time+1,time)
self.Flag[time][age]='KEEP'
elif time==3 and age==2:
self.Matrix[time][age]=T=self.S[age]+self.N+self.M[0]+self.Fxy(time+1,0)
self.Flag[time][age]='TRADE'
else:
T=self.S[age]+self.N+self.M[0]+self.Fxy(time+1,0)
if age+1<len(self.Matrix[0]):
K=self.M[age+1]+self.Fxy(time+1,age+1)
else:
K=self.M[age+1]
self.Matrix[time][age]=min(T,K)
if(self.Matrix[time][age]==T and self.Matrix[time][age]==K):
self.Flag[time][age]='TRADE OR KEEP'
elif(self.Matrix[time][age]==T):
self.Flag[time][age]='TRADE'
else:
self.Flag[time][age]='KEEP'
return self.Matrix[time][age]
else:
return self.Matrix[time][age]
Optimal solutions can be achieved via drawing a decisions tree contains all possible paths & takes the minimum cost paths. We use a recursive algorithm where it traverses each tree level & make the path where current decision point occurs.
Ex: When it traverses F1(0), it has ‘TRADE OR KEEP’ decision binds with it. Then we can traverse two possible paths. When it traverses F2(1), since it has ‘KEEP’ decision then recursively we traverse F3(2), the right child. When ‘TRADE’ met, the left child continuously until it reaches the leaves.
def recursePath(self,x,y):
if(x==5):
self.dic[x].append(self.Flag[x][y])
return self.Flag[x][y]
else:
if(self.Flag[x][y]=='TRADE OR KEEP'):
self.recursePath(x+1,y)
self.recursePath(x+1,y+1)
if(self.Flag[x][y]=='KEEP'):
self.recursePath(x+1,y+1)
if(self.Flag[x][y]=='TRADE'):
self.recursePath(x+1,y)
self.dic[x].append(self.Flag[x][y])
return self.Flag[x][y]

Answer 2

If you want something like Dijkstra, why don't you just do Dijkstra? You'd need to change a few things in your graph interpretation but it seems very much doable:
Dijkstra will settle nodes according to a minimum cost criterium. Set that criterium to be "money lost by company". You will also settle nodes in Dijkstra and you need to determine what exactly will be a node. Consider a node to be a time and a property state e.g. year 4 with a working machine of x years old. In year 0, the money lost will be 0 and you will have no machine. You then add all possible edges/choices/state transitions, here being 'buy a machine'. You end up with a new node on the Dijkstra PQ [year 1, working machine of age 1] with a certain cost.
From thereon, you can always sell the machine (yielding a [year 1, no machine] node), buy a new machine [year 1, new machine]) or continue with the same ([year 2, machine of age 2]). You just continue to develop that shortest path tree untill you have everything you want for year 5 (or more).
You then have a set of nodes [year i, machine of age j]. To find the optimum for your company at year i, just look among all possibilities for it (I think it will always be [year i, no machine]) to get your answer.
As Dijkstra is an all-pairs shortest path algorithm, it gives you all best paths to all years
edit: some pseudo code for java
first you should create a node object/class to hold your node information.
Node{
int cost;
int year;
int ageOfMachine;
}
Then you could just add nodes and settle them. Make sure your PQ is sorting the nodes based on the cost field. Starting at the root:
PQ<Node> PQ=new PriorityQueue<Node>();
Node root= new Root(0,0,-1);//0 cost, year 0 and no machine)
PQ.offer(root);
int [] best= new int[years+1];
//set best[0..years] equal to a very large negative number
while(!PQ.isEmpty()){
Node n=PQ.poll();
int y=n.year;
int a=n.ageOfMachine;
int c=n.cost;
if(already have a cost for year y and machine of age a)continue;
else{
add [year y, age a, cost c] to list of settled nodes;
//examine all possible further actions
//add nodes for keeping a machine and trading a machine
PQ.offer(new Node(cost+profit selling current-cost of new machine,year+1,1));
PQ.offer(new Node(cost,year+1,age+1);//only if your machine can last an extra year
//check to see if you've found the best way of business in year i
if(cost+profit selling current>best[i])best[i]=cost+profit selling current;
}
}
Something along those lines will give you the best practice to reach year i with cost best[i]

Answer 3

I think I have found a simpler dynamic program solution.
Suggest Cost(n) is the whole cost when sell at year n . And the cost of keeping a machine for 1, 2 ,3 year is cost1,cost2,cost3 ( which is 26000, 54000, 76000 in this problem ) .
Then we can divide the problem to sub-problems like this:
**Cost(n)= MIN( Cost(n-1)+cost1, Cost(n-2)+cost2, Cost(n-3)+cost3 );**
So we can calculate it in 'bottom-up way', which is just O(n).
I have implemented and tested it using C :
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct costAndSell_S{
int lastSellYear;
int cost;
};
int operatCost[3]={6000,8000,12000};
int sellGain[3]={80000,60000,50000};
int newMachinValue=100000;
int sellCost[3];
struct costAndSell_S costAndSell[20];
void initSellCost(){
memset( costAndSell, 0, sizeof(costAndSell));
sellCost[0]=operatCost[0]+newMachinValue-sellGain[0];
sellCost[1]=operatCost[0]+operatCost[1]+newMachinValue-sellGain[1];
sellCost[2]=operatCost[0]+operatCost[1]+operatCost[2]+newMachinValue-sellGain[2];
costAndSell[0].cost=100000;
return;
}
int sellAt( int year ){
if ( year<0){
return(costAndSell[0].cost );
}
return costAndSell[year].cost;
}
int minCost( int i1, int i2, int i3 ){
if ( (i1<=i2) && (i1<=i3) ){
return(0);
}else if ( (i2<=i1) && (i2<=i3) ){
return(1);
}else if ( (i3<=i1) && (i3<=i2) ){
return(2);
}
}
void findBestPath( int lastYear ){
int i;
int rtn;
int sellYear;
for( i=1; i<=lastYear; i++ ){
rtn=minCost( sellAt(i-1)+sellCost[0], sellAt(i-2)+sellCost[1], sellAt(i-3)+sellCost[2]);
switch (rtn){
case 0:
costAndSell[i].cost=costAndSell[i-1].cost+sellCost[0];
costAndSell[i].lastSellYear=i-1;
break;
case 1:
costAndSell[i].cost=costAndSell[i-2].cost+sellCost[1];
costAndSell[i].lastSellYear=i-2;
break;
case 2:
costAndSell[i].cost=costAndSell[i-3].cost+sellCost[2];
costAndSell[i].lastSellYear=i-3;
break;
}
}
sellYear=costAndSell[lastYear].lastSellYear;
printf("sellAt[%d], cost[%d]\n", lastYear, costAndSell[lastYear].cost );
do{
sellYear=costAndSell[sellYear].lastSellYear;
printf("sellAt[%d], cost[%d]\n", sellYear, costAndSell[sellYear].cost );
} while( sellYear>0 );
}
void main(int argc, char * argv[]){
int lastYear;
initSellCost();
lastYear=atoi(argv[1]);
findBestPath(lastYear);
}
The output is :
sellAt[5], cost[228000]
sellAt[3], cost[176000]
sellAt[0], cost[100000]

Answer 4

I think it can't use dynamic programming because I can't find optimal substructure and overlapping subproblems for it.
The cost of year N depends on the behavior of year N-1, N-2 and N-3 . It is difficult to find a optimal substructure.

Answer 5

The link you provided is dynamic programming - and the code is pretty easy to read. I'd recommend taking a good look at the code to see what it is doing.

Answer 6

The following method might work.
At the end of each year , you have two choices. You can either Choose to Trade or choose to Pay the maintenance cost for another year. Except for the 3rd year, where you dont have a choice. You have to trade for sure.
This can be solved by a recursion method where you choose the minimum cost among trading and not trading during a particular year.
A Table can be maintained for offset, nth year (without trading) so that values need not be recalculated