Introduction to Competitive Programming. Instructor: William W.Y. Hsu

Transcription

1 Introduction to Competitive Programming Instructor: William W.Y. Hsu

2 CONTENTS Linear data structures and built-in libraries Array sorting and searching Non-linear data structures with built-in libraries Binary search tree Heap Hash table Data structures without built-in libraries Graphs Union-find disjoint sets Segment tree Fenwick tree 10/2/2016 PROGRAMMING IN C 2

3 Before we begin Who are you? 1. Pure C coder. 2. Pure C++ coder. 3. C/C++ intermixed coder. 4. Pure Java coder. 5. Other coder. 6. Multilingual coder C/C++/Java. 10/2/2016 PROGRAMMING IN C 3

4 Linear data structures and built-in libraries You must know! 10/2/2016 PROGRAMMING IN C 4

5 Linear DS + built in libraries Static arrays, built in support in C/C++/Java Resize able arrays: C++ STL vector, Java Vector Both are very useful in ICPCs/IOIs PS: Java ArrayList may be slightly faster There are 2 very common operations on Array: Sorting Searching 10/2/2016 PROGRAMMING IN C 5

6 Linear DS + built in libraries Array of Boolean: C++ STL bitset Should be faster than array of Booleans or vector<bool>! No specific API in Java that is similar to this. Bitmask Lightweight set of Boolean or bit string Linked List, C++ STL list, Java LinkedList Usually not used just use vector! Stack, C++ STL stack, Java Stack Used by default in recursion, postfix conversion/calculation, bracket matching, etc Queue, C++ STL queue, Java Queue Used in breadth first search, topological sort, etc Deque, C++ STL deque, Java Deque Used in algorithms for sliding window problem, etc 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 6

7 Array sorting and searching This is fundamental. 10/2/2016 PROGRAMMING IN C 7

8 Sorting Definition: Given unsorted stuffs, sort them Popular Sorting Algorithms OO(nn 2 ) algorithms: Bubble/Selection/Insertion Sort OO(nn log nn) algorithms: Merge/Quick/Heap Sort Special purpose: Counting/Radix/Bucket Sort Take a look at wikipedia 10/2/2016 PROGRAMMING IN C 8

9 Sorting In ICPC, you can forget all these In general, if you need to sort something, just use the O(n log n) sorting library: C stdlib.h qsort() C++ STL algorithm:: sort Java Collections.sort In ICPC, sorting is either used as preliminary step for more complex algorithm or to beautify output Familiarity with sorting libraries is a must! 10/2/2016 PROGRAMMING IN C 9

10 Sorting Sorting routines in C++ STL algorithm sort a bug free implementation of introsort* Fast, it runs in OO(nn log nn). Can sort basic data types (ints, doubles, chars), Abstract Data Types (C++ class), multi field sorting ( 2 criteria) partial_sort implementation of heapsort Can do OO(kk log nn) sorting, if we just need top kk sorted! stable_sort If you need to have the sorting stable, keys with same values appear in the same order as in input. 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 10

11 Searching in array Two variants: When the array is sorted versus not sorted. Must do OO(nn) linear scan if not sorted Can use OO(log nn) binary search when sorted PS: must run an OO(nn log nn) sorting algorithm once! Binary search is tricky to code! Instead, use C++ STL algorithm::lower_bound, algorithm::binary_search or Java Collections.binarySearch 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 11

12 Non-linear data structures with built-in libraries More efficient data structures 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 12

13 Binary search tree ADT table (key data) Binary search tree (BST) Advertised OO(log nn) for insert, search, and delete Requirement: the BST must be balanced! AVL tree, Red Black Tree, etc Just use: C++ STL map (Java TreeMap) UVa (Hardwood Species) 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 13

14 Binary search tree ADT Table (key exists or not) Set (Single Set) C++ STL set, similar to C++ STL map map stores a (key, data) pair set stores just the key In Java: TreeSet UVa CD 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 14

15 Heap Heap C++ STL algorithm has some heap algorithms partial_sort uses heapsort C++ STL priority_queue (Java PriorityQueue) is heap Prim s and Dijkstra s algorithms use priority queue. But, we rarely see pure heap problems in ICPC. 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 15

16 Hash table Hash table Advertised OO(1) for insert, search, and delete, but: The hash function must be good! There is no hash table in C++ STL (hashtable in Java API) Nevertheless, OO(log nn) using map is usually ok Direct addressing table (DAT) Rather than hashing, we more frequently use DAT UVa (Newspaper) 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 16

17 Data structures without builtin libraries Here comes the hard part. 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 18

18 Range minimum query Range Minimum Query (RMQ) is used on arrays to find the position of an element with the minimum value between two specified indices. Given an array AA[00, NN 11] find the position of the element with the minimum value between two given indices. RMQ AA 2,7 = 3 A[0] A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9] /2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 19

19 Range minimum query Suppose that an algorithm has preprocessing time ff(nn) and query time gg(nn). The notation for the overall complexity for the algorithm is < ff(nn), gg(nn) >. We will note the position of the element with the minimum value in some array AA between indices ii and jj with RMQ AA (ii, jj). 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 20

