BITTIGER #11. Oct

Transcription

1 BITTIGER #11 Oct

2 PROBLEM LIST A. Five in a Row brute force, implementation B. Building Heap data structures, divide and conquer C. Guess Number with Lower or Higher Hints dynamic programming, mathematics

3 FIVE IN A ROW 2 Players Take turns to place pieces(1 piece a time) Who forms 5 pieces as a line win The line could be horizontal, vertical or diagonal

4 FIVE IN A ROW Horizontal line of 3 white pieces Diagonal line of 4 black pieces Vertical line of 4 black pieces

5 DESCRIPTION Problem: For a given board, judge who had complete a continuously line of 5 pieces Input: A 15*15 chess board. as empty, B as Black piece, W as White piece Output: None - no player complete the task White - only white player complete the task Black - only black player complete the task Both both players complete the task

6 HUMAN S WAY OF THINKING Enumerate all possible line of length 5 Check whether it s black or white Horizontal / Vertical / Diagonal

7 BRUTE FORCE Enumerate each line Enumerate each start position Enumerate each direction Enumerate next 5 positions All pieces? Same color?

8 POSITIONS Consider a position as (x, y) The x-th row, y-th column y for x = for y = { } x

9 DIRECTIONS 8 directions Half are useless Since reverse direction are same Only need 4 directions (0, 1) as right (1, -1) as lower-left (1, 1) as lower-right (1, 0) as down

10 DIRECTIONS Use a direction array to represents all direction d 0 = 0,1 as right, d 1 = 1,1 as right down d 2 = 1,0 as down, d 2 = 1, 1 as lower left dx 4 = 0,1,1,1, dy 4 = 1,1,0, 1, d k = dx k, dy k (0, 1) as right (1, -1) as lower-left (1, 1) as lower-right (1, 0) as down

11 PIECES x, y We have x, y as start position We have (dx[k], dy[k]) as direction What s the position of rest pieces? x + dx k 1, y + dy k 1 (x + dx k 2, y + dy k 2) (x + dx k 3, y + dy k 3) (x + dx k 4, y + dy k 4) (dx[k], dy[k]) = x + dx k i, y + dy k i, 1 i 4 Positions of this line x + dx k i, y + dy k i, 0 i 4

12 JUDGE x + dx k i, y + dy k i, 0 i 4 All B exists at least 1 B solution (AnsB true) All W exists at least 1 W solution (AnsW true) Answer AnsB & AnsW: Both AnsB &! AnsW: Black! AnsB & AnsW: White! AnsB &! AnsW: None

13 BRUTE FORCE Algorithm: Step 1: Enumerate each start position as x, y, 1 x 15, 1 y 15 Step 2: Enumerate each direction as dx k, dy k, 1 k 4 Step 3: Enumerate each positions as x + dx k i, y + dy k i, 0 i 4 Step 4: Update AnsW, AnsB by check these positions Step 5: Output answer according to AnsW, AnsB Time Complexity: O n S, n = 15 Solve 100% of the data

14 CODE bool answ = false, ansb = false; for i=1~n for j=1~n for k=0~3 { int countb=0,countw=0; for l=0~4 { int x=i+dx[k] l; int y=j+dx[k] l; if (!valid(x, y)) conitnue; if (position(x,y)== W ) countw++; if (position(x,y)== B ) countb++; } if (countw==5) answ=true; if (countb==5) ansb=true; }

15 M IN A ROW Problem: For a given board, judge who had complete a continuously line of m pieces Input: m the length required of the line A n*n chess board. as empty, B as Black piece, W as White piece Output: None - no player complete the task White - only white player complete the task Black - only black player complete the task Both both players complete the task

16 STILL BRUTE FORCE? Algorithm Step 1: Enumerate each start position as x, y, 1 x n, 1 y n Step 2: Enumerate each direction as dx k, dy k, 1 k 4 Step 3: Enumerate each positions as x + dx k i, y + dy k i, 0 i < m Step 4: Update AnsW, AnsB by check these positions Step 5: Output answer according to AnsW, AnsB Time Complexity: O n S m Better solution?

17 M IN A ROW Black x, y number of black pieces start from(x, y) Black x, y = min Black x, y + 1, 4 + isblack x, y White x, y = min White x, y + 1, 4 + iswhite x, y

18 M IN A ROW Algorithm Step 1: Enumerate each directions Step 2: Enumerate each start positions in order (x=n~1,y=n~1) Step 3: Calculate Black(x, y) and White x, y Black x, y = min Black x, y + 1, 4 + isblack x, y White x, y = min White x, y + 1, 4 + iswhite x, y Step 4: Same as brute force Time Complexity: O n S

19 QUESTION TIME

20 BUILDING HEAP Min Heap Binary Tree Value of a node is smaller than its children Also smaller than all its descendants In-order Traversal Left subtree Root Right subtree Pre-order Traversal Root Left subtree Right subtree

