### Article catalog

## Greedy Algorithm

Resource allocation, maximizing revenue

Xiaoq's company recently received m tasks, the i task needs xi time to complete, and the difficulty level is yi.

Xiaoq has n machines, the longest working time of each machine is zi, and the machine level is wi.

For a task, it can only be completed by one machine. If the maximum working time of the machine assigned to it is less than the time required by the task, it cannot be completed. If the task is completed, it will gain 200 * xi + 3 * yi.

For a machine, it can only complete one task a day. If its machine level is lower than the task difficulty level assigned to it, it cannot complete.

Xiaoq wants to finish as many tasks as possible today, that is to say, the number of tasks completed is the largest. If there are multiple arrangements, xiaoq also wants to find the one with the most profit. Xiaoq needs you to help him calculate.

Enter a description:

The input includes N + M + 1 lines,

The first input line is two positive integers n and m (1 < = n, m < = 100000), indicating the number of machines and tasks.

Next n lines, each line has two integers zi and wi (0 < zi < 1000, 0 < = wi < = 100), indicating the maximum working time and machine level of each machine.

The next m lines, two integers xi and Yi (0 < xi < 1000, 0 < = Yi < = 100) in each line, indicate the completion time and difficulty level of each task.

Output Description:

Output two integers, representing the maximum number of tasks that can be completed and the revenue obtained.

Example 1

Input:

1 2

100 3

100 2

100 1

output

1 20006

#Greedy algorithm, in order to ensure the maximization of benefits, completes the most time first, so sorts machines and tasks from large to small according to time class node(): def __init__(self,time,level): self.time=time self.level=level #Read the first line of input, number of machines and number of tasks n,m=map(int,input().split()) machines=[] jobs=[] #Read the maximum working time and machine level of each machine for i in range(n): time,level= map(int,input().split(' ')) machine = node(time,level) machines.append(machine) #Read the maximum working time and working level of each task for i in range(m): time,level= map(int,input().split(' ')) job = node(time,level) jobs.append(machine) #Sort by time machines.sort(key=lambda x:(x.time,x.level),reverse=True) jobs.sort(key=lambda x:(x.time,x.level),reverse=True) #Revenue and number of jobs profit=0 count=0 j=0#Until the machine runs out or does not work levels=[0]*101 for i in range(m): #Two restrictions, the serial judgment condition should be used while j<n and machines[j].time>jobs[i].time: #Record machines that meet time conditions levels[machines[j].level]+=1 j+=1 for k in range(jobs[i].level,101): #A machine that judges whether there is a level of satisfaction if(levels[k]): count+=1 levels[k]-=1 profit+=200*jobs[i].time+3*jobs[i].level break print(count, end=' ') print(profit)

## Dictionary order

Dictionary order minimum: from small to large

Dictionary order: from large to small

Link: https://www.nowcoder.com/questionTerminal/21cbcf96d99d42a18e50553df27cd230

Source: niuke.com

One day, Xiaoyi put all the permutations from 1 to n in a dictionary order. Xiaoyi chooses a permutation from it. Suppose it is the Q permutation of positive number. Xiaoyi hopes you can answer what the Q permutation of reciprocal number is.

For example, all permutations from 1 to 3 are:

1 2 3

1 3 2

2 1 3

2 3 1

3 1 2

3 2 1

If Xiaoyi chooses 1 2 3, then Q = 1, and you should output 3 2 1

Enter a description:

The number n in the first row indicates the arrangement length

Next n numbers in a row indicate the selected arrangement

1≤n≤3000001≤n≤3000001 \leq n \leq 3000001≤n≤3000001≤n≤3000001≤n≤300000

Output Description:

A row of n numbers representing the desired arrangement

Example

Input:

3

1 2 3

output

3 2 1

#It can be seen from the analysis that the two permutations of position are relatively symmetric, and the sum of corresponding digits is n+1, so the output can be calculated directly

## Huawei test

1. Divide by a space. Only the year and day of the first group contain the day of the week. Please calculate the day of the year and the day of the second group.

a = input().split('|') begin = list(map(int, a[0].split())) end = list(map(int, a[1].split())) # Count the days and divide by 7 year = end[0] - begin[0] mounth = end[1] - end[1] mounths = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] weeks = [1, 2, 3, 4, 5, 6, 7] day = [0, 0] # Calculate the date separately as the day of this year if ((begin[0] % 4 == 0 and begin[0] % 100 != 0) or begin[0] % 400 == 0): mounths[1] = 29 for i in range(begin[1]-1): day[0] += mounths[i] day[0] += begin[2] # Calculate the days of end in the year if ((end[0] % 4 == 0 and end[0] % 100 != 0) or end[0] % 400 == 0): mounths[1] = 29 else: mounths[1] = 28 for i in range(end[1]-1): day[1] += mounths[i] day[1] += end[2] if year == 0: days = day[1] - day[0] else: days = 0 for i in range(begin[0], end[0]): if ((i % 4 == 0 and i % 100 != 0) or i % 400 == 0): days += 366 else: days += 365 days = days - day[0] + day[1] # Calculate leap year # Get the difference between two dates print(days) result = (days % 7 + begin[3]) % 7 if(result==0): result=7 print(result)

2. There are several fixed position street lights on a road, which need to illuminate all bus stops on the road; now give the location serial number of all bus stops and roads on the road, and the bus stops and street lights are arranged on the road according to the location serial number.

Calculate the brightness of the street light to illuminate all the bus stops on the road,