20 Trivial algorithms for RMQ For every pair of indices (ii, jj) store the value of RMQ AA (ii, jj) in a table MM[00, NN 11][00, NN 11]. Trivial computation will lead us to an < OO(NN 33 ), OO(11) > complexity. However, by using an easy dynamic programming approach we can reduce the complexity to < OO(NN 22 ), OO(11) >. 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 21

21 Trivial algorithms for RMQ The preprocessing function will look something like this: void process1(int M[MAXN][MAXN], int A[MAXN], int N) { int i, j; for(i =0; i < N; i++) M[i][i] = i; for(i = 0; i < N; i++) for(j = i + 1; j < N; j++) if(a[m[i][j - 1]] < A[j]) M[i][j] = M[i][j - 1]; else M[i][j] = j; } This trivial algorithm is quite slow and uses OO NN 2 memory, so it won t work for large cases. 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 22

22 Better algorithms for RMQ An interesting idea is to split the vector in NN pieces. We will keep in a vector MM[00, NN 11] the position for the minimum value for each section. MM can be easily preprocessed in OO(NN). Here is an example: RMQ AA 2,7 = 3 A[0] A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9] MM 0 = 0 MM 1 = 3 MM 2 = 8 MM 3 =9 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 23

23 Better algorithms for RMQ The idea is to get the overall minimum from the sqrt(nn) sections that lie inside the interval, and from the end and the beginning of the first and the last sections that intersect the bounds of the interval. To get RMQ AA (22, 77) in the above example we should compare AA[22], AA[MM[11]], AA[66] and AA[77] and get the position of the minimum value. It s easy to see that this algorithm doesn t make more than 33 NN operations per query. The main advantages of this approach are that is to quick to code. You can adapt it to the dynamic version of the problem (where you can change the elements of the array between queries). 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 24

24 Sparse table (ST) algorithm for RMQ A better approach is to preprocess RMQ for sub arrays of length 22 kk using dynamic programming. We will keep an array MM[00, NN 11][00, log NN] where MM[ii][jj] is the index of the minimum value in the sub array starting at ii having length 22 jj. Here is an example A[0] A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9] MM 1 [0] = 1 MM 1 [1] = 2 MM 1 [2] = 3 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 25

25 Sparse table (ST) algorithm for RMQ For computing MM[ii][jj] we must search for the minimum value in the first and second half of the interval. It s obvious that the small pieces have 22 jj 11 length, so the recurrence is: MM ii jj = MM ii jj 1, AA MM ii jj 1 AA[MM ii + 2jj 1 1 jj 1 ] MM ii + 2 jj 1 1 jj 1, otherwise 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 26

26 Code void process2(int M[MAXN][LOGMAXN], int A[MAXN], int N) { int i, j; } //initialize M for the intervals with length 1 for(i = 0; i < N; i++) M[i][0] = i; //compute values from smaller to bigger intervals for(j = 1; 1 << j <= N; j++) for(i = 0; i + (1 << j) - 1 < N; i++) if(a[m[i][j - 1]] < A[M[i + (1 << (j - 1))][j - 1]]) M[i][j] = M[i][j - 1]; else M[i][j] = M[i + (1 << (j - 1))][j - 1]; 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 27

27 Usage Once we have these values preprocessed, let s show how we can use them to calculate RMQ AA (ii, jj). The idea is to select two blocks that entirely cover the interval [ii.. jj] and find the minimum between them. Let kk = [log(jj ii + 11)]. For computing RMQ AA (ii, jj) we can use the following formula: RMQ AA = MM ii kk, AA MM ii kk AA[MM jj 2kk + 1 ll ] MM jj 2 kk + 1 kk, otherwise So, the overall complexity of the algorithm is < OO(NN log NN), OO(11) >. 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 28

28 Segment trees for RMQ For solving the RMQ problem we can also use segment trees. A segment tree is a heap-like data structure that can be used for making update/query operations upon array intervals in logarithmical time. We define the segment tree for the interval [ii, jj] in the following recursive manner: The first node will hold the information for the interval ii, jj. If ii < jj the left and right son will hold the information for the intervals [ii, (ii + jj)/22] and [(ii + jj)/ , jj]. 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 29

29 Segment trees for RMQ The height of a segment tree for an interval with NN elements is [log NN] Here is how a segment tree for the interval [00, 99] would look like: 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 30

30 Segment trees for RMQ The segment tree has the same structure as a heap, so if we have a node numbered xx that is not a leaf: Left son of xx is Right son of xx is For solving the RMQ problem using segment trees we should use an array MM[11, log nn +11 ] where MM[ii] holds the minimum value position in the interval assigned to node ii. At the beginning all elements in MM should be 11. The tree should be initialized with the following function (bb and ee are the bounds of the current interval): 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 31

