Contest programming. Linear data structures. Maksym Planeta

Transcription

1 Contest programming Linear data structures Maksym Planeta /2

2 Table of Contents Organisation Linear Data Structures Long arithmetic Practice 2/2

3 Update on organisation 11 weeks 9 exercises: Introduction lectures + exercises A practice session Contest on June, 16th After Lange Nacht der Wissenschaft /2

4 Updated outline 1. Introduction 2. Linear data structures. Long arithmetic.. Greedy and Divide and conquer algorithms. Dynamic programming. 4. Algorithms on string. Sorting and searching. 5. Computational geometry. Floating point arithmetic. 6. Mathematical and combinatorial problems.. Algorithms on graphs 8. Algorithms on graphs 9. Practice session 10. Contest 4/2

5 Updated outline 1. Introduction 2. Linear data structures. Long arithmetic.. Greedy and Divide and conquer algorithms. Dynamic programming. 4. Algorithms on string. Sorting and searching. 5. Computational geometry. Floating point arithmetic. 6. Mathematical and combinatorial problems.. Algorithms on graphs 8. Algorithms on graphs 9. Practice session 10. Contest 4/2

6 Linear data structures std :: vector<int> std :: vector<bool> int array [4] std :: array<int, 4> std :: bitset <444> 5/2

7 Searching std :: lower_bound std :: upper_bound std :: binary_search std :: find std :: max_element std :: min_element 6/2

8 Sorting std :: sort std :: partial_sort std :: stable_sort /2

9 Permutations std :: next_permutation std :: prev_permutation 8/2

10 Jolly Jumpers Problem Statement A sequence of n > 0 integers is called a jolly jumper if the absolute values of the difference between successive elements take on all the values 1 through n 1. For instance, is a jolly jumper, because the absolutes differences are, 2, and 1 respectively. The definition implies that any sequence of a single integer is a jolly jumper. You are to write a program to determine whether or not each of a number of sequences is a jolly jumper. 9/2

11 Jolly Jumpers (contd.) Input Each line of input contains an integer n 000 followed by n integers representing the sequence. Output For each line of input, generate a line of output saying Jolly or Not jolly. Sample Input Sample Output Jolly Not Jolly 10/2

12 Jolly Jumpers (Solution) #i n c l u d e < b i t s / s t d c ++.h> using namespace s t d ; #d e f i n e N 000 i n t j o l l y [N ] ; i n t main ( ) { i n t n, a, b ; } w h i l e ( s c a n f ( "%d %d ", &n, &a ) > 0) { // Body f o l l o w s } 11/2

13 Jolly Jumpers (Solution) // The body f i l l ( j o l l y, j o l l y + N, 0 ) ; f o r ( i n t i = 1 ; i < n ; i ++, a = b ) { s c a n f ( "%d ", &b ) ; j o l l y [ abs ( a b )]++; } auto f = f i n d _ i f ( j o l l y +1, j o l l y + n, [ ] ( i n t count ) { r e t u r n count!= 1 ; } ) i f ( n == 1 f == ( j o l l y + n ) ) { cout << " J o l l y \n" ; } e l s e { cout << " Not j o l l y \n " ; } 12/2

14 Linear data structures N-dimensional arrays Vector of vectors of vectors... 1D-vector with proper indexing Row major Column major Heaps Trees Queues 1/2

15 Disjoint Sets Set of sets Sets may change Find which set an item belongs to Merge sets efficiently 14/2

16 Disjoint Sets: Operations Make-Set(x) Creates a set with a single element x Union(x, y) Unite sets with elements x and y Find-Set(x) Return a representative element of the set containing x 15/2

17 Disjoint Sets: Connected components Connected-Components(G) 1 for each vertex v G.V 2 Make-Set(v) for each edge (u, v) G.E 4 if Find-Set(u) Find-Set(v) 5 Union(u, v) Same-Components(G) 1 if Find-Set(u) == Find-Set(v) 2 return True else return False 16/2

18 Disjoint Sets: Implementation Make-Set(x) 1 x.p = x 2 x.rank = 0 Union(x, y) 1 Link(Find-Set(x), Find-Set(y)) Link(x, y) 1 if x.rank > y.rank 2 y.p = x else x.p = y 4 if x.rank == y.rank 5 y.rank = y.rank + 1 Find-Set(x) 1 if x x.p 2 x.p = Find-Set(x.p) return x.p 1/2

19 Range Minimum Queries Given an array a 0... a n Find a minimum value in range [i, j] Trivial algorithm complexity O(n) With m queries the complexity is O(mn) Possible complexity: O(n + m log n) 18/2

20 Segment Tree Build a tree with O(2n) nodes [0, ] [0, ] [4, ] [0, 1] [2, ] [4, 5] [6, ] [0, 0] [1, 1] [2, 2] [, ] [4, 4] [5, 5] [6, 6] [, ] Figure: Segment Tree 19/2

21 Segment Tree: Structure Mark a parent for each node Figure: Segment Tree 20/2

22 Segment Tree: Query Execute a query RMQ(, 6) Figure: Segment Tree 21/2

23 Segment Tree: Query Execute a query RMQ(, 6) Figure: Segment Tree 21/2

24 Segment Tree: Query Execute a query RMQ(, 6) Figure: Segment Tree 21/2

25 Segment Tree: Query Execute a query RMQ(, 6) Figure: Segment Tree 21/2

26 Segment Tree: Query Execute a query RMQ(, 6) Figure: Segment Tree 21/2

27 Segment Tree: Query Execute a query RMQ(, 6) Figure: Segment Tree 21/2

28 Segment Tree: Query Execute a query RMQ(, 6) Figure: Segment Tree 21/2

29 Segment Tree: Query Execute a query RMQ(, 6) Figure: Segment Tree 21/2

30 Segment Tree: Query Execute a query RMQ(, 6) Figure: Segment Tree 21/2

31 Segment Tree: Building Build-Segments(p, L, R) 1 if L == R 2 tree[p] = L else Build-Segments(Left(p), L, L+R 4 Build-Segments(Right(p), L+R 2 5 p 1 = tree[left(p)] 6 p 2 = tree[right(p)] if value[p 1 ] value[p 2 ] 8 tree[p] = p 1 9 else tree[p] = p 2 2 ) + 1, R) 22/2

32 Segment Tree: Querying Range-Min-Query(p, L, R, i, j) 1 if i > R or j < L 2 return nil if L i and R j 4 return tree[p] 5 p 1 = Range-Min-Query(Left(p), L, (L + R)/2, i, j) 6 p 2 = Range-Min-Query(Right(p), (L + R)/2 + 1, R, i, j) if p 1 == nil 8 return p 2 9 if p 2 == nil 10 return p 1 11 if value[p 1 ] value[p 2 ] 12 return p 1 1 else return p 2 2/2

33 Long arithmetic java. math.biginteger add subtract pow modpow multiply divide 24/2

34 Practice Solve following set of problems in a group: Mapmaker Searching Quickly ID Codes Friends Very Easy!!! Ferry Loading IV Frequent Values Ahoy, Pirates Who Said Crisis? Easy Problem from Rujia Liu? 25/2

35 Home reading Cormen. 1. Recommended Section 4 (intro) Section Optional Section 21 (intro) Section /2

36 Literature Thomas H Cormen. Introduction to algorithms. MIT press, Steven Halim and Felix Halim. Competitive Programming. Lulu Independent Publish, /2