[share_ebook] How to think about algorithms.Jeff Edmonds.Cambridge.2008

Description

How to think about algorithms Authors Jeff Edmonds Publisher: 2008 Cambridge University Press Pages: 462 ISBN 13: ISBN-13 978-0-511-41370-4 eBook (EBL) ISBN-13 978-0-521-84931-9 hardback ISBN-13 978-0-521-61410-8 paperback Introduction From determining the cheapest way to make a hot dog to monitoring the workings of a factory, there are many complex computational problems to be solved. Before executable code can be produced, computer scientists need to be able to design the algorithms that lie behind the code, be able to understand and describe such algorithms abstractly, and be confident that they work correctly and efficiently. These are the goals of computer scientists. A Computational Problem: A specification of a computational problem uses preconditions and postconditions to describe for each legal input instance that the computation might receive, what the required output or actions are. This may be a function mapping each input instance to the required output. It may be an optimization problem which requires a solution to be outputted that is “optimal” from among a huge set of possible solutions for the given input instance. It may also be an ongoing system or data structure that responds appropriately to a constant stream of input. Example: The sorting problem is defined as follows: Preconditions: The input is a list of n values, including possible repetitions. Postconditions: The output is a list consisting of the same n values in nondecreasing order. An Algorithm: An algorithm is a step-by-step procedure which, starting with an input instance, produces a suitable output. It is described at the level of detail and abstraction best suited to the human audience that must understand it. In contrast, code is an implementation of an algorithm that can be executed by a computer. Pseudocode lies between these two. An Abstract Data Type: Computers use zeros and ones, ANDs and ORs, IFs and GOTOs. This does not mean that we have to. The description of an algorithm may talk of abstract objects such as integers, reals, strings, sets, stacks, graphs, and trees; abstract operations such as “sort the list,” “pop the stack,” or “trace a path”; and abstract relationships such as greater than, prefix, subset, connected, and child. To be useful, the nature of these objects and the effect of these operations need to be understood. However, in order to hide details that are tedious or irrelevant, the precise implementations of these data structure and algorithms do not need to be specified. Formore on this see Chapter 3. Correctness: An algorithm for the problem is correct if for every legal input instance, the required output is produced. Though a certain amount of logical thinking is requireds, the goal of this text is to teach how to think about, develop, and describe algorithms in such way that their correctness is transparent. See Chapter 28 for the formal steps required to prove correctness, and Chapter 22 for a discussion of forall and exist statements that are essential formaking formal statements. Running Time: It is not enough for a computation to eventually get the correct answer. It must also do so using a reasonable amount of time and memory space. The running time of an algorithm is a function from the size n of the input instance given to a bound on the number of operations the computation must do. (See Chapter 23.) The algorithm is said to be feasible if this function is a polynomial like Time(n) =
(n2), and is said to be infeasible if this function is an exponential like Time(n) =
(2n). (See Chapters 24 and 25 formore on the asymptotics of functions.) To be able to compute the running time, one needs to be able to add up the times taken in each iteration of a loop and to solve the recurrence relation defining the time of a recursive program. (See Chapter 26 for an understanding of
n i=1 i =
(n2), and Chapter 27 for an understanding of T(n) = 2T(n2 ) +n =
(n logn).) Meta-algorithms: Most algorithms are best described as being either iterative or recursive. An iterative algorithm (Part One) takes one step at a time, ensuring that each step makes progress whilemaintaining the loop invariant. A recursive algorithm (Part Two) breaks its instance into smaller instances, which it gets a friend to solve, and then combines their solutions into one of its own. Optimization problems (Part Three) form an important class of computational problems. The key algorithms for them are the following. Greedy algorithms (Chapter 16) keep grabbing the next object that looks best. Recursive backtracking algorithms (Chapter 17) try things and, if they don’t work, backtrack and try something else. Dynamic programming (Chapter 18) solves a sequence of larger and larger instances, reusing the previously saved solutions for the smaller instances, until a solution is obtained for the given instance. Reductions (Chapter 20) use an algorithm for one problem to solve another. Randomized algorithms (Chapter 21) flip coins to help them decide what actions to take. Finally, lower bounds (Chapter 7) prove that there are no faster algorithms. 本资源售价15分，共7个可选网络硬盘链接，6.04 MB，保质期2009-07-15。 [/free] [hide] ---------------------------------------------------------------------------- [url=http://www.divshare.com/download/7203177-230]How to think about algorithms.Jeff Edmonds.Cambridge.2008.pdf[/url] [url=http://www.easy-share.com/1904746523/How to think about algorithms.Jeff Edmonds.Cambridge.2008.pdf]How to think about algorithms.Jeff Edmonds.Cambridge.2008.pdf[/url] [url=http://www.filefactory.com/file/agd0e37/n/How_to_think_about_algorithms_Jeff_Edmonds_Cambridge_2008_pdf]How to think about algorithms.Jeff Edmonds.Cambridge.2008.pdf[/url] [url=http://depositfiles.com/files/ezcffxlm2]How to think about algorithms.Jeff Edmonds.Cambridge.2008.pdf[/url] [url=http://www.sendspace.com/file/qyp5b0]How to think about algorithms.Jeff Edmonds.Cambridge.2008.pdf[/url] [url=http://www.namipan.com/d/How%20to%20think%20about%20algorithms.Jeff%20Edmonds.Cambridge.2008.pdf/]How to think about algorithms.Jeff Edmonds.Cambridge.2008.pdf[/url] [url=http://uploading.com/files/XYLMED2U/How to think about algorithms.Jeff Edmonds.Cambridge.2008.pdf.html]How to think about algorithms.Jeff Edmonds.Cambridge.2008.pdf[/url] ---------------------------------------------------------------------------- [/hide][free] 未经发贴人conanwj许可，任何人禁止任何形式的转贴本文，违者必究！ How to think about algorithms. Authors Jeff Edmonds Publisher: 2008 Cambridge University Press Pages: 462 ISBN 13: ISBN-13 978-0-511-41370-4 eBook (EBL) ISBN-13 978-0-521-84931-9 hardback ISBN-13 978-0-521-61410-8 paperback Introduction From determining the cheapest way to make a hot dog to monitoring the workings of a factory, there are many complex computational problems to be solved. Before executable code can be produced, computer scientists need to be able to design the algorithms that lie behind the code, be able to understand and describe such algorithms abstractly, and be confident that they work correctly and efficiently. These are the goals of computer scientists. A Computational Problem: A specification of a computational problem uses preconditions and postconditions to describe for each legal input instance that the computation might receive, what the required output or actions are. This may be a function mapping each input instance to the required output. It may be an optimization problem which requires a solution to be outputted that is “optimal” from among a huge set of possible solutions for the given input instance. It may also be an ongoing system or data structure that responds appropriately to a constant stream of input. Example: The sorting problem is defined as follows: Preconditions: The input is a list of n values, including possible repetitions. Postconditions: The output is a list consisting of the same n values in nondecreasing order. An Algorithm: An algorithm is a step-by-step procedure which, starting with an input instance, produces a suitable output. It is described at the level of detail and abstraction best suited to the human audience that must understand it. In contrast, code is an implementation of an algorithm that can be executed by a computer. Pseudocode lies between these two. An Abstract Data Type: Computers use zeros and ones, ANDs and ORs, IFs and GOTOs. This does not mean that we have to. The description of an algorithm may talk of abstract objects such as integers, reals, strings, sets, stacks, graphs, and trees; abstract operations such as “sort the list,” “pop the stack,” or “trace a path”; and abstract relationships such as greater than, prefix, subset, connected, and child. To be useful, the nature of these objects and the effect of these operations need to be understood. However, in order to hide details that are tedious or irrelevant, the precise implementations of these data structure and algorithms do not need to be specified. Formore on this see Chapter 3. Correctness: An algorithm for the problem is correct if for every legal input instance, the required output is produced. Though a certain amount of logical thinking is requireds, the goal of this text is to teach how to think about, develop, and describe algorithms in such way that their correctness is transparent. See Chapter 28 for the formal steps required to prove correctness, and Chapter 22 for a discussion of forall and exist statements that are essential formaking formal statements. Running Time: It is not enough for a computation to eventually get the correct answer. It must also do so using a reasonable amount of time and memory space. The running time of an algorithm is a function from the size n of the input instance given to a bound on the number of operations the computation must do. (See Chapter 23.) The algorithm is said to be feasible if this function is a polynomial like Time(n) =
(n2), and is said to be infeasible if this function is an exponential like Time(n) =
(2n). (See Chapters 24 and 25 formore on the asymptotics of functions.) To be able to compute the running time, one needs to be able to add up the times taken in each iteration of a loop and to solve the recurrence relation defining the time of a recursive program. (See Chapter 26 for an understanding of
n i=1 i =
(n2), and Chapter 27 for an understanding of T(n) = 2T(n2 ) +n =
(n logn).) Meta-algorithms: Most algorithms are best described as being either iterative or recursive. An iterative algorithm (Part One) takes one step at a time, ensuring that each step makes progress whilemaintaining the loop invariant. A recursive algorithm (Part Two) breaks its instance into smaller instances, which it gets a friend to solve, and then combines their solutions into one of its own. Optimization problems (Part Three) form an important class of computational problems. The key algorithms for them are the following. Greedy algorithms (Chapter 16) keep grabbing the next object that looks best. Recursive backtracking algorithms (Chapter 17) try things and, if they don’t work, backtrack and try something else. Dynamic programming (Chapter 18) solves a sequence of larger and larger instances, reusing the previously saved solutions for the smaller instances, until a solution is obtained for the given instance. Reductions (Chapter 20) use an algorithm for one problem to solve another. Randomized algorithms (Chapter 21) flip coins to help them decide what actions to take. Finally, lower bounds (Chapter 7) prove that there are no faster algorithms. http://www.divshare.com/download/7203177-230 http://www.easy-share.com/1904746523/How to think about algorithms.Jeff Edmonds.Cambridge.2008.pdf http://www.filefactory.com/file/agd0e37/n/How_to_think_about_algorithms_Jeff_Edmonds_Cambridge_2008_pdf http://depositfiles.com/files/ezcffxlm2 http://www.sendspace.com/file/qyp5b0 http://uploading.com/files/XYLMED2U/How to think about algorithms.Jeff Edmonds.Cambridge.2008.pdf.html

Disclaimer:
Contents of this page are indexed from the Internet. All actions are under your responsability. Email us to report illegal contents or external links and we'll remove them immediately.

Download links for "[share_ebook] How to think about algorithms.Jeff Edmonds.Cambridge.2008":






How to Download
You may need eMule or Bittorrent to download ebook torrents or emule links.

Report Dead Link
Please leave a comment to report dead links, so that someone else may update new links.

1. Ebooks list page : 3051
2. Jeff Edmonds - How To Think About Algorithms
3. [share_ebook] Distributed Computing Principles, Algorithms, and Systems.Ajay D. Kshemkalyani.Cambridge.2008
4. [share_ebook] Cambridge University Press Distributed Computing Principles Algorithms and Systems (2008)
5. [share_ebook] Algorithms on Strings.Maxime Crochemore.Cambridge.2007
6. [share_ebook] Pro SQL Server 2008 Analytics: Delivering Sales and Marketing Dashboards
7. [share_ebook] Cambridge Vocabulary for IELTS with answers and Audio CD (Cambridge Exams Publishing) [ILLUSTRATED] (Paperback)
8. Integration-Ready Architecture and Design: Software Engineering with XML, Java,
9. [share_ebook] Cambridge IELTS Test 7
10. [share_ebook] Cambridge English for Engineering Student's Book with Audio CDs (2) (Cambridge English For Series) (STUDENT EDITION)(Paperback)
11. [share_ebook] Graphs Dioids and Semirings New Models and Algorithms May 2008 eBook-DDU
12. [share_ebook] Algorithms And Protocols For Wireless Sensor Networks Oct 2008 eBook-ELOHiM
13. Concurrency: State Models and Java Programs
14. [share_ebook] Parallel Algorithms and Cluster Computing _ Implementations,Algorithms and Applications
15. [share_ebook] Accelerated Silverlight 2 Oct 2008 eBook-ELOHiM Accelerated Silverlight 2 will get you up to speed with the latest version of Silverlight quickly and efficiently. Author Jeff Scanlon assumes you’re already comfortable with the basics of .N
16. [request_ebook] Using Drupal