PRESENTATION ON
●OPTIMAL STORAGE ON TAPES
●OPTIMAL MERGE PATTERNS
PRESENTED TO ■
DR. VINAY PATHAK
RESPENTED BY-
SUNIL KUMAR
III rd C.S.E.
S.R.No. – 108/07
Optimal Storage on Tapes
PROBLEM
INPUT
●
We are given n programs that are to be stored on a computer Tape of length l and associated with each program length l i
●
such that 1 ≤ i≤ n and
● ∑1 ≤ i≤ n li ≤ l
OUTPUT
●
A permutation from all n! for the n programs so that when they are stored on
tape in the order the MRT is minimized.
ALL SIX PERMUTATIONS FOR n=3
1 2 3
1 3 2
2 3 1
2 1 3
3 1 2
3 2 1
MRT(Mean Retrival Time)
Let there are n programs namely i1,i2,i3,i4.......................in on tape
then time tj required to retrive program ij
tj ∝ ∑ lik
1≤ k ≤j
If all program are retrived equally and every time head point to the front , then expected
MRT is given by-
MRT =(1/n)∑1≤j≤n tj
Minimizing the MRT is equivalent to minimizing
D( I ) li
1 j n 1 k j
k
Example
Let n = 3 and (l1,l2,l3) = (5,10,3)
Ordering I D(I)
1,2,3 5 + 5 + 10 + 5 + 10 + 3 = 38
1,3,2 5 + 5 + 3 + 5 + 3 + 10 = 31
2,1,3 10 + 10 + 5 + 10 + 5 + 3 = 43
2,3,1 10 + 10 + 3 + 10 + 3 + 5 = 41
3,1,2 3 + 3 + 5 + 3 + 5 + 10 = 29
3,2,1 3 + 3 + 10 + 3 + 10 + 5 = 34
The Greedy Solution
Make tape empty
for i := 1 to n do
grab the next shortest file
put it next on tape
The algorithm takes the best short term choice
without checking to see weather it is the best long
term decision.
Example
Let n=5 ,and l1=5, l2=7, l3=10, l4=20, l5=30
TAPE-
SORTED ORDER IS
5,7,10,20,30
Insert 5
5
Insert 7
5 7
Insert 10
5 7 10
Insert 20
5 7 10 20
Insert 30
5 7 10 20 30
ALGO FOR MORE THAN ONE TAPE
1. Algorithm Store(n,m)
2. //n is the no of programs and m the no of tapes
3. {
4. j:=1;//Next tape to store on
5. for i:=1 to n do
6. {
7. write(“append program”,i,”to permutation for
tape”,j);
8. j:=(j+1)mod m;
9. }
10. }
Example
We want to store files of lengths (in MB) {12 34 56 73 24 11
34 56 78 91 34 45} on three tapes.
How should we store
them on the three tapes so that the mean retrieval
time is minimized?
SOLUTION: STORE FILES BY NONDECREASING
LENGTH
First sort the files in increasing order of length. For
this we can use heapsort, meregesort or quicksort
algorithms.
Sorted Ele4ments are
11 12 24 34 34 34 45 56 56 73 78 91
Now distribute the files:
First element 11
Inserting 11
Tape 1 11
Tape 2
Tape 3
Inserting 12
Tape 1 11
Tape 2 12
Tape 3
Inserting 24
Tape 1 11
Tape 2 12
Tape 3 24
Inserting 34
Tape 1 11 34
Tape 2 12
Tape 3 24
Inserting 34
Tape 1 11 34
Tape 2 12 34
Tape 3 24
Inserting 45
Tape 1 11 34 45
Tape 2 12 34
Tape 3 24 34
Inserting 56
Tape 1 11 34 45
Tape 2 12 34 56
Tape 3 24 34
Inserting 56
Tape 1 11 34 45
Tape 2 12 34 56
Tape 3 24 34 56
Inserting 73
Tape 1 11 34 45 73
Tape 2 12 34 56
Tape 3 24 34 56
Inserting 78
Tape 1 11 34 45 73
Tape 2 12 34 56 78
Tape 3 24 34 56
Inserting 91
Tape 1 11 34 45 73
Tape 2 12 34 56 78
Tape 3 24 34 56 91
TIME COMPLEXITY
The time is consumed only in shorting becoz in writting
and finding the tape on which we have to write the
time consumed is constant.So time consumed is
equal to time taken by any sorting algo
T(n)=O(n ln n)+θ(1)
=O(n ln n)
Optimal Merge Patterns
PROBLEM
INPUT
●
We are given n sorted files containing records and we have to merge them in to a single file merging only 2 at a time
OUTPUT
●
We have to merge them in minimum time
As we know time consumed in merging is directly proportional to the no of
records moved from one file to another file
So we will focus on reducing the movement of records required for merging or
no of comparisions
Example.
Suppose there are 3 sorted lists L1, L2, and L3, of sizes 30, 20, and
10, respectively, which need to be merged into a combined
sorted list, but we can merge only two at a time. We intend
to find an optimal merge pattern which minimizes the total
number of comparisons. For example, we can merge L1 and L2,
which uses 30 + 20 = 50 comparisons resulting in a list of size
50. We can then merge this list with list L3, using another 50 +
10 = 60 comparisons, so the total number of comparisons is 50
+ 60 = 110. Alternatively, we can merge lists L2 and L3, using 20
+ 10 = 30 comparisons, the resulting list (size 30) can then be
merged with list L1, for another 30 + 30 = 60 comparisons. So
the total number of comparisons is 30 + 60 = 90. It doesn’t take
long to see that this latter merge pattern is the optimal one.
Binary Merge Trees: We can depict the merge patterns using a binary tree,
built from the leaf nodes (the initial lists) towards the root in which each
merge of two nodes creates a parent node whose size is the sum of the sizes
of the two children. For example, the two previous merge patterns are
depicted in the following two figures:
Cost = 30*2 +
Cost = 30*1 +
60 20*2 + 10*1 =
60 20*2 + 10*2 =
110
90
50 10 30 30
30 20 20 10
Merge L1 and L2, then with Merge L2 and L3, then with L1
L3
merge cost = sum of all weighted external path lengths
ALGORITHM
treenode = record{
treenode* lchild;
treenode*rchild;
integer weight;};
1. Algorithm Tree(n)
2. // list is a global list of n single node
3. //binary trees as described above
4. {
5. for i:= 1 to n-1 do
6. {
7. pt:= new treenode;//Get a new treevnode
8. (pt->lchild):=Least(list);
9. (pt->rchild):=Least(list);
10. (pt->wieght):= ((pt->lchild)->wieght)+((pt->rchild)-> wieght);
11. Insert (list,pt);//Merge 2 trees with smallest length
12. }
13. return Least(list) //tree left in list is merged tree
14. }
Example of the optimal merge tree algorithm:
2 3 5 7 9 Initially, 5 leaf nodes with
sizes
5
2 3 5 7 9
Iteration 1: merge 2 and 3 into 5
10
Iteration 2:
5 5 16 Iteration 3: merge 7 and
merge 5 and
9 (chosen among 7, 9,
5 into 10
2 3 7 9 and 10) into 16
26
Iteration 4: merge
16
10 10 and 16 into 26
5 5 7 9
Cost = 2*3 + 3*3 + 5*2 + 7*2 +
2 3 9*2 = 57.
TIME COMPLEXITY
The main for loop executed n-1 times
If list is kept in nondecreasing order of the weights of
roots then Least (list) take only O(1)time &
Insert(list,pt) will take O(n) time .
Hence the total time taken will be O(n2)
Greedy Solution
The solution is greedy becoz at each step we are merging
smallest files without caring of final result
The cost is directly proportional tothe sum of productof
depth of external leaves to their weights
∑1≤i≤n diqi called as weighted external path length
Proof of optimality of the tree algorithm
We use induction on n 1 to show that the tree algo is optimal in
that it gives the minimum total weighted external path lengths
(among all possible ways to merge the given leaf nodes into a
binary tree).
(Basis) When n = 1. There is no internal nodes so tree is optimal.
(Induction Hypothesis) Suppose the merge tree is optimal when
there are k leaf nodes, for some k 1
(Induction) Consider (k + 1) leaf nodes. Call them a1, a2, …, and
ak+1. We may assume nodes a1, a2 are of the smallest values, which
are merged in the first step of the merge algorithm into node b.
We call the merge tree T, the part excluding a1, a2 T’ (see figure).
Suppose an optimal binary merge tree is S. We make two
observations.
. (1) If node x of S is a deepest internal node, we may swap its
two children with nodes a1, a2 in S without increasing the total
weighted external path lengths. Thus, we may assume tree S
has a subtree S’ with leaf nodes x, a3, …, and ak+1. (2) The
tree S’ must be an optimal tree for k nodes x, a3, …, and ak+1
By induction hypothesis, tree S’ has a total weighted external
path lengths equal to that of tree T’. Therefore, the total
weighted external path lengths of T equals to that of tree S,
proving the optimality of T.
T S
T’ S’
b x
a1 a2 a1 a2
THANK YOU !
