程序代写代做代考 C go AI algorithm game Algorithms Tutorial 4 Solutions

Solution: List out the cities on the northern side by index from left to right sorted by x-coordinate. (For example, {1, 4, 6, 8, 2, …} would indicate that city 1 has lowest x-coordinate, city 4 has second lowest x-coordinate, etc.) Do the same for the southern side, to obtain another sequence. Observe that making the maximum possible bridge connections that don’t cross each other is equivalent to finding the longest common subsequence in both sequences (i.e. a maximal subsequence of cities which appear in the same order). Two cities are considered matching if you can build a bridge between them, and not matching otherwise. The complexity is O(n log n) to sort the coordinates, and O(n2) to do longest common subsequence, giving the overall complexity of O(n2).
Another way of doing it is to sort the cities on the south bank according to their x coordinates and then re-enumerate them so that they appear as {1, 2, 3, . . .}, and then apply the same permutation to the cities on the north bank. Now the problem reduces to finding a maximal increasing sequence of indices of cities on the north bank.
5. You are given a boolean expression consisting of a string of the symbols true and false and with exactly one operation and, or, xor between any two consecutive truth values. Count the number of ways to place brackets in the expression such that it will evaluate to true. For example, there is only 1 way to place parentheses in the expression true and false xor true such that it evaluates to true.
Solution: Let there be n symbols, and n − 1 operations between them. We solve the following two subproblems: How many ways are there to make the expression starting from at the lth symbol and ending at rth symbol evaluate to true (T), and how many ways to do the same but evaluate to false (F)? For example in “true and false xor true”, T(1,2) would be the number of ways of making “true and false” evaluate to true with correct bracketting (in this case, T(1, 2) = 0).
The base case is that T(i, i) is 1 if symbol i is true, and 0 if symbol i is false. The reverse applies to F(i, i).
Otherwise, for each subproblem, we ‘split’ the expression around an operator m so that everything to the left of the operator is in its own bracket, and everything to the right of the operator is in its own bracket to form two smaller expressions. For example, splitting the sample expression around “xor” would give “(true and false) xor (true)”. We then evaluate the subproblems on each
3

of the two sides, and combine the results together depending on the type of operator we are splitting by, and whether we want the result to evaluate to true or false. We solve both subproblems in parallel:
r−1
T(l, r) = 􏰁 TSplit(l, m, r)
m=l r−1
F(l, r) = 􏰁 FSplit(l, m, r) m=l
T(l,m)×T(m+1,r)


 if operator m is ‘and’,
T(l,m)×F(m+1,r)+T(l,m)×T(m+1,r)+F(l,m)×T(m+1,r)
TSplit(l, m, r) = 
FSplit(l, m, r) = 
if operator m is ‘or’, T(l,m)×F(m+1,r)+F(l,m)×T(m+1,r)
 
if operator m is ‘xor’.
T(l,m)×F(m+1,r)+F(l,m)×F(m+1,r)+F(l,m)×T(m+1,r)


 if operator m is ‘and’,
F(l,m)×F(m+1,r)
if operator m is ‘or’, T(l,m)×T(m+1,r)+F(l,m)×F(m+1,r)
 
if operator m is ‘xor’.
Note that the equations inside the TSplit and FSplit functions are chosen to
correspond with the truth tables of the corresponding operator.
The complexity is O(n3). There are n2 different ranges that l and r could cover, and each needs the evaluations of TSplit or FSplit at up to n different splitting points.
6. A company is organising a party for its employees. The organisers of the party want it to be a fun party, and so have assigned a fun rating to every employee. The employees are organised into a strict hierarchy, i.e. a tree rooted at the president. There is one restriction, though, on the guest list to the party: an employee and their immediate supervisor (parent in the tree) cannot both attend the party (because that would be no fun at all). Give an algorithm that
4

