1 Review of Vertex Cover
|
|
- Eileen Little
- 5 years ago
- Views:
Transcription
1 CS266: Parameterized Algorithms and Complexity Stanford University Lecture 3 Tuesday, April 9 Scribe: Huacheng Yu Spring Review of Vertex Cover In the last lecture, we discussed FPT algorithms for the k-vertex cover problem. By doing backtracking and analyzing different cases, we can get a recurrence with different cases, such as T (k) max{t (k 1) + T (k 4), T (k 2) + T (k 4),...} + poly(n), and such recurrences will solve to something of the form T (k) = O(c k poly(n)), for a constant c (1, 2). Using more clever backtracking, one can develop even more complex recurrences and a running time of O(1.27 k poly(n)). For the minimum vertex cover problem, we can therefore solve it on arbitrary graphs in time O (1.27 n ). 1 In fact, one can get a slightly better running time for arbitrary graphs, via the following trick. Notice that if the vertex cover is of size at least n δn for some δ < 1/2, we can solve the problem in O ( ( n δn) ) time, by trying all vertex subsets of size at least n δn. This bound is at most O (2 H(δ)n ), where H is the binary entropy function, i.e., H(δ) = δ log 2 (1/δ) + (1 δ) log 2 (1/(1 δ)). On the other hand, if the vertex cover is of size at most n δn, then we get O (1.27 n δn ) time. By calculation, we find that the first bound is smaller when δ , and the second bound is smaller when δ In the worst case, when δ , the running time becomes O (1.252 n ). It is an open question whether minimum vertex cover on n nodes be solved in time O((1 + ɛ) n ) for any ɛ > 0. Later we will see that this turns out to be equivalent to the question of whether 3SAT has such an algorithm on instances with n variables! It also has been studied how to have computers efficiently analyze such backtracking recurrences for us, when they are given the recurrence as an input (in some form) [1]. 2 The k-path Problem Over the next few lectures, we will be discussing the fixed-parameter tractability of the k-path problem: Definition 2.1 (k-path) Given a directed graph G = (V, E), parameter k, is there a path 2 in G of length k? The problem has interesting biology applications. For example, in [2], they studied the minimum weight k-path problem: given a directed edge-weighted graph G, find the k-path with minimum weight sum. 1 The notation O (f(n)) suppresses polynomial factors, so O (f(n)) = O(f(n) poly(n)). 2 A path does not go through a vertex twice. 1
2 3 Hamiltonian Path Before we discuss k-path, it will be useful for us to first discuss algorithms for the famous NP-complete Hamiltonian path problem, which is the special case where k = n. The naive algorithm for Hamiltonian Path takes time O (n!) = 2 O(n log n). In the following, for simplicity, we denote the number of vertices by n, and the number of edges by m. It will also be convenient to associate the set of n vertices with the set {1,..., n}. 3.1 Dynamic Programming Our first algorithm shows how to beat the n! running time: Theorem 3.1 (Bellman, Held-Karp 60s) Hamiltonian path problem can be solve in O (2 n ) time. Proof. We use dynamic programming to solve this problem. The basic idea is this: suppose you are walking through the graph, and trying to construct a Hamiltonian path. After you have visited some of the vertices, you do not need to remember the actual order of vertices that you have visited in the past: you just need to remember the set of such vertices.that you visited, in order to continue constructing a Hamiltonian path. More formally, we construct a table T, indexed by 2 V V, such that T (S, v) = 1 if and only if there is a path going through S ending at v. We can compute the table T using the following algorithm: Set T (, v) = 1 for all v V, and set all other entries of T to 0. for t = 0,..., n 2 S, S = t, v V, v / S if T (S, v) = 1 then u / S s.t. (v, u) E Set T (S {v}, u) = 1 end if end for output Hamiltonian path exists iff v V, T (V \{v}, v) = 1 The intuition: initially, our table T only knows that there are 1-node paths starting and ending at each vertex. In subsequent iterations, it constructs enough information to determine the existence of paths on t + 1 vertices, for t = 0,..., n 2. Each iteration consists of examining all subsets S of t vertices, determining if there is a v / S that has a path through the vertices in S; if so, then we conclude there are paths through S {v} that end in the vertex u, for all u adjacent to v that are not already in S. It is easy to verify that this algorithm solves Hamiltonian path and runs in time O (2 n ). 3.2 A More Space-Efficient Algorithm Could we use the above algorithm to get a FPT algorithm for k-path? If we simply restrict subsets S to be all sets of size at most k, the above algorithm will run in time O ( ( n k) ), which is not FPT. Also, this algorithm has the issue that it uses exponential space, while the naive algorithm of O (n!) time only costs polynomial space. Actually there is another algorithm that solves it in both O (2 n ) time and O (1) space, by the following theorem. Theorem 3.2 (Karp 80s) Hamiltonian path problem can be solved in O (2 n ) time and O (1) space. Proof. The key idea here is to solve a harder problem than just finding a Hamiltonian path: we count the number of Hamiltonian paths. To do this, we use the Inclusion-Exclusion Principle, which will give us a reduction from 2
3 counting paths in a graph (which is hard) to counting walks in a graph (which is easy) The catch is that the number of calls to counting walks in our reduction will be 2 n. Recall that a walk in a graph is any sequence of vertices (v 1,..., v t ) such that (v i, v i+1 ) is an edge. A walk on t vertices is called a t-walk. The difference between a walk and a path is that a walk can visit the same vertex several times, while a path cannot. Denote the number of n-node walks in G by W G. W G can be computed efficiently by the following lemma. Lemma 3.1 For any G, we can compute the number of n-node walks in time O(poly(n)). Proof of Lemma 3.1. Let A be the adjacency matrix of G. Consider the quantity A 2 (i, j) = k A(i, k) A(k, j). Observe that this is equal to the number of 3-node walks from i to j (i.e., walks of the form (i, k, j)). Similarly, we can prove by induction that A l 1 (i, j) is the number of k-node walks from i to j, for all l. Therefore we can set W G = i j A n 1 (i, j), which is computable in polynomial time by repeated matrix multiplications. Now a key observation is: Proposition 3.1 An n-walk P is Hamiltonian if and only if P visits all vertices in the graph. Any Hamiltonian path must reach all vertices in the graph. In the opposite direction, if the walk P is n vertices long, and it visits all n vertices, then it must visit each vertex exactly once. For any subset of vertices S V, let G S = (V S, E (S V ) (V S)). That is, G S is the subgraph of G not containing the vertex set S. Then, W G{v} is the number of n-walks that do not go through v. To use the Inclusion- Exclusion Principle, we let W be the set of all n-walks ( W = W G ), and S i be the set of all n-walks containing node i. We have the following: n i=1 S i = the number of Hamiltonian paths, by the above proposition; By the Inclusion-Exclusion Principle, n i=1 S i = W i S i + i<j S i S j ; observe that S i = the number of n-walks that do not contain i = W G{i}, S i S j = W G{i,j}, and so on. We compute each of the W GS in polynomial time and space, and each one is then is added to or subtracted from the total sum depending on S. There are 2 n different W GS to compute. Once we ve computed them all and added/subtracted them, we have the number of Hamiltonian paths. The running time is O (2 n ) and the space used is O (1). 3
4 3.3 Dynamic Programming Vs Inclusion-Exclusion There is an important difference between the dynamic programming algorithm and the inclusion-exclusion algorithm, beyond the big difference in space usage. The dynamic programming algorithm for Hamiltonian paths can be extended to solve the Traveling Salesman Problem (TSP) as well (instead of storing a 0-1 value indicating if there is a path, we store the value for the minimum sum weighted path, over all paths that pass through the subset S and end at v). Therefore TSP can also be solved in time O (2 n ), and it is the fastest known worst-case algorithm for TSP. However, we do not know how to adapt the inclusion-exclusion algorithm to solve TSP efficiently! (There are ways to do it, but they are pseudopolynomial in the weights of the edges.) It is an open problem if can we solve TSP in both time O (2 n ) and space O (1). Moreover, there are very sophisticated variants on the inclusion-exclusion ideas for Hamiltonian path which lead to O (1.66 n ) time in undirected graphs, but we do not know how to extend that to TSP. Now, it is known that TSP can be solved in O (4 n ) time and O (1) space. The idea is to try all possibilities for the first n/2 nodes L that we will visit in the TSP solution. One of these subsets L will be correct. For each L, recurse on L and V \L, and have these recursive calls return two n/2 by n/2 matrices A and B, storing the minimum weight path from i to j for i, j L and for i, j V \L, respectively. Using all of these pairs of matrices A and B that are returned over all possible choices for L, we can construct an n n matrix M which stores the minimum weight path from i to j for i, j V. (Think about how you would do this! If w(k, j) denotes the weight of the edge from k to j, note that A[i, k] + w(k, j) + B[j, l] gives the minimum weight path that starts at i L, passes through all the vertices of L ending at k L, takes the edge from k to j V L, then passes through all vertices in V L, ending in l V L. By trying all L, and all edges that pass between L and V L, we can compute the (i, l) entry of M.) The recurrence for the running time is ( ) n T (n) 2 T (n/2) + O (1) O (2 n+n/2+n/4+ ) = O (4 n ). n/2 4 Onward to k-path The idea of the FPT algorithm for k-path is to first do a randomized reduction from k-path on arbitrary graphs to k-path on simple graphs which are easy to solve. We will solve the easy problem, then we will get rid of the randomization. The easy problem is Longest Path in a DAG (directed acyclic graph). It can be solved in polynomial time by dynamic programming. (Think about it!) Now here is our randomized reduction. Suppose G is directed for simplicity. We generate a random permutation π : [n] [n] (it is important to think about how you might do this!). We remove all edges (π(i), π(j)) for i > j in G. This results in a DAG, G. We then compute the longest path in this DAG G. If there is a k-path in G, with probability 1/k!, there is a k-path in G : the order of the vertices in the k path is preserved by the permutation. If there is no k-path in G, then there will certainly be no k-path in G we are only removing edges. Doing this randomized reduction for O(k!) times, we can therefore determine whether there is a k-path in G with high probability. The running time will be O(k! poly(n)). In next lecture, we will talk about how to get rid of the randomization, and much more. References [1] David Eppstein. Quasiconvex analysis of backtracking algorithms. In Proc. 15th Symp. Discrete Algorithms, pages ACM and SIAM, January
5 [2] Jacob Scott, Trey Ideker, Richard M. Karp, and Roded Sharan. Efficient algorithms for detecting signaling pathways in protein interaction networks. In RECOMB, pages 1 13,
Lecture 24 Nov. 20, 2014
CS 224: Advanced Algorithms Fall 2014 Prof. Jelani Nelson Lecture 24 Nov. 20, 2014 Scribe: Xiaoyu He Overview Today we will move to a new topic: another way to deal with NP-hard problems. We have already
More informationIntractable Problems Part One
Intractable Problems Part One Announcements Problem Set Five due right now. Solutions will be released at end of lecture. Correction posted for Guide to Dynamic Programming, sorry about that! Please evaluate
More informationAlgorithms and Theory of Computation. Lecture 22: NP-Completeness (2)
Algorithms and Theory of Computation Lecture 22: NP-Completeness (2) Xiaohui Bei MAS 714 November 8, 2018 Nanyang Technological University MAS 714 November 8, 2018 1 / 20 Set Cover Set Cover Input: a set
More informationCS 241 Analysis of Algorithms
CS 241 Analysis of Algorithms Professor Eric Aaron Lecture T Th 9:00am Lecture Meeting Location: OLB 205 Business Grading updates: HW5 back today HW7 due Dec. 10 Reading: Ch. 22.1-22.3, Ch. 25.1-2, Ch.
More informationLecture 4: NP and computational intractability
Chapter 4 Lecture 4: NP and computational intractability Listen to: Find the longest path, Daniel Barret What do we do today: polynomial time reduction NP, co-np and NP complete problems some examples
More information/633 Introduction to Algorithms Lecturer: Michael Dinitz Topic: NP-Completeness I Date: 11/13/18
601.433/633 Introduction to Algorithms Lecturer: Michael Dinitz Topic: NP-Completeness I Date: 11/13/18 20.1 Introduction Definition 20.1.1 We say that an algorithm runs in polynomial time if its running
More informationDesign and Analysis of Algorithms
Design and Analysis of Algorithms CSE 5311 Lecture 25 NP Completeness Junzhou Huang, Ph.D. Department of Computer Science and Engineering CSE5311 Design and Analysis of Algorithms 1 NP-Completeness Some
More informationChapter 34: NP-Completeness
Graph Algorithms - Spring 2011 Set 17. Lecturer: Huilan Chang Reference: Cormen, Leiserson, Rivest, and Stein, Introduction to Algorithms, 2nd Edition, The MIT Press. Chapter 34: NP-Completeness 2. Polynomial-time
More informationIntractable Problems Part Two
Intractable Problems Part Two Announcements Problem Set Five graded; will be returned at the end of lecture. Extra office hours today after lecture from 4PM 6PM in Clark S250. Reminder: Final project goes
More informationCombinatorial Optimization
Combinatorial Optimization Problem set 8: solutions 1. Fix constants a R and b > 1. For n N, let f(n) = n a and g(n) = b n. Prove that f(n) = o ( g(n) ). Solution. First we observe that g(n) 0 for all
More informationLecture 4 October 18th
Directed and undirected graphical models Fall 2017 Lecture 4 October 18th Lecturer: Guillaume Obozinski Scribe: In this lecture, we will assume that all random variables are discrete, to keep notations
More informationUnit 1A: Computational Complexity
Unit 1A: Computational Complexity Course contents: Computational complexity NP-completeness Algorithmic Paradigms Readings Chapters 3, 4, and 5 Unit 1A 1 O: Upper Bounding Function Def: f(n)= O(g(n)) if
More informationVIII. NP-completeness
VIII. NP-completeness 1 / 15 NP-Completeness Overview 1. Introduction 2. P and NP 3. NP-complete (NPC): formal definition 4. How to prove a problem is NPC 5. How to solve a NPC problem: approximate algorithms
More informationExact and Parameterized Algorithms for Max Internal Spanning Tree
Exact and Parameterized Algorithms for Max Internal Spanning Tree Henning Fernau 1, Serge Gaspers 2, and Daniel Raible 1 1 Univ. Trier, FB 4 Abteilung Informatik, D-54286 Trier, Germany {fernau,raible}@uni-trier.de
More informationLecture 6 January 21, 2013
UBC CPSC 536N: Sparse Approximations Winter 03 Prof. Nick Harvey Lecture 6 January, 03 Scribe: Zachary Drudi In the previous lecture, we discussed max flow problems. Today, we consider the Travelling Salesman
More informationCS/COE
CS/COE 1501 www.cs.pitt.edu/~nlf4/cs1501/ P vs NP But first, something completely different... Some computational problems are unsolvable No algorithm can be written that will always produce the correct
More informationClassical Complexity and Fixed-Parameter Tractability of Simultaneous Consecutive Ones Submatrix & Editing Problems
Classical Complexity and Fixed-Parameter Tractability of Simultaneous Consecutive Ones Submatrix & Editing Problems Rani M. R, Mohith Jagalmohanan, R. Subashini Binary matrices having simultaneous consecutive
More informationAdmin NP-COMPLETE PROBLEMS. Run-time analysis. Tractable vs. intractable problems 5/2/13. What is a tractable problem?
Admin Two more assignments No office hours on tomorrow NP-COMPLETE PROBLEMS Run-time analysis Tractable vs. intractable problems We ve spent a lot of time in this class putting algorithms into specific
More informationNP-Completeness. Until now we have been designing algorithms for specific problems
NP-Completeness 1 Introduction Until now we have been designing algorithms for specific problems We have seen running times O(log n), O(n), O(n log n), O(n 2 ), O(n 3 )... We have also discussed lower
More informationEasy Problems vs. Hard Problems. CSE 421 Introduction to Algorithms Winter Is P a good definition of efficient? The class P
Easy Problems vs. Hard Problems CSE 421 Introduction to Algorithms Winter 2000 NP-Completeness (Chapter 11) Easy - problems whose worst case running time is bounded by some polynomial in the size of the
More informationECS122A Handout on NP-Completeness March 12, 2018
ECS122A Handout on NP-Completeness March 12, 2018 Contents: I. Introduction II. P and NP III. NP-complete IV. How to prove a problem is NP-complete V. How to solve a NP-complete problem: approximate algorithms
More informationCS173 Running Time and Big-O. Tandy Warnow
CS173 Running Time and Big-O Tandy Warnow CS 173 Running Times and Big-O analysis Tandy Warnow Today s material We will cover: Running time analysis Review of running time analysis of Bubblesort Review
More informationNotes on Space-Bounded Complexity
U.C. Berkeley CS172: Automata, Computability and Complexity Handout 6 Professor Luca Trevisan 4/13/2004 Notes on Space-Bounded Complexity These are notes for CS278, Computational Complexity, scribed by
More informationCS 320, Fall Dr. Geri Georg, Instructor 320 NP 1
NP CS 320, Fall 2017 Dr. Geri Georg, Instructor georg@colostate.edu 320 NP 1 NP Complete A class of problems where: No polynomial time algorithm has been discovered No proof that one doesn t exist 320
More informationP, NP, NP-Complete, and NPhard
P, NP, NP-Complete, and NPhard Problems Zhenjiang Li 21/09/2011 Outline Algorithm time complicity P and NP problems NP-Complete and NP-Hard problems Algorithm time complicity Outline What is this course
More informationNP and Computational Intractability
NP and Computational Intractability 1 Polynomial-Time Reduction Desiderata'. Suppose we could solve X in polynomial-time. What else could we solve in polynomial time? don't confuse with reduces from Reduction.
More informationNotes for Lecture 21
U.C. Berkeley CS170: Intro to CS Theory Handout N21 Professor Luca Trevisan November 20, 2001 Notes for Lecture 21 1 Tractable and Intractable Problems So far, almost all of the problems that we have studied
More informationData Structures in Java
Data Structures in Java Lecture 21: Introduction to NP-Completeness 12/9/2015 Daniel Bauer Algorithms and Problem Solving Purpose of algorithms: find solutions to problems. Data Structures provide ways
More informationQuantum Algorithms for Graph Traversals and Related Problems
Quantum Algorithms for Graph Traversals and Related Problems Sebastian Dörn Institut für Theoretische Informatik, Universität Ulm, 89069 Ulm, Germany sebastian.doern@uni-ulm.de Abstract. We study the complexity
More informationKernelization by matroids: Odd Cycle Transversal
Lecture 8 (10.05.2013) Scribe: Tomasz Kociumaka Lecturer: Marek Cygan Kernelization by matroids: Odd Cycle Transversal 1 Introduction The main aim of this lecture is to give a polynomial kernel for the
More informationLecture 18: More NP-Complete Problems
6.045 Lecture 18: More NP-Complete Problems 1 The Clique Problem a d f c b e g Given a graph G and positive k, does G contain a complete subgraph on k nodes? CLIQUE = { (G,k) G is an undirected graph with
More informationNP Complete Problems. COMP 215 Lecture 20
NP Complete Problems COMP 215 Lecture 20 Complexity Theory Complexity theory is a research area unto itself. The central project is classifying problems as either tractable or intractable. Tractable Worst
More informationTopics in Complexity Theory
Topics in Complexity Theory Announcements Final exam this Friday from 12:15PM-3:15PM Please let us know immediately after lecture if you want to take the final at an alternate time and haven't yet told
More information2.1 Laplacian Variants
-3 MS&E 337: Spectral Graph heory and Algorithmic Applications Spring 2015 Lecturer: Prof. Amin Saberi Lecture 2-3: 4/7/2015 Scribe: Simon Anastasiadis and Nolan Skochdopole Disclaimer: hese notes have
More informationNP-Complete Problems. More reductions
NP-Complete Problems More reductions Definitions P: problems that can be solved in polynomial time (typically in n, size of input) on a deterministic Turing machine Any normal computer simulates a DTM
More informationFriday Four Square! Today at 4:15PM, Outside Gates
P and NP Friday Four Square! Today at 4:15PM, Outside Gates Recap from Last Time Regular Languages DCFLs CFLs Efficiently Decidable Languages R Undecidable Languages Time Complexity A step of a Turing
More informationNP-completeness. Chapter 34. Sergey Bereg
NP-completeness Chapter 34 Sergey Bereg Oct 2017 Examples Some problems admit polynomial time algorithms, i.e. O(n k ) running time where n is the input size. We will study a class of NP-complete problems
More informationNotes on Space-Bounded Complexity
U.C. Berkeley CS172: Automata, Computability and Complexity Handout 7 Professor Luca Trevisan April 14, 2015 Notes on Space-Bounded Complexity These are notes for CS278, Computational Complexity, scribed
More informationCS 6505, Complexity and Algorithms Week 7: NP Completeness
CS 6505, Complexity and Algorithms Week 7: NP Completeness Reductions We have seen some problems in P and NP, and we ve talked about space complexity. The Space Hierarchy Theorem showed us that there are
More informationPolynomial-time Reductions
Polynomial-time Reductions Disclaimer: Many denitions in these slides should be taken as the intuitive meaning, as the precise meaning of some of the terms are hard to pin down without introducing the
More informationDynamic Programming. Shuang Zhao. Microsoft Research Asia September 5, Dynamic Programming. Shuang Zhao. Outline. Introduction.
Microsoft Research Asia September 5, 2005 1 2 3 4 Section I What is? Definition is a technique for efficiently recurrence computing by storing partial results. In this slides, I will NOT use too many formal
More informationCS 350 Algorithms and Complexity
1 CS 350 Algorithms and Complexity Fall 2015 Lecture 15: Limitations of Algorithmic Power Introduction to complexity theory Andrew P. Black Department of Computer Science Portland State University Lower
More informationEssential facts about NP-completeness:
CMPSCI611: NP Completeness Lecture 17 Essential facts about NP-completeness: Any NP-complete problem can be solved by a simple, but exponentially slow algorithm. We don t have polynomial-time solutions
More informationNP-Complete Problems and Approximation Algorithms
NP-Complete Problems and Approximation Algorithms Efficiency of Algorithms Algorithms that have time efficiency of O(n k ), that is polynomial of the input size, are considered to be tractable or easy
More informationFINAL EXAM PRACTICE PROBLEMS CMSC 451 (Spring 2016)
FINAL EXAM PRACTICE PROBLEMS CMSC 451 (Spring 2016) The final exam will be on Thursday, May 12, from 8:00 10:00 am, at our regular class location (CSI 2117). It will be closed-book and closed-notes, except
More informationLecture 3: Reductions and Completeness
CS 710: Complexity Theory 9/13/2011 Lecture 3: Reductions and Completeness Instructor: Dieter van Melkebeek Scribe: Brian Nixon Last lecture we introduced the notion of a universal Turing machine for deterministic
More informationLecture 7: Dynamic Programming I: Optimal BSTs
5-750: Graduate Algorithms February, 06 Lecture 7: Dynamic Programming I: Optimal BSTs Lecturer: David Witmer Scribes: Ellango Jothimurugesan, Ziqiang Feng Overview The basic idea of dynamic programming
More informationCHAPTER 3 FUNDAMENTALS OF COMPUTATIONAL COMPLEXITY. E. Amaldi Foundations of Operations Research Politecnico di Milano 1
CHAPTER 3 FUNDAMENTALS OF COMPUTATIONAL COMPLEXITY E. Amaldi Foundations of Operations Research Politecnico di Milano 1 Goal: Evaluate the computational requirements (this course s focus: time) to solve
More informationLecture 22: Counting
CS 710: Complexity Theory 4/8/2010 Lecture 22: Counting Instructor: Dieter van Melkebeek Scribe: Phil Rydzewski & Chi Man Liu Last time we introduced extractors and discussed two methods to construct them.
More informationP P P NP-Hard: L is NP-hard if for all L NP, L L. Thus, if we could solve L in polynomial. Cook's Theorem and Reductions
Summary of the previous lecture Recall that we mentioned the following topics: P: is the set of decision problems (or languages) that are solvable in polynomial time. NP: is the set of decision problems
More informationData Structures and Algorithms
Data Structures and Algorithms CS245-2015S-23 NP-Completeness and Undecidablity David Galles Department of Computer Science University of San Francisco 23-0: Hard Problems Some algorithms take exponential
More informationLecture 59 : Instance Compression and Succinct PCP s for NP
IITM-CS6840: Advanced Complexity Theory March 31, 2012 Lecture 59 : Instance Compression and Succinct PCP s for NP Lecturer: Sivaramakrishnan N.R. Scribe: Prashant Vasudevan 1 Introduction Classical Complexity
More informationLimitations of Algorithm Power
Limitations of Algorithm Power Objectives We now move into the third and final major theme for this course. 1. Tools for analyzing algorithms. 2. Design strategies for designing algorithms. 3. Identifying
More informationNP-Completeness I. Lecture Overview Introduction: Reduction and Expressiveness
Lecture 19 NP-Completeness I 19.1 Overview In the past few lectures we have looked at increasingly more expressive problems that we were able to solve using efficient algorithms. In this lecture we introduce
More information4.1 Notation and probability review
Directed and undirected graphical models Fall 2015 Lecture 4 October 21st Lecturer: Simon Lacoste-Julien Scribe: Jaime Roquero, JieYing Wu 4.1 Notation and probability review 4.1.1 Notations Let us recall
More informationAutomata Theory CS Complexity Theory I: Polynomial Time
Automata Theory CS411-2015-17 Complexity Theory I: Polynomial Time David Galles Department of Computer Science University of San Francisco 17-0: Tractable vs. Intractable If a problem is recursive, then
More informationU.C. Berkeley CS278: Computational Complexity Professor Luca Trevisan 9/6/2004. Notes for Lecture 3
U.C. Berkeley CS278: Computational Complexity Handout N3 Professor Luca Trevisan 9/6/2004 Notes for Lecture 3 Revised 10/6/04 1 Space-Bounded Complexity Classes A machine solves a problem using space s(
More informationComputer Science 385 Analysis of Algorithms Siena College Spring Topic Notes: Limitations of Algorithms
Computer Science 385 Analysis of Algorithms Siena College Spring 2011 Topic Notes: Limitations of Algorithms We conclude with a discussion of the limitations of the power of algorithms. That is, what kinds
More informationCS 350 Algorithms and Complexity
CS 350 Algorithms and Complexity Winter 2019 Lecture 15: Limitations of Algorithmic Power Introduction to complexity theory Andrew P. Black Department of Computer Science Portland State University Lower
More information1 Circuit Complexity. CS 6743 Lecture 15 1 Fall Definitions
CS 6743 Lecture 15 1 Fall 2007 1 Circuit Complexity 1.1 Definitions A Boolean circuit C on n inputs x 1,..., x n is a directed acyclic graph (DAG) with n nodes of in-degree 0 (the inputs x 1,..., x n ),
More informationNP-Completeness. CptS 223 Advanced Data Structures. Larry Holder School of Electrical Engineering and Computer Science Washington State University
NP-Completeness CptS 223 Advanced Data Structures Larry Holder School of Electrical Engineering and Computer Science Washington State University 1 Hard Graph Problems Hard means no known solutions with
More informationLecture 15 - NP Completeness 1
CME 305: Discrete Mathematics and Algorithms Instructor: Professor Aaron Sidford (sidford@stanford.edu) February 29, 2018 Lecture 15 - NP Completeness 1 In the last lecture we discussed how to provide
More informationThe Complexity of the Permanent and Related Problems
The Complexity of the Permanent and Related Problems Tim Abbott and Alex Schwendner May 9, 2007 Contents 1 The Permanent 2 1.1 Variations on the Determinant...................... 2 1.2 Graph Interpretation...........................
More informationLecture 20: PSPACE. November 15, 2016 CS 1010 Theory of Computation
Lecture 20: PSPACE November 15, 2016 CS 1010 Theory of Computation Recall that PSPACE = k=1 SPACE(nk ). We will see that a relationship between time and space complexity is given by: P NP PSPACE = NPSPACE
More informationNP-complete problems. CSE 101: Design and Analysis of Algorithms Lecture 20
NP-complete problems CSE 101: Design and Analysis of Algorithms Lecture 20 CSE 101: Design and analysis of algorithms NP-complete problems Reading: Chapter 8 Homework 7 is due today, 11:59 PM Tomorrow
More informationP, NP, NP-Complete. Ruth Anderson
P, NP, NP-Complete Ruth Anderson A Few Problems: Euler Circuits Hamiltonian Circuits Intractability: P and NP NP-Complete What now? Today s Agenda 2 Try it! Which of these can you draw (trace all edges)
More informationLecture 25: Cook s Theorem (1997) Steven Skiena. skiena
Lecture 25: Cook s Theorem (1997) Steven Skiena Department of Computer Science State University of New York Stony Brook, NY 11794 4400 http://www.cs.sunysb.edu/ skiena Prove that Hamiltonian Path is NP
More information10.4 The Kruskal Katona theorem
104 The Krusal Katona theorem 141 Example 1013 (Maximum weight traveling salesman problem We are given a complete directed graph with non-negative weights on edges, and we must find a maximum weight Hamiltonian
More information4/12/2011. Chapter 8. NP and Computational Intractability. Directed Hamiltonian Cycle. Traveling Salesman Problem. Directed Hamiltonian Cycle
Directed Hamiltonian Cycle Chapter 8 NP and Computational Intractability Claim. G has a Hamiltonian cycle iff G' does. Pf. Suppose G has a directed Hamiltonian cycle Γ. Then G' has an undirected Hamiltonian
More informationComplexity Theory Part II
Complexity Theory Part II Time Complexity The time complexity of a TM M is a function denoting the worst-case number of steps M takes on any input of length n. By convention, n denotes the length of the
More informationCSCI3390-Lecture 17: A sampler of NP-complete problems
CSCI3390-Lecture 17: A sampler of NP-complete problems 1 List of Problems We now know that if L is any problem in NP, that L P SAT, and thus SAT is NP-hard. Since SAT is also in NP we find that SAT is
More informationGraduate Algorithms CS F-21 NP & Approximation Algorithms
Graduate Algorithms CS673-2016F-21 NP & Approximation Algorithms David Galles Department of Computer Science University of San Francisco 21-0: Classes of Problems Consider three problem classes: Polynomial
More informationTractable & Intractable Problems
Tractable & Intractable Problems We will be looking at : What is a P and NP problem NP-Completeness The question of whether P=NP The Traveling Salesman problem again Programming and Data Structures 1 Polynomial
More informationTheory of Computation Time Complexity
Theory of Computation Time Complexity Bow-Yaw Wang Academia Sinica Spring 2012 Bow-Yaw Wang (Academia Sinica) Time Complexity Spring 2012 1 / 59 Time for Deciding a Language Let us consider A = {0 n 1
More informationAlgorithms and Theory of Computation. Lecture 19: Class P and NP, Reduction
Algorithms and Theory of Computation Lecture 19: Class P and NP, Reduction Xiaohui Bei MAS 714 October 29, 2018 Nanyang Technological University MAS 714 October 29, 2018 1 / 26 Decision Problems Revisited
More informationInstitute of Operating Systems and Computer Networks Algorithms Group. Network Algorithms. Tutorial 3: Shortest paths and other stuff
Institute of Operating Systems and Computer Networks Algorithms Group Network Algorithms Tutorial 3: Shortest paths and other stuff Christian Rieck Shortest paths: Dijkstra s algorithm 2 Dijkstra s algorithm
More informationCS 583: Approximation Algorithms: Introduction
CS 583: Approximation Algorithms: Introduction Chandra Chekuri January 15, 2018 1 Introduction Course Objectives 1. To appreciate that not all intractable problems are the same. NP optimization problems,
More informationCSE 202 Homework 4 Matthias Springer, A
CSE 202 Homework 4 Matthias Springer, A99500782 1 Problem 2 Basic Idea PERFECT ASSEMBLY N P: a permutation P of s i S is a certificate that can be checked in polynomial time by ensuring that P = S, and
More informationAlgorithms Re-Exam TIN093/DIT600
Algorithms Re-Exam TIN093/DIT600 Course: Algorithms Course code: TIN 093 (CTH), DIT 600 (GU) Date, time: 7th January 2016, 8:30 12:30 Building: M Responsible teacher: Peter Damaschke, Tel. 5405. Examiner:
More informationCSC 5170: Theory of Computational Complexity Lecture 4 The Chinese University of Hong Kong 1 February 2010
CSC 5170: Theory of Computational Complexity Lecture 4 The Chinese University of Hong Kong 1 February 2010 Computational complexity studies the amount of resources necessary to perform given computations.
More informationAlgorithms and Complexity Theory. Chapter 8: Introduction to Complexity. Computer Science - Durban - September 2005
Algorithms and Complexity Theory Chapter 8: Introduction to Complexity Jules-R Tapamo Computer Science - Durban - September 2005 Contents 1 Introduction 2 1.1 Dynamic programming...................................
More informationUC Berkeley CS 170: Efficient Algorithms and Intractable Problems Handout 22 Lecturer: David Wagner April 24, Notes 22 for CS 170
UC Berkeley CS 170: Efficient Algorithms and Intractable Problems Handout 22 Lecturer: David Wagner April 24, 2003 Notes 22 for CS 170 1 NP-completeness of Circuit-SAT We will prove that the circuit satisfiability
More informationLecture 2: Divide and conquer and Dynamic programming
Chapter 2 Lecture 2: Divide and conquer and Dynamic programming 2.1 Divide and Conquer Idea: - divide the problem into subproblems in linear time - solve subproblems recursively - combine the results in
More informationData Structures and Algorithms (CSCI 340)
University of Wisconsin Parkside Fall Semester 2008 Department of Computer Science Prof. Dr. F. Seutter Data Structures and Algorithms (CSCI 340) Homework Assignments The numbering of the problems refers
More informationNotes for Lecture Notes 2
Stanford University CS254: Computational Complexity Notes 2 Luca Trevisan January 11, 2012 Notes for Lecture Notes 2 In this lecture we define NP, we state the P versus NP problem, we prove that its formulation
More informationLecture 4 : Quest for Structure in Counting Problems
CS6840: Advanced Complexity Theory Jan 10, 2012 Lecture 4 : Quest for Structure in Counting Problems Lecturer: Jayalal Sarma M.N. Scribe: Dinesh K. Theme: Between P and PSPACE. Lecture Plan:Counting problems
More informationNP Completeness. CS 374: Algorithms & Models of Computation, Spring Lecture 23. November 19, 2015
CS 374: Algorithms & Models of Computation, Spring 2015 NP Completeness Lecture 23 November 19, 2015 Chandra & Lenny (UIUC) CS374 1 Spring 2015 1 / 37 Part I NP-Completeness Chandra & Lenny (UIUC) CS374
More informationComputational Intractability 2010/4/15. Lecture 2
Computational Intractability 2010/4/15 Professor: David Avis Lecture 2 Scribe:Naoki Hatta 1 P and NP 1.1 Definition of P and NP Decision problem it requires yes/no answer. Example: X is a set of strings.
More informationLecture 3: Voronoi Diagrams & VCP Preliminaries July 24, 2013
Blockcourse on High-Dimensional Computational Geometry Spring 2013 Lecture 3: Voronoi Diagrams & VCP Preliminaries July 24, 2013 Wolfgang Mulzer, Helmut Alt Scribes: Simon Tippenhauer, Terese Haimberger
More informationAnalysis of Algorithm Efficiency. Dr. Yingwu Zhu
Analysis of Algorithm Efficiency Dr. Yingwu Zhu Measure Algorithm Efficiency Time efficiency How fast the algorithm runs; amount of time required to accomplish the task Our focus! Space efficiency Amount
More informationSpace and Nondeterminism
CS 221 Computational Complexity, Lecture 5 Feb 6, 2018 Space and Nondeterminism Instructor: Madhu Sudan 1 Scribe: Yong Wook Kwon Topic Overview Today we ll talk about space and non-determinism. For some
More informationExact Exponential Algorithms
/57 Exact Exponential Algorithms Dieter Kratsch Laboratoire d Informatique Théorique et Appliquée Université Paul Verlaine - Metz 57000 METZ Cedex 01 France Algorithms and Complexity in Durham (ACiD 2010)
More informationNondeterministic Polynomial Time
Nondeterministic Polynomial Time 11/1/2016 Discrete Structures (CS 173) Fall 2016 Gul Agha Slides based on Derek Hoiem, University of Illinois 1 2016 CS Alumni Awards Sohaib Abbasi (BS 78, MS 80), Chairman
More informationfsat We next show that if sat P, then fsat has a polynomial-time algorithm. c 2010 Prof. Yuh-Dauh Lyuu, National Taiwan University Page 425
fsat fsat is this function problem: Let φ(x 1, x 2,..., x n ) be a boolean expression. If φ is satisfiable, then return a satisfying truth assignment. Otherwise, return no. We next show that if sat P,
More informationSolving Connected Dominating Set Faster than 2 n
Solving Connected Dominating Set Faster than 2 n Fedor V. Fomin 1, Fabrizio Grandoni 2, and Dieter Kratsch 3 1 Department of Informatics, University of Bergen, N-5020 Bergen, Norway, fomin@ii.uib.no 2
More informationPolynomial-time reductions. We have seen several reductions:
Polynomial-time reductions We have seen several reductions: Polynomial-time reductions Informal explanation of reductions: We have two problems, X and Y. Suppose we have a black-box solving problem X in
More information1 Counting spanning trees: A determinantal formula
Math 374 Matrix Tree Theorem Counting spanning trees: A determinantal formula Recall that a spanning tree of a graph G is a subgraph T so that T is a tree and V (G) = V (T ) Question How many distinct
More informationNP-Complete problems
NP-Complete problems NP-complete problems (NPC): A subset of NP. If any NP-complete problem can be solved in polynomial time, then every problem in NP has a polynomial time solution. NP-complete languages
More informationClasses of Problems. CS 461, Lecture 23. NP-Hard. Today s Outline. We can characterize many problems into three classes:
Classes of Problems We can characterize many problems into three classes: CS 461, Lecture 23 Jared Saia University of New Mexico P is the set of yes/no problems that can be solved in polynomial time. Intuitively
More informationOn the complexity of approximate multivariate integration
On the complexity of approximate multivariate integration Ioannis Koutis Computer Science Department Carnegie Mellon University Pittsburgh, PA 15213 USA ioannis.koutis@cs.cmu.edu January 11, 2005 Abstract
More information