A pharmaceutical company has n large tanks T1T2Lambda Tn of

A pharmaceutical company has n large tanks, T_{1},T_{2},\\Lambda, T_{n} of chemical liquids. It has been found that one of the tanks is contaminated, but it is not known which one. The contamination can be determined by sending samples of liquids to an external laboratory which uses some expensive equipment and sophisticated testing procedure and charges $2000 per sample test. The lab can detect the contamination even if minute amount is present in a sample. It takes one week (regardless of the number of samples) for the samples to be sent and to receive the lab results. Design an algorithm to find the contaminated tank in one week and with a cost of at most [lg n] dollars. This means that no more than [lg n] samples must be sent to the lab. Note that it is possible to mix samples from 2 or more tanks, and send the mix as one sample. Your algorithm must come up with a detail procedure to select no more than [lg n] samples, and after receiving the results from the lab, determine what tank is contaminated. No code needed, just an explanation

Solution

Deterministic solutions to the task allocation drawback square measure typically primarily based upon
several common concepts. To certify once all tasks are dead, the processes put together maintain a
so-called progress tree [3,13] or another quite organization for pursuit work. every method maintains
its own permutation of the m tasks and executes these tasks within the permutation order. One will read this
approach as generalizing the straightforward case wherever p = 2: one method executes the tasks so as one, 2, 3, . . .,
while the opposite executes the task so as m, m 1, m 2, . . ., and at some purpose within the middle, the two
processes meet. once there square measure p > two processes, the trick is to settle on permutations to hide all the tasks,
regardless of however the operations interleave, whereas at the same time avoiding an excessive amount of redundant work. More
recently, researchers have used expanders to offer algorithms with higher work complexness.
The most economical settled task allocation algorithmic program for general m and p, given by Kowalski and
Shvartsman [22], uses O(m + p
2+
) total work. It uses a group of permutations with low contention; to
date, it\'s not proverbial a way to construct such permutations in polynomial time, so their algorithmic program isn\'t
explicit. the foremost economical specific algorithmic program was given by Malewicz [24], exploitation O(m + p
4
log m) work.
These last 2 algorithms achieved optimum O(m) work for p = O(m1/(2+)
) and p = O((m/ log m)
1/4
),
respectively. against this, our algorithmic program is work-optimal for a wider vary of p = O(m/polylog m).
For the special case once p = m, Chlebus and Kowalski [15] gave a non-explicit settled algorithmic program
with complexness O(m log18 m/(log log m)
3
) and an exact variant with complexness M2
O(log3
log m)
. This
algorithm and its specific variant square measure primarily based upon expander constructions. once applied to m > p their
approach yields O((m+p) polylogm) work. Earlier settled algorithms for the task allocation drawback
appear in, e.g. [3, 17, 18]. In distinction to those higher bounds, there\'s a (m + p log p) boundary [13],
which holds for settled algorithms and for randomised algorithms with a powerful someone.
Randomized solutions to the task allocation drawback square measure primarily based upon the concept of getting processors choose
tasks at random from the whole set of tasks or from the set of tasks that stay to be dead. Most
previous randomised algorithms for the task allocation drawback assumed that the someone is oblivious; associate degree
oblivious (weak) someone is aware of the system state once the algorithmic program begins, however in distinction to the adaptive
adversary, cannot see the outcomes of coin tosses.
Anderson associate degreed Woll [3] gave a randomised algorithmic program that works against an adaptive someone. The algo-
3
rithm assumes p processes, m = p
2
tasks, and runs in O(m log m) work. The algorithmic program is predicated on random
permutations on a special quite progress tree; derandomized variants are studied in [14]. Their strategy,
as written, doesn\'t be general m and p. Since the algorithmic program has complexness (m log m) and
m = p
2
, it runs inside a log issue of optimum. The randomised algorithmic program of Martel et al. [25], which runs
against associate degree oblivious someone, performs work O(m) with high likelihood, exploitation p = m/ log m processes.
Thus, it achieves optimum work for this selection of p and a weak someone. different randomised algorithms for
the oblivious someone embrace [8, 19]. For an in depth summary of analysis on this drawback, we tend to refer the
reader to the book by Giorgiou and Shvartsman [16].
Outline. Section two formalizes the model and definitions employed in the paper. Section three presents our stir
Tree algorithmic program for asynchronous task allocation. Sections four and five analyze the randomised and derandomized
versions of the stir Tree algorithmic program.
2 Definitions and Notations
Model. we tend to assume the classic asynchronous shared-memory model [5, 23] with p processes one, 2, . . . , p,
where up to t < p processes might fail by bloody. every method features a distinct initial symbol i. Processes
communicate through atomic scan and write operations on registers. The programming of the processes’ steps
and crashes is controlled by a powerful adaptive someone. in any respect times the someone is aware of the state of the
entire system, together with the results of random coin flips, and may change the schedule and also the failure pattern
accordingly. Algorithms that square measure correct during this setting square measure known as wait-free.
Problem statement. Asynchronous task allocation suggests that facultative p processes to execute m distinct tasks,
labeled . the standard work complexness metric measures the whole variety of shared-register
operations that processes perform throughout associate degree execution. we tend to conjointly analyze the tasks dead metric, counting
the total variety of times that tasks square measure dead. Note that each one m tasks should be dead a minimum of once, but
some tasks might get dead redundantly. The redundant-task magnitude relation is tasks dead divided by m.