makes a guest list for the party that maximises the sum of the fun ratings of the guests.
Solution: Let us denote by T(i) the subtree of the tree T of all employees which is rooted at an employee i. For each such subtree we will compute two quantities, I (i) and E (i). I (i) is the maximal sum of fun factors fun(i) of employees selected from subtree T(i) which satisfies the constraint and which must include the root i. E(i) is the maximal sum of fun factors of employees selected from the subtree T (i) but which does NOT include i. These two quan- tities are easily computed by recursion on subtrees, starting from the leaves. For every employee i whose subordinates are j1, . . . , jm we have
I(i) = fun(i) + 􏰁 E(jm) 1≤k≤m
E(i) = 􏰁 max(E(jm), I(jm)) 1≤k≤m
Notice that in the definition of E(i) we have the option to either include the children of i or exclude them, whatever produces larger value of E(i). The final answer is max(I(n),E(n)) where n is the root of the corporate tree T.. Clearly such algorithm runs in time linear in the number of all employees.
7. You have n1 items of size s1 and n2 items of size s2. You would like to pack all of these items into bins, each of capacity C, using as few bins as possible.
Solution: We will solve subproblems P(i,j) of packing i many items of size s1 andjmanyitemsofsizes2 forall1≤i≤n1 andall1≤j≤n2. Let C/s1 = K. The recursion step is essentially an exhaustive search:
opt(i,j)=1+ min opt(i−k,j−⌊(C−ks1)/s2⌋) 0≤k≤K
Thus, we try all options of placing between 0 and K many items of size s1 into one single box and then fill the box to capacity with items of size s2, and opti- mally packing the remaining items. The algorithm runs in time O(K n1 n2) = O(C n1 n2). Thus, such an algorithm runs in exponential time in the size of the input, because input takes only O(log2 C + log2 n1 + log2 n2 + log2 s1 + log2 s2) many bits to represent.
8. You are given n activities and for each activity i you are given its starting time si, its finishing time fi and the profit pi which you get if you schedule this activity. Only one activity can take place at any time. Your task is to design
5

