n, m = int(input()), int(input())
a = [[int(i) for i in input().split()] for w in range(m)]
input()
b = [int(i) for i in input().split()]
def listmerge(lstlst):
all=[]
for lst in lstlst:
all.extend(lst)
return all
def local(a,n):
loc, locUse = [],[]
for w in a:
if w != []:
if w[0] not in locUse and w[1] not in locUse:
loc.append(w)
locUse.extend(w)
else:
for i in range(len(loc)):
if w[0] in locUse and w[1] in locUse:
if w[0] in loc[i] and w[1] in loc[i]: None
else:
for j in range(i, len(loc)):
if w[0] in loc[i] and w[1] in loc[j] or w[1] in loc[i] and w[0] in loc[j]:
loc[i] = listmerge([loc[i],loc[j]])
loc[j] = []
elif w[0] in locUse and w[1] not in locUse or w[1] in locUse and w[0] not in locUse:
if w[0] in loc[i]:
loc[i] = listmerge([loc[i],[w[1]]])
locUse.append(w[1])
elif w[1] in loc[i]:
loc[i] = listmerge([loc[i],[w[0]]])
locUse.append(w[0])
while [] in loc:
loc.remove([])
return len(loc)+n-len(locUse)
for w in b:
a[w-1] = []
print(local(a,n), end = ' ')
def user_input():
# n, m = int(input()), int(input())
n = 2
m = 4
# a = [[int(i) for i in 'input()'.split()] for w in range(m)]
first = [[1, 2], [3, 4, 5], [6, 7], [8, 9, 10, 11]]
# input()
# b = [int(i) for i in input().split()]
second = [2, 3]
return first, second, n
def process(list_of_lists, n):
# Можно ли использовать множества? А вместо вложенных списков - tuple или set.
seen_lists, seen_numbers = [], []
has_at_least_two_items = lambda lst: lst and len(lst) >= 2
for sublist in filter(has_at_least_two_items, list_of_lists):
number0, number1 = sublist[:2]
numbers = {number0, number1} # Для ускорения проверок <x in Y>
# Ни одно из чисел не встречалось ранее
if not numbers.issubset(seen_numbers):
seen_lists.append(sublist)
seen_numbers.extend(sublist)
# Здесь бы вставить continue и уменьшить вложенность блока ниже, но зачистка seen_lists перед return мешает
else: # Обработка списка, напоминающая сортировку пузырьком
# Почему перебор до конца списка, а не до seen_lists[:-1]? Поправил.
for i, seen_list_i in enumerate(seen_lists[:-1]): # Заметка: слайс возвращает КОПИЮ списка
sl_i = set(seen_list_i) # Для ускорения проверок <x in Y>
common = len(numbers.intersection(seen_numbers))
# Оба числа встречались раньше
if common == 2:
if numbers.issubset(sl_i):
continue
# Что будет, когда i == j == len(seen_lists) - 1?
for j, seen_list_j in enumerate(seen_lists[i:], i): # Заметка: слайс возвращает КОПИЮ списка
sl_j = set(seen_list_j) # Для ускорения проверок <x in Y>
if (number0 in sl_i and number1 in sl_j) or (number1 in sl_i and number0 in sl_j):
seen_list_i.extend(seen_list_j)
seen_list_j.clear()
# Раньше встречалось только одно число из двух
elif common == 1:
# Дальше у одного числа приоритет перед другим;
# Нельзя ли сделать nx = numbers - sl_i? Но проверить, что nx - это одно число, а не {number1, n2}
if number0 in sl_i:
nx = number1
elif number1 in sl_i:
nx = number0
else:
continue
seen_list_i.append(nx)
seen_numbers.append(nx)
# Эта зачистка точно на своём месте? Можно её сделать перед return? Или удалять пустые сразу (выше)?
seen_lists = [sublist for sublist in seen_lists if sublist]
# В чём смысл этого результата?
return len(seen_lists) - len(seen_numbers) + n
def main(first, second, n):
for value in second:
first[value-1].clear() # В чём смысл?
print(process(first, n), end=' ')
if __name__ == '__main__':
main(*user_input())if w != []:def listmerge(lstlst):
all=[]
for lst in lstlst:
all.extend(lst)
return allwhile [] in loc:
Простой
Простой
Простой
Простой
Простой