21 DESCRIPTION Problem: Given a Min Heap s in-order traversal Reconstruct this heap Output its preorder traversal Input: An array of N numbers, represents the in-order traversal of a Min Heap Like Output: An array of N numbers, represents the pre-order traversal of the input Min Heap Like

22 HOW TO? What can we get from this array? 1 Heap: Value of a node is smaller than its children Root has the smallest value That is, the value of the root is 1, Otherwise, there is no node can be 1 s parent. So, at least we find the root.

23 THEN? In-order traversal left subtree root right subtree root Left subtree Right subtree left subtree right subtree Build heap by in-order 768, as 1 s left-subtree Build heap by in-order 3 11, as 1 s right-subtree

24 DIVIDE & CONQUER We divide a bigger problem Into 2 smaller problems and 3 11 Solve each smaller problems Then use results of the smaller problems to generate result of the bigger problem

25 DIVIDE & CONQUER Algorithm: Step 1: Find the smallest number in in-order traversal, as the root Left part of the in-order traversal, as in-order traversal of the left-subtree Right part of the in-order traversal, as in-order traversal of the right-subtree Step 2: Construct left-subtree and right-subtree by recursion Step 3: Use root, left-subtree and right-subtree to generate answer left subtree root right subtree

26 DIVIDE & CONQUER Time Complexity: Each node: find the minimum number Each level: O(N) Number of Levels: Average: O(logN) Worst: O(N) Total complexity: Average: O(NlogN) Worst: O(N S )

27 CODE TreeNode divide array a { TreeNode root i a i < a j, 1 j a. size; root value = a i ; root lchild = divide a 1.. i 1 ; root rchild = divide a i a. size ; return root; } void preorder TreeNode root { print root value; preorder root lchild ; preorder root rchild ; }

28 NO TREE? How to avoid build this tree? TreeNode divide array a { TreeNode root i a i < a j, 1 j a. size; root value = a i ; void solve array a { i a i < a j, 1 j a. size; print a i ; solve a 1.. i 1 ; solve a i a. size ; return root; } } root lchild = divide a 1.. i 1 ; root rchild = divide a i a. size ; return root; void preorder TreeNode root { print root value; preorder root lchild ; preorder root rchild ; }

29 DIVIDE & CONQUER + RMQ Use RMQ to pre-calculate some data Reduce complexity of minimum to O(1) Complexity of RMQ is O(NlogN) Total complexity: Average: O(NlogN) Worst: O(NlogN)

30 QUESTION TIME

31 GUESS NUMBER WITH LOWER OR HIGHER HINTS Two players Alice and Bob Alice needs to guess a number n From range [1, N], N 200 In i-th turn Alice guess a number n d Bob choose to tell the relation of n and n d n < n e, n = n e, n > n e Bob can tell what he want, unless it conflicts what he says before Each turn cost n d Alice wants to minimum the total costs Bob wants to maximum the total costs What s the minimum costs? If both players take the best strategy.

32 EXAMPLES N=1 No need to guess Minimum cost is 0 N=2 Alice guess 1 Bob says n=1, no more cost Bob says n>1, only 2 remains, no more cost Whatever Bob says, further cost is 0 Final cost is 1+0=1 Alice guess 2 Bob says n=2, no more cost Bob says n<2, only 1 remains, no more cost Whatever Bob says, further cost is 0 Final cost is 2+0=2 Minimum cost is 1

33 EXAMPLES N=3 Alice guess 1 Bob says n=1, no more cost Bob says n>1, 2 3 remains, further costs is 2 Bob would says n>1 to maximum Alice s cost to 2 Total cost is 1+2=3 Alice guess 2 Bob says n=2, no more cost Bob says n<2, only 1 remains, no more cost Bob says n>2, only 3 remains, no more cost Whatever Bob says, further cost is 0 Total cost is 2+0=2 Alice guess 3 Bob says n=3, no more cost Bob says n<3, 1 2 remains, further costs is 1 Bob would says n<3 to maximum Alice s cost to 1 Total cost is 3+1=4 Minimum cost is 2

34 STRATEGY TREE Algorithm: Step 1: Start from the initial state Step 2: Enumerate Alice s strategy Step 3: Enumerate Bob s strategy Step 4: Transfer to new state using players strategies Step 5: Calculate value of new state by recursion Step 6: Calculate value of initial state by value of new state Initial State minimum maximum New state New state

35 STRATEGY TREE Initial state [1,3] Alice s strategy guess 1 guess 2 guess 3 1[2,3] [1]2[3] [1,2]3 Bob s strategy n=1 n>1 n<2 n=2 n>2 n<3 n=3 [1] [2,3] [1] [2] [3] [1,2] [3] Alice s strategy guess 2 guess 3 guess 1 guess 2 2[3] [2]3 Bob s strategy n=2 n>2 n<3 n=3 [2] [3] [2] [3] 1[2] [1]2 n=1 n>1 n<2 n=2 [1] [2] [1] [2]