an algorithm which produces a subset S of those n activities so that no two activities in S overlap and such that the sum of profits of all activities in S is maximised.
Solution: Sort all activities by finishing time fi. We solve the following sub- problems for all i: What is the maximum profit opt(i) we can make if activity i is the last activity we do? Recursion is simple:
opt(i) = max{opt(j) : fj < si} + pi prev(i) = arg max{opt(j) : fj < si} Finally, the solution to the original problem is profit of maxi≤i≤n opt(i) and the sequence of jobs can be obtained starting with m = arg maxi≤i≤n opt(i) and then backtracking via m, prev(m), prev(prev(m)), . . .. 9. Your shipping company has just received N shipping requests (jobs). For each request i, you know it will require ti trucks to complete, paying you di dollars. You have T trucks in total. Out of these N jobs you can take as many as you would like, as long as no more than T trucks are used in total. Devise an efficient algorithm to select jobs which will bring you the largest possible amount of money. Solution: This is just the standard knapsack problem with ti being the size of the ith item, di its value and with T as the capacity of the knapsack. Since each transportation job can be executed only once, it is a knapsack problem with no duplicated items allowed. The complexity is O(NT). 10. Again your shipping company has just received N shipping requests (jobs). This time, for each request i, you know it will require ei employees and ti trucks to complete, paying you di dollars. You have E employees and T trucks in total. Out of these N jobs you can take as many of them as you would like, as long as no more than E employees and T trucks are used in total. Devise an efficient algorithm to select jobs which will bring you the largest possible amount of money. Solution: This is a slight modification of the knapsack problem with two constraints on the total size of all jobs; think of a knapsack which can hold items of total weight not exceeding E units of weight and total volume not exceeding T units of volume, with item i having a weight of ei integer units of weight and ti integer units of volume. For each triplet e ≤ E, t ≤ T,ı ≤ N we solve the following subproblem: choose a sub-collection of items 1 . . . i that 6 fits in a knapsack of capacity e units of weight and t units of volume, which is of largest possible value, putting such a value in a 3D table of size E × T × N where N is the number of items (in this case jobs). These values are obtained using the following recursion: opt(i,e,t)=max{opt(i−1,e,t), opt(i−1,e−ei,t−ti)+di}. The complexity is O(NET) 11. Because of the recent droughts, n proposals have been made to dam the Murray river. The ith proposal asks to place a dam xi meters from the head of the river (i.e., from the source of the river) and requires that there is not another dam within ri metres (upstream or downstream). What is the largest number of dams that can be built? You may assume that xi < xi+1. Solution: We solve this by finding the maximum value among the following subproblems for every i ≤ n: Find the largest possible number of dams that can be built among proposals 1 . . . i, such that the ith dam is built. The base case is opt(1) = 1. The recursion is: opt(i)=1+max{opt(j) : xi−xj >max(ri,rj),jopt(i,j−1) ways(i−1,j)+ways(i,j−1) ifopt(i−1,j)=opt(i,j−1)
The complexity is once again O(n2)
d) This is a very tricky one. The idea is to combine divide and conquer with dynamic programming. Note that to generate optimal scores at a row i you only need the optimal scores of the previous row. You start running the previous algorithm from the top left cell to the middle row ⌊n/2⌋, keeping in memory only the previous row. You now run the algorithm from the bottom right corner until you reach the middle row, always going either up one cell or to the left one cell. Once you reach the middle row you sum up the scores obtained by moving down and to the right from the top left cell and the scores obtained by moving up and to the left from the bottom right cell and you pick the cell C(n/2,m) in that row with the minimal sum. This clearly is the cell on the optimal trajectory. You now store the coordinates of that cell and proceed with the same strategy applied to the top left region for which C(n/2,m) is bottom right cell, and also applied to the bottom right region of the board for which C(n/2,m) is the top left cell. The run time is O(n × n + n × n/2 + n × n/4 + . . .) = O(n × 2n) = O(n2)
13. A palindrome is a sequence of at least two letters which reads equally from left to right and from right to left. Given a sequence of letters, find efficiently its longest subsequence (not necessarily contiguous) which is a palindrome. Thus, we are looking for a longest palindrome which can be obtained by crossing out some of the letters of the initial sequence without permuting the remaining letters.
Solution: Let Si denote the ith letter of the string. Solve the subproblem: What is the longest palindrome within the substring starting at letter i and ending at j. The base case is that opt(i, i) = 1, as a single letter is a palindrome by itself. We solve this using the recursion:
1 2
if i = j,
if i + 1 = j and Si = Sj ,
opt(i,j)= opt(i+1,j−1)+2
max{opt(i, j − 1), opt(i + 1, j)} else
9
ifS =S andi i is:
opt(i,j)=min{opt(i,j−1),opt(i−1,j−1)+|hi −lj|}.
To retrieve the assignment, we start at (i, j) where i = n and j = m. If opt(i − 1, j − 1) + |hi − lj | < opt(i, j − 1) then s(i) = j and we try again at (i − 1,j − 1). Otherwise, we try again at (i, j − 1). If at any point we reach i = j (our base case), we simply assign s(k) = k for all 1 ≤ k ≤ i. The complexity of the initial recursion O(nm). The complexity of retrieving the assignment is O(m), as each time we run the algorithm, j decreases by exactly 1. 12 18. You have to cut a wood stick into several pieces. The most affordable company, Analog Cutting Machinery (ACM), charges money according to the length of the stick being cut. Their cutting saw allows them to make only one cut at a time. It is easy to see that different cutting orders can lead to different prices. For example, consider a stick of length 10 m that has to be cut at 2, 4, and 7 m from one end. There are several choices. One can cut first at 2, then at 4, thenat7. Thisleadstoapriceof10+8+6=24becausethefirststickwas of 10 m, the resulting stick of 8 m, and the last one of 6 m. Another choice couldcutat4,thenat2,thenat7. Thiswouldleadtoapriceof10+4+6 = 20, which is better for us. Your boss demands that you design an algorithm to find the minimum possible cutting cost for any given stick. Solution: Let x(i) be the distance along the stick the ith cutting point is at. Solve the following subproblem: What is the minimum cost of cutting up he stick completely from cutting point i to cutting point j. The base case is opt(i, i + 1) = 0. The recursion is: opt(i, j) = x(j) − x(i) + min{opt(i, k) + opt(k, j) : i < k < j}. The complexity is O(n2), where n is the number of cutting points on the stick. 19. ForbitstringsX=x1...xm,Y =y1...yn andZ=z1...zm+n wesaythatZ is an interleaving of X and Y if it can be obtained by interleaving the bits in X and Y in a way that maintains the left-to-right order of the bits in X and Y. For example if X = 101 and Y = 01 then x1x2y1x3y2 = 10011 is an interleaving of X and Y, whereas 11010 is not. Give an efficient algorithm to determine if Z is an interleaving of X and Y. Solution: Solve the following subproblem: Do the first i bits of X and the first j bits of Y form an interleaving in the first i + j bits of Z? The base case is opt(0,0) = true, and opt(i,j) = false if i < 0 or j < 0. The recursion is: opt(i,j)=(opt(i−1,j)ANDzi+j =xi)OR(opt(i,j−1)ANDzi+j =yj). The complexity is O(nm). 20. Some people think that the bigger an elephant is, the smarter it is. To disprove this you want to analyse a collection of elephants and place as large a subset of elephants as possible into a sequence whose weights are increasing but their IQs are decreasing. Design an algorithm which given the weights and IQs of n 13 elephants, will find a longest sequence of elephants such that their weights are increasing but IQs are decreasing. Solution: Sort the elephants in order of decreasing IQs. The problem now becomes finding the longest increasing subsequence of elephant weights. This can be solved in O(n log(n)). 21. You have been handed responsibility for a business in Texas for the next N days. Initially, you have K illegal workers. At the beginning of each day, you may hire an illegal worker, keep the number of illegal workers the same or fire an illegal worker. At the end of each day, there will be an inspection. The inspector on the ith day will check that you have between li and ri illegal workers (inclusive). If you do not, you will fail the inspection. Design an algorithm that determines the fewest number of inspections you will fail if you hire and fire illegal employees optimally. Solution: Observe that the minimum and maximum illegal workers you could possiblehaveovertheNdaysaremax(K−N,0)andK+N. I.e. Thereare at most 2N + 1 possible values for the number of illegal works you could have at any point. We solve the following subproblem: If I have j illegal workers at the end of day i, what is the minimum number of inspections I have failed? The base case is opt(0, K) = 0, since we start with 0 failed inspections before the first day begins. The recursion is: opt(i−1,j−1) ifj−1≥0,  opt(i, j) = failed(i, j) + min opt(i − 1, j), opt(i − 1, j + 1) Here, failed(i, j) returns 1 if the j falls out of the range of li and ri, and returns 0 otherwise. Note that the first option in the cases corresponds to hiring an illegal worker on the morning of day i, the second corresponds to keeping the same number of illegal workers as on the previous day and the third option corresponds to firing a worker from the previous day. The final answer is equal to min opt(N, j). max(K−N,0)≤j≤K+N The complexity is O(N2), as there are N days, and at most 2N + 1 possible values of illegal worker each day. 22. Given an array of N positive integers, find the number of ways of splitting the array up into contiguous blocks of sum at most K. 14 Solution: Solve the subproblem: What is the number of ways I can split the first i elements into contiguous blocks size K. The base case is opt(0) = 1. The recursion is: opt(i) = 􏰁{opt(j − 1) : 1 ≤ j ≤ i, sum(j, i) ≤ K}, where sum(j, i) is the sum of all numbers from j to i inclusive. The complexity is O(n2), as each subproblem requires a O(n) search. 23. There are N levels to complete in a video game. Completing a level takes you to the next level, however each level has a secret exit that lets you skip to another level later in the game. Determine if there is a path through the game that plays exactly K levels. Solution: The subproblems are: Can I reach the ith level after playing exactly k levels? The base case is opt(0, 0) = true. The recursion is: opt(i, k) = opt(i − 1, k − 1) OR (∃j < i − 1)(opt(j, k − 1) AND link(j, i)) Here link(j, i) is true if and only if level j has a secret exit to level i. The final answer is opt(K,N). The time complexity is O(N2). 24. Given a sequence of n positive or negative integers A1,A2,...An, determine a contiguous subsequence Ai to Aj for which the sum of elements in the subse- quence is maximised. Solution:We solve the subproblem: What is the maximum sum of elements ending with integer i? The base case is opt(0) = 0. The recursion is: opt(i) = Ai + max(0, opt(i − 1). Here, we take the maximum of 0 and opt(i − 1) because we may either choose to add Ai to the previous block, or start a completely new block. To determine the actual block, we may also solve the following recursive function for all i: 􏰅start(i − 1) if opt(i − 1) > 0, start(i)= i ifopt(i−1)≤0
To get the block, we simply find the element i such that opt(i) is maximised. The block with maximum sum is [start(i), i]. The complexity is O(n).
15

25. Consider a row of n coins of values v1,v2,…vn, where n is even. We play a game against an opponent by alternating turns. In each turn, a player selects either the first or last coin from the row, removes it from the row permanently, and receives the value of the coin. Determine the maximum possible amount of money we can definitely win if we move first.
Solution: DP has a very important role in the field of game theory. Let opt(i, j) for i, j two integers such that j−i+1 an even number and 1 ≤ i < j ≤ n denote the maximal amount of money we can definitely win if we play on the subsequence between coins at the position i and position j. Then opt(i,j) satisfies the following recursion opt(i,j) = max{vi+min{opt(i−2,j),opt(i−1,j−1)},vj+min{opt(i−1,j−1),opt(i,j−2)}} The options inside the min functions represent the choice your opponent takes, either to continue taking from the same end as you took or from the oposite end of the sequence. The problems to find opt(i,j) are solved in order of the size of j − i. The complexity is O(n2), because this is how many pairs of i, j we have and each stage of the recursion has only constant number of steps (4 table lookups and 2 additions plus two min and one max operations. 16