# Algorithm Design Strategies

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

## Data Structures and Algorithms

### 13th lecture, January 11, 2017

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

### Martin J. Dürst

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

# Today's Schedule

• Remaining schedule
• Leftovers/summary of last lecture
• Algorithm design strategies
• Examples of 'difficult' problems
• Student Survey

# Remaining Schedule

• December 21: 13th lecture (algorithm design strategies)
• January 11: 14th lecture (NP-completenes, reducibility)
• January 18: 15th lecture (approximation algorithms)
• January 25, 09:30-10:55: Term Final Exam

# Term Final Exam

Coverage:
Complete contents of lecture and handouts
No need to be able to write Ruby code, but need to be able to understand it, and to write your own pseudocode
Type of problems:
Similar to problems in Discrete Mathematics I or Computer Practice I
Past exams: 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016
How to view example solutions:
Use Opera 12.17 (Windows/Mac/Linux)
For Google Chrome, install Style Chooser
For Firefox, install Context Style Switcher
Select solutions style (e.g. View → Style → solutions)
Some images and example solutions are missing
Important points:
Read problems carefully (distinguish between calculation, proof, explanation,...)
Be able to explain concepts in your own words
Combine and apply knowledge from different lectures
Write clearly
Answers can be in Japanese or English

# Summary of Last Lecture

• Dynamic programming is an algorithm design strategy
• Dynamic programming is suited for problems where the overall (optimal) solution can be obtained from solutions for subproblems, but the subproblems overlap
• The time complexity of dynamic programming depends on the structure of the actual problem
• Dynamic programming is closely related to memoization

# Algorithm Design Strategies/Methods

• 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

# The Knapsack Problem

• A knapsack with capacity c (weight or volume) and
• n items s1,..., sn (each with a weight/volume, and in some variations a value)
• Goal: Find the best way to pack the knapsack

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

# Variations of the Knapsack Problem

1. All items are the same; how many items fit in?
2. Pack as many items as possible
3. Use as much capacity as possible (integer version)
4. Maximise value

# All Items are the Same

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

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

Design strategy: simplistic "algorithm"

# Simplistic 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

# Pack as Many Items as Possible

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

Algorithm: Sort items by increasing weight, pack starting with lightest item

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

Design strategy: Greedy algorithm

# 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

# Use as Much Capacity as Possible (Integer Version)

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

Algorithm: Consider subproblems with capacity c'c using only the first k items s1,..., sk (kn) (complexity: O(cn))

Design strategy: Dynamic programming

max_weight(0, ...) = max_weight(x, {}) = 0

max_weight(c1, {s1,..., sk}) = max(max_weight(c1- sk, {s1,..., sk-1})+sk, max_weight(c1, {s1,..., sk-1}))

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

# Value Maximization

Example: Capacity c = 20kg, weight of items: 8kg, 500¥; 2kg, 2000¥; 4kg, 235¥; 7kg, 700¥; 2kg, 400¥; 1kg, 100¥; 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)

# Variations of the Knapsack Problem (Summary)

1. All items are the same; how many items fit in?
Solution: Divide capacity by item weight
Design strategy: Simplistic 'algorithm'
2. Pack as many items as possible
Design strategy: Greedy algorithm
3. Use as much capacity as possible (integer version)
Solution: Consider subproblems with capacity c'c and items s1,..., sk (kn)
Design Strategy: Dynamic programming
4. Maximize value
Design Strategy: Brute force

# Brute Force Algorithm

• Try all solution possibilities (combinations, permutations,...)
• Choose the best solution
• May be very slow
• May be improved by shortcuts (e.g. compare with best solution found up to now)

# Algorithm Design Strategies

• 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

# Goal for Remaining Time

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

# Example Problem 1: 3-SAT

• 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):
(x1x2x4) ∧ (x1'∨x3x4') ∧ (x2x3'∨x4) ∧ (x1'∨x2'∨x3')
• Number of possible answers: 2n
• Time to check all possible answers: O(n2n)
• Currently, no faster algorithm is known
• Currently, there is no proof that there is no faster algorithm

# Example Problem 2: Independent Set

• 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: 2n
• Time to check all possible answers: O(n2n)
• Currently, no faster algorithm is known
• Currently, there is no proof that there is no faster algorithm

# Example Problem 3: Traveling Salesman

• n towns
• 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

# Homework

(no need to submit)

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

# Student Survey

(授業改善のための学生アンケート)

WEB Survey

お願い: 自由記述に必ず良かった点、問題点を具体的に書きましょう

(悪い例: 発音が分かりにくい; 良い例: さ行が濁っているかどうか分かりにくい)

# Glossary

NP-completeness
NP-完全性
reducibility

approximation algorithms

brute force

greedy algorithm

knapsack problem
ナップサック問題
capacity

closed formula
「閉じた式」
number sequence

independent set

conflict

traveling salesman