a = list(map(int, input().split(','))) b = list(map(int, input().split(','))) print(a, b) a.sort() b.sort() # Find the maximum of several values minnums = [] # Calculation of intermediate position for i in range(len(a)): minnum = 10000 for j in range(len(b)): if (abs(a[i] - b[j]) < minnum): minnum = abs(a[i] - b[j]) minnums.append(minnum) print(minnums) result = max(minnums) print(result)

3. The owner of the rental house plans to buy a batch of new books, selects n books with the same price as alternatives, and sends a batch of questionnaires to the vip readers. The mobile phone goes to the list of books that each reader wants to read. In order to save the purchase cost, the owner decides to make sure that each vip reader has at least one favorite book in the purchase list to minimize the purchase cost. Output the minimum number of purchased books

Input example

5

3

1 2 3 4 5

1 2

2

3 4

## vivo advance approval

Prototype topic: dynamic planning + binary search

Title:

You will get K eggs and can use a building with N floors from 1 to N.

Every egg has the same function. If an egg breaks, you can't drop it.

You know that there is floor F. any egg falling from a floor higher than f will be broken, and the egg falling from a floor f or a floor lower than f will not be broken.

Each time you move, you can take an egg (if you have a complete egg) and drop it from any floor X (meet 1 < = X < = n).

Your goal is to know exactly what the value of F is.

No matter what the initial value of F is, how many times do you determine the minimum movement of the value of F?

Example:

Input: K = 1, N = 2

Output: 2

Explanation:

The eggs fell from the first floor. If it breaks, we know F = 0.

Otherwise, the eggs fall off the second floor. If it breaks, we know F = 1.

If it's not broken, then we know F = 2.

So in the worst case we need to move twice to determine what F is.

Idea: after the number of eggs and the floor are determined, the minimum number of movements will also be determined, so the number of k,n corresponding to the number of dynamic planning can be obtained.

1. There are two cases of dropping eggs from floor X: broken and not broken. If broken, the next step is f(k-1,x-1). If not broken, f(k,n-x). Therefore, the minimum number of movements needed to find the critical floor is f(k,n)=max{fx(k-1,x-1),fx(k,n-x)}

2. It is known that f(k,n) should be the minimum value of all cases, that is, f(k,n)=min{f1(),f2() fn()}

Time complexity: O(kn^2)

class Solution: def superEggDrop(self, k: int, n: int) -> int: def parse(k, n): if n == 1: # If there is only one layer, no matter how many eggs there are, just try it once return 1 elif n == 0: return 0 elif k == 1: # If there is only one egg, it can only be tested layer by layer return n elif (k, n) in table: return table[(k, n)] f = float('inf') # Define an infinite number as the initial condition for x in range(1, n + 1): # Drop the eggs on layer x, starting with layer 1 fx = 1 + max(parse(k - 1, x - 1), parse(k, n - x)) f = min(f, fx) table[(k, n)] = f return f table = {} # Memory is counted return parse(k, n)

Optimization scheme: dynamic planning + binary search

The observation shows that fx(k-1,x-1) increases monotonically with the increase of X, fx(k,n-x) decreases monotonically with the increase of X, so we can find out the worst case by binary search. To find the minimum value code:

for x in range(1, n + 1): # Drop the eggs on layer x, starting with layer 1 fx = 1 + max(parse(k - 1, x - 1), parse(k, n - x)) f = min(f, fx)

Change to:

while lp <= rp: mid = lp + (rp-lp) // 2 # Dichotomy optimization bcase = parse(k-1, mid-1) # Broken eggs notbcase = parse(k,n-mid) # Unbreakable situation # fx = 1 + max(bcase, notbcase) if bcase > notbcase: rp = mid - 1 f = min(f, bcase + 1) else: lp = mid + 1 f = min(f,notbcase + 1)

## Sort + two pointer search

Daily question:

Give you a n array of N integers, nums, to determine whether there are three elements a, b, c in nums, making a + b + c = 0? Please find out all the triples that meet the conditions and do not repeat.

Idea: sort the array and traverse the benchmark number from the beginning. Use two pointers to traverse at the first place of the following number. Because the array is monotonous, the search is unidirectional.

def threeSum(self,nums): nums.sort() res, k = [], 0 length = len(nums) for k in range(length-2): if nums[k] > 0: # The latter are greater than 0, and the latter are greater than zero break if(k>0 and nums[k]==nums[k-1]):#Avoid duplicate triples. Skip the next benchmark as before continue i = k + 1 j = length - 1 while i < j:#Conditions for two head and tail pointers if((nums[k] + nums[i] + nums[j] )< 0): i += 1 elif ((nums[k] + nums[i] + nums[j]) > 0): j -= 1 else: a = [nums[k], nums[i], nums[j]] res.append(a) while i<j: if(nums[i] == nums[i + 1] ):#Exclude the same tuple i+=1 elif(nums[j] == nums[j - 1]): j-=1 else: i+=1 j-=1 break return res

## to flash back

Given an array candidates and a target number target, find out all combinations of candidates that can make the number and target.

Each number in candidates can only be used once in each combination.

def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]: candidates.sort()#Now the array is sorted in order to ensure the monotonicity of the search direction self.res = [] if (target == 0 or len(candidates) == 0): return res def helper(tar, cur, idx): # cur records the node of the current record, so it needs to be passed down if (tar==0): # Start a new search self.res.append(cur[:]) for i in range(int(idx), len(candidates)): if (tar < candidates[i]): # The following number must be greater than tar. There is no target value. End directly break elif (i > idx and candidates[i] == candidates[i - 1]): # Avoid duplicate nodes continue # The rest is that the node is smaller than the target value, save the node and carry out the next search cur.append(candidates[i]) helper(tar - candidates[i], cur,i + 1) cur.pop() # Restore status, further search helper(target, [], 0) return self.res