36 STRATEGY TREE How to calculate each node s value? Initial state [1,3] guess 1 guess 2 guess 3 1[2,3] [1]2[3] [1,2]3 n=1 n>1 n<2 n=2 n>2 n<3 n=3 [1] [2,3] [1] [2] [3] [1,2] [3] guess 2 guess 3 guess 1 guess 2 2[3] [2]3 n=2 n>2 n<3 n=3 [2] [3] [2] [3] 1[2] [1]2 n=1 n>1 n<2 n=2 [1] [2] [1] [2]

37 STRATEGY TREE All leaf node s value is 0 [1,3] guess 1 guess 2 guess 3 1[2,3] [1]2[3] [1,2]3 0 [2,3] [1,2] 0 guess 2 guess 3 guess 1 guess 2 2[3] [2]3 1[2] [1]

38 STRATEGY TREE From bottom to top Bob will choose the maximum value [1,3] guess 1 guess 2 guess 3 1[2,3] [1]2[3] [1,2]3 0 [2,3] [1,2] 0 guess 2 guess 3 guess 1 guess Bob s strategy

39 STRATEGY TREE From bottom to top Alice will choose the minimum value [1,3] guess 1 guess 2 guess 3 1[2,3] [1]2[3] [1,2] Alice s strategy cost 2 cost 1 cost 3 cost

40 STRATEGY TREE [1,3] guess 1 guess 2 guess Bob s strategy cost 2 cost 3 cost 1 cost

41 STRATEGY TREE 2 Alice s strategy cost 1 cost 2 cost The value of the first state is 2(The Answer) cost 2 cost cost 1 cost

42 STRATEGY TREE Algorithm: Step 1: Start from the initial state Step 2: Enumerate Alice s strategy Step 3: Enumerate Bob s strategy Step 4: Transfer to new state using players strategies Step 5: Calculate value of new state by recursion Step 6: Calculate value of initial state by value of new state Initial State minimum maximum New state New state Time Complexity:O(N g ) Can t solve all of the data

43 CODE EXAMPLE int CalcState(int l, int r) { if (l >=r) return 0; int ansa = ; for k = l ~ r { // Alice s guess int ansb = 0; // n=k ansb = max(ansb, CalcState(l, k-1)); // n<k ansb = max(ansb, CalcState(k+1, l)); // n>k ansa = min(ansa, ansb + k); } return ansa; }

44 REDUNDANCY [1,5] When calculate state [1, 5] 1, 5 1, 4 2, 4 1, 5 2, 5 2, 4 2, 4 were calculated multiple times Memorized Search When calculate the strategy tree If a state is already calculated, skip the recursion and return the value calculated before [1,4] [2,5] [1,3] [2,4] [2,5] A lot of calculation

45 CODE EXAMPLE int CalcState(int l, int r) { if (l >=r) return 0; if (mem[l, r]!= -1) return mem[l, r]; int ansa = ; for k = l ~ r { // Alice s guess int ansb = 0; // n=k ansb = max(ansb, CalcState(l, k-1)); // n<k ansb = max(ansb, CalcState(k+1, l)); // n>k ansa = min(ansa, ansb + k); } mem[l, r] = ansa; return ansa; }

46 REORDER CALCULATION We will calculate all mem l, r, 1 l r N Why not calculate them in specific order So when calculate a state mem[l, r] All the state that it will use were already calculated mem l h, r h, l l h r h r Such an order can be describe as for l = N ~ 1 for r = l ~ N This is a very useful trick in real programming

47 CODE EXAMPLE for l = N ~ 1 for r = l ~ N { mem[l, r] = ; for k = l ~ r { int s = 0; s = max(s, mem[l, k-1]); s = max(s, mem[k+1, l]); mem[l, r] = min(mem[l, r], s + k); } }

48 DYNAMIC PROGRAMMING By the way, we can call this Dynamic Programming f l, r = min {max f l, k 1, f k + 1, r + k l k r} Time Complexity: O N l Solve all of the data

49 MORE? Mathematic trick f l, r = min {max f l, k 1, f k + 1, r + k l k r} f(l, k 1) f(k + 1, r) max f l, k 1, f k + 1, r k k m

50 MORE? f l, r = min {max f l, k 1, f k + 1, r + k l k r} = min (min max f l, k 1, f k + 1, r + k l k k m,, min {max f l, k 1, f k + 1, r + k k m < k r}) = min (min f k + 1, r + k l k k m, min f l, k 1 + k k m < k r}) = min (min f k + 1, r + k l k k m, f l, k m 1 + k m )

51 QUESTION TIME

52 THANKS FOR LISTENING