(アルゴリズムの設計方法)

http://www.sw.it.aoyama.ac.jp/2015/DA/lecture13.html

© 2009-15 Martin J. Dürst 青山学院大学

- Remaining schedule
- Leftovers/summary of last lecture
- Algorithm design strategies
- The algorithm universe

- December 17: 14th lecture (NP-completenes, reducibility)
- January 7: 15th lecture (approximation algorithms)
- January 14: Monday lectures!
- January 21: Make-up Classes
- January 26 - February 2: Term Final Exam Period

- 試験範囲/exam coverage:
- 授業・プリント・プログラムの全ての内容

Contents of all lectures/handouts/programs - プログラムそのものは書く必要がないが、プログラムを理解する、そして自分の議事コードを書ける必要はある

No need to be able to write Ruby code, but need to be able to understand it, and to write your own pseudocode - 問題の種類/types of problem:
- 情報数学 I や計算機実習 I と類似

Similar to problems in Discrete Mathematics I or Computer Practice I

- 2008年度、2009年度、2010年度、2011年度、2012年度、2013年度、2014年度
- 図と解答例の一部は不足

解答例の表示のために、

Opera 12.17 (Windows/Mac/Linux)、

Google Chrome + Style Chooser 又は

Firefox + Context Style Switcher を使用

「表示」→「スタイル」→「solutions」で表示

Use one of the above browsers (with add-ons) and switch to 'solution' style to check solutions

- 問題をよく読む (計算、証明、説明などの区別)

Read problems carefully (calculation vs. proof vs. explanation,...) - 概念の定義を自分の言葉でおさえる

Be able to define and explain terms in your own words - 綺麗な字で書く

Write legibly - Answers can be in Japanese or in English

- Simple/simplistic algorithms
- Brute force algorithms
- Greedy algorithms

Find overall optimal solution by selecting locally optimal solutions - Divide and conquer

Divide problem into nonoverlapping subproblems - Dynamic programming

Find overall optimal solution from solutions for overlapping subproblems

- A knapsack with capacity
`c`(weight or volume) and `n`items`s`_{1},...,`s`(each with a weight/volume, and in some variations a value)_{n}- Goal: Find the best way to pack the knapsack

Depending on the details of the problem, the best algorithm design strategy is different

- All items are the same; how many items fit in?

- Pack as many items as possible

- Use as much capacity as possible (integer version)

- Maximise value

Example: Capacity `c` = 20kg, weight per item: 3.5㎏

'Algorithm': Divide the capacity by the weight per item, round down

Answer for example: 5 items

Design strategy: simple "algorithm"

- Sometimes too simple to be called 'algorithm'
- Examples:
- Select the third-smallest element from a sorted array
- Obtain the surface of a rectangle from the length of its sides
- Closed formula of a number sequence

- Often forgotten because computers are now so fast

Example: Capacity `c` = 20kg, weight of items: 8kg, 2kg, 4kg, 7kg,
2kg, 1kg, 5kg, 12kg

Algorithm: Sort items by increasing weight (1kg, 2kg, 2kg, 4kg, 5kg, 7kg, 8kg, 12kg), pack starting from lightest item

Answer for example: 5 items (e.g. 1kg, 2kg, 2kg, 4kg, 5kg)

Design strategy: Greedy algorithm

- Develop solution step-by-step
- Consider only locally optimal solutions
- Optimal substructure is a precondition, but the structure is different than for dynamic programming
- Time complexities of
`O`(`n`) and`O`(`n`log`n`) are frequent - Examples: Calculating change

Example: Capacity `c` = 20kg, weight of items: 8kg, 2kg, 4kg, 7kg,
2kg, 1kg, 5kg, 12kg

Algorithm: Consider subproblems with capacity `c'` ≦ `c`
and items `s`_{1},..., `s`` _{k}`
(

Answer for example: 8kg, 2kg, 4kg, 1kg, 5kg (total: 20kg; other solutions possible)

Design strategy: Dynamic programming

Example: 8kg, 500¥; 2kg, 2000¥; 4kg, 235¥; 7kg, 700¥; 2kg, 400¥; 1kg, 1¥; 5kg, 450¥; 12kg, 650¥

Algorithm: Try all possible solutions

Design strategy: Brute force

Implementation: Dknapsack.rb (of various algorithms, only brute force finds optimal solution)

- All items are the same; how many items fit in?

Solution: Divide capacity by item weight

Design strategy: Simplistic 'algorithm' - Pack as many items as possible

Solution: Start with lightest items

Design strategy: Greedy algorithm - Use as much capacity as possible (integer version)

Solution: Consider subproblems with capacity`c'`≦`c`and items`s`_{1},...,`s`(_{k}`k`≦`n`)

Design Strategy: Dynamic programming - Maximise value

Design Strategy: Brute force

- Useful when developing algorithms
- Consider design strategies one-by-one
- For some problems, some strategies can be excluded quickly
- Depending on the details of the problem, the best strategy may be different
- For the same problem and the same strategy, there may be several algorithms

- Be able to distinguish between "simple" and "difficult" problems
- Expand your view, let's look at the algorithm universe

`n`binary variables- A logical formula using these variables
- The formula is the conjunction of the disjunction (of negation)
- All disjunctions use exactly 3 terms
- Problem: Find values for each variable so that the overall formula becomes true
- Problem variant: Decide whether a solution is possible or not
- Example (' indicates negation):

(`x`_{1}∨`x`_{2}∨`x`_{4}) ∧ (`x`_{1}'∨`x`_{3}∨`x`_{4}') ∧ (`x`_{2}∨`x`_{3}'∨`x`_{4}) ∧ (`x`_{1}'∨`x`_{3}'∨`x`_{4}') - Number of possible answers: 2
^{n} - Time to check all possible answers:
`O`(`n`2^{n}) - Currently, no faster algorithm is known
- Currently, there is no proof that there is no faster algorithm

- Graph with
`n`vertices - If two vertices are connected by an edge, there is a conflict
- Problem: Find the largest independent set (i.e. subset of vertices without conflicts)
- Problem variant: Decide whether there is an independent set of size
≧
`k` - Number of possible answers: 2
^{n} - Time to check all possible answers:
`O`(`n`2^{n}) - Currently, no faster algorithm is known
- Currently, there is no proof that there is no faster algorithm

`n`cities- Distances (or time or cost) between each pair of cities
- Problem: Find the shortest (fastest/cheapest) tour that visits all cities exactly once
- Problem variant: Decide whether there is a tour of size (duration/cost)
≦
`k` - Number of possible answers:
`n`! - Time to check all possible answers:
`O`(`n`!) - Currently, no faster algorithm is known
- Currently, there is no proof that there is no faster algorithm

(no need to submit)

- Review this lecture
- Find commonalities of 3-SAT, independent set, and traveling salesman problems
- Plan preparation for term final exam

- NP-completeness
- NP-完全性
- reducibility
- 帰着可能性
- approximation algorithms
- 近似アルゴリズム
- brute force
- 総当たり方、腕力法、虱潰し
- greedy algorithm
- 貪欲アルゴリズム
- knapsack problem
- ナップサック問題
- capacity
- 容量
- closed formula
- 「閉じた式」
- number sequence
- 数列
- independent set
- 独立集合
- conflict
- 競合
- traveling salesman
- 巡回セールスマン