IEOR 269, Spring 2010 Integer Programming and Combinatorial ...

More documents

Recommendations

Info

IEOR269 notes, Prof. Hochbaum, 2010 9 7 Complexity of algorithms It is meaningless to use an algorithm that is “inefficient” (the concept of efficiency will be defined precisely later). The example in he handout of “Reminiscences and Gary & Johnson” shows that an inefficient algorithm may not result in a solution in a reasonable time, even if it is correct. Therefore, the complexity of algorithms is an important issue in optimization. We start by defining polynomial functions. Definition 7.1. A function p(n) is a polynomial function of n if p(n) = ∑ k i=0 a in i for some constants a 0 , a 1 , ..., and a k . The complexity of an algorithm is determined by the number of operations it requires to solve the problem. Operations that should be counted includes addition, subtraction, multiplication, division, comparison, and rounding. While counting operations is addressed in most of the fundamental algorithm courses, another equally important issue concerning the length of the problem input will be discussed below. We illustrate the concept of input length with the following examples. 7.1 Finding the maximum element The problem is to find the maximum element in the set of integers {a 1 , ..., a n }. An algorithm for this problem is i = 1, a max = a 1 until i = n i ← i + 1 a max ← max{a i , a max } 2 end The input of this problem includes the numbers n, a 1 , a 2 , ..., and a n . Since we need 1+⌈log 2 x⌉ bits to represent a number x in the binary representation used by computers, the size of the input is n∑ 1 + ⌈log 2 n⌉ + 1 + ⌈log 2 a 1 ⌉ + · · · + 1 + ⌈log 2 a n ⌉ ≥ n + ⌈log 2 a i ⌉. (7) To complete the algorithm, the operations we need is n − 1 comparisons. This number is even smaller than the input length! Therefore, the complexity of this algorithm is at most linear in the input size. 7.2 0-1 knapsack As defined in the first lecture, the problem is to solve i=1 max s.t. ∑ n j=1 u jx j ∑ n j=1 v jx j ≤ B x j ∈ {0, 1} ∀j = 1, 2, ..., n, 2 this statement is actually implemented by if a i ≥ a max a max ← a i end
IEOR269 notes, Prof. Hochbaum, 2010 10 we restrict parameters to be integers in this section. The input includes 2n + 2 numbers: n, set of v j ’s, set of u j ’s, and B. Similar to the calculation in (7), the input size is at least 2n + 2 + n∑ ⌈log 2 u j ⌉ + j=1 n∑ ⌈log 2 v j ⌉ + ⌈log 2 B⌉. (8) This problem may be solved by the following dynamic programming (DP) algorithm. First, we define f k (y) = max ∑ k j=1 u jx j s.t. ∑ k j=1 v jx j ≤ y j=1 x j ∈ {0, 1} ∀j = 1, 2, ..., k. With this definition, we may have the recursion } f k (y) = max {f k−1 (y), f k−1 (y − v k ) + u k . The boundary condition we need is f k (0) = 0 for all k from 1 to n. Let g(y, u, v) = u if y ≥ v and 0 otherwise, we may then start from k = 1 and solve { } f 1 (y) = max 0, g(y, u 1 , v 1 ) . Then we proceed to f 2 (·), f 3 (·), ..., and f n (·). The solution will be found by looking into f n (B). Now let’s consider the complexity of this algorithm. The total number of f functions is nB, and for each f function we need 1 comparison and 2 additions. Therefore, the number of total operations we need is O(nB) = O(n2 log 2 B ). Note that 2 log 2 B is an exponential function of the term ⌈log 2 B⌉ in the input size. Therefore, if B is large enough and ⌈log 2 B⌉ dominates other terms in (8), then the number of operations is an exponential function of the input size! However, if B is small enough, then this algorithm works well. An algorithm with its complexity similar to this O(nB) is called pseudo-polynomial. Definition 7.2. An algorithm is pseudo-polynomial time if it runs in a polynomial time with a unary-represented input. For the 0-1 knapsack problem, the input size will be n + ∑ n j=1 (v i + u i ) + B under unary representation. It then follows that the number of operations becomes a quadratic function of the input size. Therefore, we conclude that the dynamic programming algorithm for the 0-1 knapsack is pseudo-polynomial. 7.3 Linear systems Given an n × n matrix A and an n × 1 vector b, the problem is to solve the linear system Ax = b. As several algorithms have been proposed for solving linear systems, here we discuss Gaussian elimination: through a sequence of elementary row operations, change A to a lower-triangular matrix. For this problem, the input is the matrix A and the vector b. To represent the n 2 + n numbers, the number of bits we need is bounded below by n 2 + n∑ i=1 j=1 n∑ ⌈log 2 a ij ⌉ + n∑ ⌈log 2 b i ⌉. i=1
Page 1 and 2: IEOR 269, Spring 2010 Integer Progr
Page 3 and 4: IEOR269 notes, Prof. Hochbaum, 2010
Page 13: IEOR269 notes, Prof. Hochbaum, 2010
Page 65 and 66:
IEOR269 notes, Prof. Hochbaum, 2010
Page 67 and 68:
Page 69 and 70:
Page 71 and 72:
Page 73 and 74:
Page 75 and 76:
Page 77 and 78:
Page 79 and 80:
Page 81 and 82:
Page 83 and 84:
Page 85 and 86:
Page 87 and 88:
Page 89 and 90:
Page 91 and 92:
Page 93 and 94:
Page 95 and 96:
Page 97 and 98:
Page 99 and 100:
Page 101 and 102:
References 1. G.B. Dantzig & D.R. F
Page 103 and 104:
Page 105 and 106:
Page 107 and 108:
Page 109 and 110:
Page 111 and 112:
Page 113 and 114:
Page 115 and 116:
Page 117 and 118:
Page 119 and 120:
Page 121 and 122:
Page 123 and 124:
Page 125 and 126:
Page 127 and 128:
Page 129 and 130:
Page 131 and 132:
Page 133 and 134:
Page 135 and 136:
Page 137 and 138:
Page 139 and 140:
Page 141 and 142:
Page 143 and 144:
Page 145 and 146:
show all

IEOR 269, Spring 2010 Integer Programming and Combinatorial ...

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?