Академический Документы
Профессиональный Документы
Культура Документы
By:
BSCS-II
I. Introduction
There are several kinds of algorithm, but in this report we have to be focused on what we called, The Class NP and the Greedy Algorithm. These include what kind of algorithm it is and its characteristic why it is called a greedy? The advantages and disadvantages of this algorithm and there are some examples provided. Huffmans Code it was a technique for compressing a data that helps us how to make a shorter the process of solving the problem were the characters can convert into variable bit string and the most frequently occurrence was converted into a shortest bit string. The importance of Class NP algorithm, its uses and characteristics is also discussed.
IV.
The name greedy comes from the fact that the algorithm make decisions based on a single criterion or criteria, instead of a global analysis that would take into account the decisions effect on further steps.
J1
J2
J3
J4
15
23
26
36
J3 0 3
J2 11
J4 21
J1 36
Schedule#2: Arranged by shortest job first Average Completion Time: 17.75 Conclusion: Operating System scheduler generally gives precedence to shorter jobs. B. The Multiprocessor Case We can extend this problem to the case of several processors. The jobs are ordered, and the shortest running time first. Example: Given three processors Job J1 J2 J3 J4 J5 J6 Running Time 3 5 6 10 11 14
J7 J8 J9
15 18 20
J1 J2 J3 0 3 5
J4 J5 J6 6
J7 J8 J9 40
13 16 20 28 34
Completion time J1 J5 J9
J2 J3
J4 J6
J7 J8
6 14 15
20
30
34
38
J2
J5
J8
J6 J1 J3 J4
J9 J7
3 5
9 14 16
19
34
VI. Definition of Huffmans Code Is a technique for compressing data. Huffman's greedy algorithm looks at the occurrence of each character and it as a binary string in an optimal way. In this matter there are so many procedures to be used in finding an easiest way to solve the problem, A statistical compression method that converts characters into variable length bit strings. Most-frequently occurring characters are converted to shortest bit strings least frequent, the longest. Compression takes two passes. The first pass analyzes a block of data and creates a tree model based on its contents. Huffman codes are helping us to VIII. Examples of Huffmans Code
1. Suppose we have a data consists of 100,000 characters that we want to compress. The characters in the data occur with following frequencies.
We can consider the problem of designing a "binary character code" in which each character is represented by a unique binary string.
Fixed Length Code In fixed length code, needs 3 bits to represent six (6) characters. a Frequency Fixed Length 000 code 001 010 011 100 101 45,000 b 13,000 c 12,000 d 16,000 e 9,000 f 5,000
This method requires 3, 000 000 bits to code the entire file. How do we get 3000,000? 1. First we need to add the total number of characters which are 45,000 + 13,000 + 12,000 + 16,000 + 9,000 + 5,000 = 1,000 000. 2. Then add each character which is assigned in 3 bit codeword => 3 * 1,000 000 = 3,000 000 bits. In this moment the Fixed-length code are requires 3, 000 000 bits while the variable code requires 224,000 bits it was equal in saving of approximately 25%. Prefix Codes In which no codeword is a prefix of other codeword. The reason prefix codes are desirable is that they simply encoding (compression) and decoding it is also a minimum expected codeword length equivalently, in a tree with minimum weighted path length. It is also another technique in coding, so that we can makes shorter the way in finding solution in compressing data.
Variable-length code can do better by giving frequent characters short codewords and infrequent characters long codewords. a 45,000 0 code b 13,000 101 c 12,000 100 d 16,000 111 e 9,000 1101 f 5,000 1100
Character 'a' are 45,000 each character 'a' assigned 1 bit codeword. 1 * 45,000 = 45,000 bits. Characters (b, c, d) are 13,000 + 12,000 + 16,000 = 41,000 each character assigned 3 bit codeword 3 * 41,000 = 123,000 bits Characters (e, f) are 9,000 + 5,000 = 14,000 each character assigned 4 bit codeword. 4 * 14,000 = 56,000 bits. Implies that the total bits are: 45,000 + 123,000 + 56,000 = 224,000 bits IX. Encoding Concatenate the codewords representing each characters of the file.
A. Examples of Encoding From variable-length codes table, we code the3-character file abc as: a 0 b 101 c 100 => 0.101.100 = 0101100
Huffmans Code B. Using standard coding scheme C. Character a Code 000 Frequency 10 Total Bits 30
15 12 3 4 13 1
45 36 9 12 39 3 174
This representation of this character can be found in starting at the root and recording the path, by using a 0 to indicate the left branch and a1 to indicate the right branch. B. Binary Tree
s p
nl
Representation of the original code in a tree Theorem A Binary tree that is not full cannot correspond to an optimal prefix code. Proof
e 9,000 100
f 5,000 101
0 Code
101
100
111
1101
1100
Fixed-length code is not optimal since binary tree is not full. From now on consider only full binary tree If C is the alphabet from which characters are drawn, then the tree for an optimal prefix code has exactly |c| leaves (one for each letter) and exactly |c|-1 internal orders. Given a tree T corresponding to the prefix code, computes the number of bits required to encode a file. For each character c in C, let f(c) be the frequency of c and let dT(c) denote the depth of c's leaf. Note that dT(c) is also the length of codeword. The number of bits to encode a file is B (T) = S f(c) dT(c) Which define as the cost of the tree T. For example, the cost of the above tree is B (T) = S f(c) dT(c) = 45*1 +13*3 + 12*3 + 16*3 + 9*4 +5*4 = 224 Therefore, the cost of the tree corresponding to the optimal prefix code is 224 (224*1000 = 224000).
X. Definition of Class NP The CLASS NP stands for Non-deterministic Polynomial-time; it does not stand for non-polynomial. Where non-deterministic is just a fancy way of talking about guessing a solution. A. Polynomial-Time Algorithm Algorithms with worst case running time of O(nk), where k is a constant, are called tractable others are called intractable or super-polynomial.
Algorithm is polynomial-time algorithm if there exists a polynomial p(n) such that the algorithm can solve any instance of size n in a time O(p(n)).
Algorithm with a problem requiring (n35) time to solve are essentially intractable for large n. 1. NP Completeness NP-completeness is a form of bad news, because there are many important problems that cant be solved quickly. Why should we care? Every time you encounter NP completeness problems, you are thinking that it is the end of the world! And you may experience nose bleeding in finding better solution to the problem. Sometimes you lost your scalp in too much scratching trying to solve them and do something better: 1.1 Finding the better solution:
Use heuristic. If you cant solve the problem with the good worst case time, you will push your self and shaking your head to find another solution for solving the problem.
Solve the problem approximately instead of exactly. Theres no perfect answer for every problems, but theres an exact answer. And it will take a long time to solve for the perfect and exact answer. Instead of searching for an optimal solution, search for an "almost" optimal one and you can prove it is close to right.
Use an exponential time solution anyway. If you really have to solve the problem exactly, you can settle down to writing an exponential time algorithm and stop worrying about finding a better solution.
Choose a better abstraction. Sometimes you need to ignore some unimportant details for your fast and better algorithm. Because they are just an accessories to the given problems.
B. Classification of Problems
P. Problems that can be solved in polynomial time. ("P" stands for polynomial.) These problems have formed the main material of this course.
NP. This stands for "nondeterministic polynomial time" where nondeterministic is just a fancy way of talking about guessing a solution. A problem is in NP if you can quickly (in polynomial time) test whether a solution is correct (without worrying about how hard it might be to find the
solution). Problems in NP are still relatively easy: if only we could guess the right solution, we could then quickly test it.
PSPACE. Problems that can be solved using a reasonable amount of memory. Too much of memory are not necessary, especially when the problem can be solve using easy method.
EXPTIME. Problems that can be solved in exponential time. Undecidable. You can use any form of algorithm in solving a problem, as long as it produce a right output in every input instances.