Conditions:

1. They open the border when two countries share the border and the difference of population is greater and equal than L, and is less and equal than R.
2. In population migration, the population in each country is (the total population / the number of countries ). Don't round up.
3. Afterward, the border is closed.

Solutions:

from collections import deque

#Get input n(size of land), l and r.
n, l, r = map(int, input().split())

#Get information of population (n X n).
population = []
for _ in range(n):
    population.append(list(map(int, input().split())))

#Define directions, left and right, and up and down.
dx = [-1, 0, 1, 0]
dy = [0, -1, 0, 1]

result = 0 

def process(x, y, index):

    #Create a list containing (x, y) coordinate and border information.
    united = []
    united.append((x, y))

    #Define queue data structure for BFS.
    q= deque()
    q.append((x, y))
    union[x][y] = index  #The index(number) of current union.
    summary = population[x][y]  #The total population of current union. 
    coutnt = 1  #The number of countries of union.

    while q:
        x, y = q.popleft()

        for i in range(4):
            nx = x + dx[i]
            ny = y + dy[i]

            #Check if the countries share the borders and check if the union are not processed yet. 
            if 0 <= nx and nx < n and 0 <= ny and ny < n and union[nx][ny] == -1:
            #Define the difference of population. 
            difference = abs(population[nx][ny] - population[x][y])
                if l <= difference <= r:
                  q.append((nx, ny))
                  #Add in union.
                  union[nx][ny] = index
                  summary += population[nx][ny]
                  count += 1
                  united.append((nx, ny))
    #Distribute population. 
    for i, j in united:
        population[i][j] = summary // count
    return count

total count = 0

#Repeate a loop until population migration do not occur.
while True:
    union = [[-1] * n for _ in range(n)]
    index = 0
    for i in range(n):
        for j in range(n):
            if union[i][j] == -1:  #If the country is not processed. 
                process(i, j, index)
                index += 1

    if index == n * n:  #After the migration ends. 
         break
       total_count += 1

#Print the total count of the migration. 
print(total_count)

Conditions: His coordinate is (1, 1) and the exit locates at (N, M). He can move one step at a time. During the movement, he has to avoid monsters, whose node is coded as 1.

from collections import deque

#Get input, N and M, separated by space.
n, m = map(int, input().split())

#Get 2 dimensional list of input.
graph = []
for i in range(n):
    graph.append(list(map(int, input())))

#Define directions (Left, Right, Up, Down)    
dx = [-1, 1, 0, 0]
dy = [0, 0, -1, 0]

#Define a function, bfs.
def bfs(x, y):
    queue = deque()
    queue.append((x, y))

    #While-loop until queue is empty.
    while queue:
        x, y = queue.popleft()

        #Location (nx, ny) distanced from current position.
        for i in range(4):
            nx = x + dx[i]
            ny = y + dy[i}

            #Ignore if the location is off-limit. 
            if nx < 0 or ny < 0 or nx >= n or ny >= m:
            continue

            #Ignore when he meets a wall.
            if graph[nx][ny] == 0:
            continue

            #If visited the node, plus 1 distance
            if graph[nx][ny] == 1:
                graph[nx][ny] = graph[x][y] + 1
                queue.append((nx, ny))

    #Return the shortest distance to the most downright node.
    return graph[n-1][m-1]

print(bfs(0,0))

Example: 4 X 5 ice frame makes 3 icecreams in total.

00110 00011 11111 00000

#Get input N and M. 
n, m = map(int, input().split())

#Get a sequential numbers of input and 
#put it into 2 dimensional list, "graph". 
graph = []
for _ in range(n):
    graph.append(list(map(int, input())))

#Define a function named "dfs".
def dfs(x, y):
    #Return False if x and y are out of range N X M. 
    if x <= -1 or x >= n or y <= -1 or y >= m:
        return False

    #If the node (x, y) is not "visited", code it to 1.
    if graph[x][y] ==0:
        graph[x][y] = 1

        #Call the "dfs" function recursively and check the surrounding nodes 
        #whether they are visited.
        dfs(x-1, y)
        dfs(x, y-1)
        dfs(x+1, y)
        dfs(x, y+1)

        #Return True if they are visited. 
        return True
    return False

result = 0
#In a for-loop of N X M, if the node(i, j) was visited, count 1 up for result. 
for i in rangae(n):
    for j in range(m):
        if dfs(i, j) == True:
            result += 1
print(result)

Rules:

1. The arrangement of cards are N rows X M columns.
2. Pick a row.
3. Select the lowest card number in the row.
4. What you will finally choose is the greatest number among cards, considering that you get the lowest card number in every row.

Solution: Find the lowest number in every row, and then pick the greatest number among them.

#Get how many rows and how many columns there are.(n X m)
n, m = map(int, input().split())

#Initialize the result.
result = 0

#In the for-loop, get the input cards, 
#and compare the minimum number of input cards with the result. 
#The result will be reset if it finds smaller numbers.
for _ in range(n):
    cards = list(map(int, input().split()))
    if result < min(cards):
        result = min(cards)
    else: pass

print(result)

#input (ex: 5 8 3, 2 4 5 4 6)
n, m, k = map(int, input().split())
data = list(map(int, input().split()))

#Get the greatest number and the second greatest number
first = max(data)
data.remove(first)
second = max(data)

#Initialize the result
result = 0

# sum = (2) * (3) * 6 + (2) * 5  
result = (m//k) * k * first + (m%k) * second

print(result)

Rules:

1. Muji starts to eat food #1, and the rotate disk brings food to Muji in increasing order.
2. When Muji eats the last # of food, the disk brings #1 again.
3. It allows 1 second for one bite of food, and because the disk rotates at every second, Muji has to eat the next food with the eaten food being left.
4. It takes no time to bring the food for the disk.

The network disconnection shut down Muji's broadcasting for k seconds, and Muji wants to know which food # he has to restart to eat.

Example:

import heapq

def solution(food_times, k):

#if eating the all food takes longer than k, return -1
    if sum(food_times) <= k:
        return -1

    q = []
# Put tuples, (food_times, #), into q during the loop.
    for i in range(len(food_times)):
        heapq.heappush(q, (food_times[i], i+1))

# Initialize the value. 
    sum_value = 0    #Time spent for eating the food
    previous = 0     #Time spent for eating, just before
    length = len(food_times)     #the number of food left

# While-loop when the eating time is less equal than k seconds,
    while sum_value + ((q[0][0] - previous) * length) <= k:
        now = heapq.heappop(q)[0]    #Current eating time
        sum_value += (now - previous) * length
        length -= 1    #Subtract 1 for eaten food
        previous = now   #reset "previous"

# Return the food # to restart eating. 
    result = sorted(q, key=lambda x: x[1])
    return result[(k - sum_value) % length][1]

최소의 동전 개수로 거스름돈을 거슬러 주는 머신이 있다.

#Define the bill('money') and the default amount of coins('count').
money = 1260
count = 0

#Define a list of coin types.
coin_types = [500, 100, 50, 10]

#During a loop, the machine will give you coins 
#in a descending order 
#and record the number of coins in the 'count' variable.
for coin in coin_types:
    count += (money // coin)
    money %= coin

#print the answer.
print(count)