31 Code void initialize(intnode, int b, int e, int M[MAXIND], int A[MAXN], int N) { if(b == e) M[node] = b; else { //compute the values in the left and right subtrees initialize(2 * node, b, (b + e) / 2, M, A, N); initialize(2 * node + 1, (b + e) / 2 + 1, e, M, A, N); //search for the minimum value in the first and //second half of the interval if(a[m[2 * node]] <= A[M[2 * node + 1]]) M[node] = M[2 * node]; else M[node] = M[2 * node + 1]; } } 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 32

32 Segment trees for RMQ The function above reflects the way the tree is constructed. When calculating the minimum position for some interval we should look at the values of the sons. You should call the function with node = 1, b = 0 and e = N-1. We can now start making queries. If we want to find the position of the minimum value in some interval [ii, jj] we should use the next easy function: 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 33

33 Code int query(int node, int b, int e, int M[MAXIND], int A[MAXN], int i, int j) { int p1, p2; //if the current interval doesn't intersect //the query interval return -1 if(i > e j < b) return -1; //if the current interval is included in //the query interval return M[node] if(b >= i && e <= j) return M[node]; //compute the minimum position in the //left and right part of the interval p1 = query(2 * node, b, (b + e) / 2, M, A, i, j); p2 = query(2 * node + 1, (b + e) / 2 + 1, e, M, A, i, j); } //return the position where the overall //minimum is if(p1 == -1) return M[node] = p2; if(p2 == -1) return M[node] = p1; if(a[p1] <= A[p2]) return M[node] = p1; return M[node] = p2; 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 34

34 Please survey LCA Lowest Common Ancestor (LCA): Given a rooted tree T and two nodes u and v, find the furthest node from the root that is an ancestor for both u and v. Here is an example (the root of the tree will be node 1 for all examples in this editorial): 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 36

35 Fenwick tree Basics The problem: Suppose there are NN boxes labeled from 1 to NN. We can add(x) marbles to the ii th box. box(i) now has a frequency xx. We want to know the total number of marbles from box(1) to box(n). 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 37

36 First analysis Operation complexities: void create(int n); O(N) void update(int idx, int val); O(log N) int freqto(int idx); O(log N) int freqat(int idx); O(log N) 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 38

37 Storage complexity Data An int array of size NN. 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 39

38 Fenwick trees How it works? Each element in the array stores cumulative frequency of consecutive list of boxes. Range of boxes that is stored is related to binary value of the index. 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 40

39 Definitions ff(xx) = number of marble in box xx. cc(xx) = summation of number of marble in box 1 to box xx. cc xx = xx ii=1 ff(ii) tree[xx] = element xx in the array. 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 41

40 Storage solution tree 16 = ff 1 + ff ff(16) tree 12 = ff 9 + ff 10 + ff 11 + ff(12) tree 6 = ff 5 + ff(6) tree 3 = ff(3) 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 42

41 Cumulative frequency f(16) = 2 Actual frequency tree[16] = 29 Cumulative frequency From 1 to 16 Index of the array tree[14] Cumulative frequency From 13 to 14 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 43

42 The last 1 A node at the index XX will store frequency of boxes in the range of XX 2 rr + 1 to XX. Where rr is the position of the last digit of 1 (in binary mode). Example: XX = 12 (1100) 2 Node will store frequency from 9 to 12 The last 1 of 12 is at position 2 (0-indexed) = 9 = (1001) 2 10/2/2016 PROGRAMMING IN C 44

43 Reading cumulative frequency c(13) = tree[13] + tree[12] + tree[8] In base-2: c( ) = tree[ ] +tree[ ] + tree[ ] 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 45

44 Updating frequency Update ff(5) by -1 involve: Tree[5] ( ) Tree[6] ( ) Tree[8] ( ) Tree[16] ( ) 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 46

45 Reading actual frequency What is ff(12)? Easy, it s cc(12) cc(11). Easier way: Tree[12] = ff(9) + ff(10) + ff(11) + ff(12) Tree[11] = ff(11) Tree[10] = ff(9) + ff(10) Hence: ff(12) = Tree[12] Tree[11] Tree[10] 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 47

46 Two s compliment A method to represent negative numbers. A two s compliment of XX is (compliment of XX) s Compliment of 7 is Finding the last 1 xx = aaaaa bb = consecutive of 0 XX = 4 = 0100 aa = 0 bb = /2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 48

47 Two s compliment xx = (aaaaa) + 1 = aa 0bb + 1 = aa 0(0 0) + 1 = aa 0(1 1) + 1 = aa 1(0 0) = aa 1bb So, if we & xx and xx: aa 1bb & aaaaa. We got the last /2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 49

48 Code int freqto(int idx) { int sum = 0; while (idx > 0) { sum += tree[idx]; idx -= (idx & -idx); } return sum; } void update(int idx,int val) { while (idx <= MaxVal) { tree[idx] += val; idx += (idx & -idx); } } 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 50

49 Code int freqat(int idx){ int sum = tree[idx]; if (idx > 0) { int z = idx - (idx & -idx); y = idx - 1; while (y!= z){ sum -= tree[y]; y -= (y & -y); } } return sum; } 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 51

50 Extension 2D bits? 10/2/2016 INTRODUCTION TO COMPETITIVE PROGRAMMING 53