Buggy python submission (verdict: Time Limit Exceeded):
import sys

# import math
# import bisect

# import copy
# import heapq
# from collections import deque
# import decimal

# sys.setrecursionlimit(100001)
# INF = sys.maxsize
# MOD = 10 ** 9 + 7

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline()


# ===CODE===
def main():
    class UnionFind():
        def __init__(self, n):
            self.n = n
            self.parents = [-1] * n

        def find(self, x):
            if self.parents[x] < 0:
                return x
            else:
                self.parents[x] = self.find(self.parents[x])
                return self.parents[x]

        def union(self, x, y):
            x = self.find(x)
            y = self.find(y)

            if x == y:
                return

            if self.parents[x] > self.parents[y]:
                x, y = y, x

            self.parents[x] += self.parents[y]
            self.parents[y] = x

        def size(self, x):
            return -self.parents[self.find(x)]

        def same(self, x, y):
            return self.find(x) == self.find(y)

        def members(self, x):
            root = self.find(x)
            return [i for i in range(self.n) if self.find(i) == root]

        def roots(self):
            return [i for i, x in enumerate(self.parents) if x < 0]

        def group_count(self):
            return len(self.roots())

        def all_group_members(self):
            return {r: self.members(r) for r in self.roots()}

        def __str__(self):
            return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())

    n, m = map(int, input().split())

    ans = 0
    d = []
    for i in range(m):
        a, b = map(int, input().split())
        a -= 1
        b -= 1
        d.append((a, b))

    d.reverse()
    ans = []
    que = UnionFind(n)

    for i in range(m):
        tmp = list(que.parents)
        cnt = 0
        l = len(tmp)
        for j in range(l):
            if tmp[j] > -1:
                continue
            for k in range(j + 1, l):
                if tmp[k] > -1:
                    continue
                cnt += tmp[j] * tmp[k]
        ans.append(cnt)

        que.union(d[i][0], d[i][1])

    ans.reverse()
    for tmp_a in ans:
        print(tmp_a)


if __name__ == '__main__':
    main()


Fixed submission:
import sys

# import math
# import bisect

# import copy
# import heapq
# from collections import deque
# import decimal

# sys.setrecursionlimit(100001)
# INF = sys.maxsize
# MOD = 10 ** 9 + 7

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline()


# ===CODE===
def main():
    class UnionFind():
        def __init__(self, n):
            self.n = n
            self.parents = [-1] * n

        def find(self, x):
            if self.parents[x] < 0:
                return x
            else:
                self.parents[x] = self.find(self.parents[x])
                return self.parents[x]

        def union(self, x, y):
            x = self.find(x)
            y = self.find(y)

            if x == y:
                return

            if self.parents[x] > self.parents[y]:
                x, y = y, x

            self.parents[x] += self.parents[y]
            self.parents[y] = x

        def size(self, x):
            return -self.parents[self.find(x)]

        def same(self, x, y):
            return self.find(x) == self.find(y)

        def members(self, x):
            root = self.find(x)
            return [i for i in range(self.n) if self.find(i) == root]

        def roots(self):
            return [i for i, x in enumerate(self.parents) if x < 0]

        def group_count(self):
            return len(self.roots())

        def all_group_members(self):
            return {r: self.members(r) for r in self.roots()}

        def __str__(self):
            return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())

    n, m = map(int, input().split())

    d = []
    for i in range(m):
        a, b = map(int, input().split())
        a -= 1
        b -= 1
        d.append((a, b))

    d.reverse()
    ans = []
    a = n*(n-1)//2
    que = UnionFind(n)

    for i in range(m):
        ans.append(a)
        x,y = d[i]
        if not que.same(x,y):
            a -= que.size(x)*que.size(y)
            que.union(x,y)

    ans.reverse()
    for tmp_a in ans:
        print(tmp_a)


if __name__ == '__main__':
    main()

Buggy python submission (verdict: Time Limit Exceeded):
import sys

# import math
# import bisect

# import copy
# import heapq
# from collections import deque
# import decimal

# sys.setrecursionlimit(100001)
# INF = sys.maxsize
# MOD = 10 ** 9 + 7

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline()


# ===CODE===
def main():
    class UnionFind():
        def __init__(self, n):
            self.n = n
            self.parents = [-1] * n

        def find(self, x):
            if self.parents[x] < 0:
                return x
            else:
                self.parents[x] = self.find(self.parents[x])
                return self.parents[x]

        def union(self, x, y):
            x = self.find(x)
            y = self.find(y)

            if x == y:
                return

            if self.parents[x] > self.parents[y]:
                x, y = y, x

            self.parents[x] += self.parents[y]
            self.parents[y] = x

        def size(self, x):
            return -self.parents[self.find(x)]

        def same(self, x, y):
            return self.find(x) == self.find(y)

        def members(self, x):
            root = self.find(x)
            return [i for i in range(self.n) if self.find(i) == root]

        def roots(self):
            return [i for i, x in enumerate(self.parents) if x < 0]

        def group_count(self):
            return len(self.roots())

        def all_group_members(self):
            return {r: self.members(r) for r in self.roots()}

        def __str__(self):
            return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())

    n, m = map(int, input().split())

    ans = 0
    d = []
    for i in range(m):
        a, b = map(int, input().split())
        a -= 1
        b -= 1
        d.append((a, b))

    d.reverse()
    ans = []
    que = UnionFind(n)

    for i in range(m):
        tmp = list(que.parents)
        cnt = 0
        l = len(tmp)
        for j in range(l):
            if tmp[j] > -1:
                continue
            for k in range(j + 1, l):
                if tmp[k] > -1:
                    continue
                cnt += tmp[j] * tmp[k]
        ans.append(cnt)

        que.union(d[i][0], d[i][1])

    ans.reverse()
    for tmp_a in ans:
        print(tmp_a)


if __name__ == '__main__':
    main()


Fixed submission:
import sys

# import math
# import bisect

# import copy
# import heapq
# from collections import deque
# import decimal

# sys.setrecursionlimit(100001)
# INF = sys.maxsize
# MOD = 10 ** 9 + 7

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline()


# ===CODE===
def main():
    class UnionFind():
        def __init__(self, n):
            self.n = n
            self.parents = [-1] * n

        def find(self, x):
            if self.parents[x] < 0:
                return x
            else:
                self.parents[x] = self.find(self.parents[x])
                return self.parents[x]

        def union(self, x, y):
            x = self.find(x)
            y = self.find(y)

            if x == y:
                return

            if self.parents[x] > self.parents[y]:
                x, y = y, x

            self.parents[x] += self.parents[y]
            self.parents[y] = x

        def size(self, x):
            return -self.parents[self.find(x)]

        def same(self, x, y):
            return self.find(x) == self.find(y)

        def members(self, x):
            root = self.find(x)
            return [i for i in range(self.n) if self.find(i) == root]

        def roots(self):
            return [i for i, x in enumerate(self.parents) if x < 0]

        def group_count(self):
            return len(self.roots())

        def all_group_members(self):
            return {r: self.members(r) for r in self.roots()}

        def __str__(self):
            return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())

    n, m = map(int, input().split())

    d = []
    for i in range(m):
        a, b = map(int, input().split())
        a -= 1
        b -= 1
        d.append((a, b))

    d.reverse()
    ans = []
    a = n*(n-1)//2
    que = UnionFind(n)

    for i in range(m):
        ans.append(a)
        x,y = d[i]
        if not que.same(x,y):
            a -= que.size(x)*que.size(y)
            que.union(x,y)

    ans.reverse()
    for tmp_a in ans:
        print(tmp_a)


if __name__ == '__main__':
    main()

Buggy python submission (verdict: Time Limit Exceeded):
import sys

# import math
# import bisect

# import copy
# import heapq
# from collections import deque
# import decimal

# sys.setrecursionlimit(100001)
# INF = sys.maxsize
# MOD = 10 ** 9 + 7

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline()


# ===CODE===
def main():
    class UnionFind():
        def __init__(self, n):
            self.n = n
            self.parents = [-1] * n

        def find(self, x):
            if self.parents[x] < 0:
                return x
            else:
                self.parents[x] = self.find(self.parents[x])
                return self.parents[x]

        def union(self, x, y):
            x = self.find(x)
            y = self.find(y)

            if x == y:
                return

            if self.parents[x] > self.parents[y]:
                x, y = y, x

            self.parents[x] += self.parents[y]
            self.parents[y] = x

        def size(self, x):
            return -self.parents[self.find(x)]

        def same(self, x, y):
            return self.find(x) == self.find(y)

        def members(self, x):
            root = self.find(x)
            return [i for i in range(self.n) if self.find(i) == root]

        def roots(self):
            return [i for i, x in enumerate(self.parents) if x < 0]

        def group_count(self):
            return len(self.roots())

        def all_group_members(self):
            return {r: self.members(r) for r in self.roots()}

        def __str__(self):
            return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())

    n, m = map(int, input().split())

    ans = 0
    d = []
    for i in range(m):
        a, b = map(int, input().split())
        a -= 1
        b -= 1
        d.append((a, b))

    d.reverse()
    ans =[]
    que = UnionFind(n)
    for i in range(m):
        tmp = list(que.all_group_members().values())
        cnt = 0
        for j in range(len(tmp)):
            for k in range(j + 1, len(tmp)):
                cnt += len(tmp[j]) * len(tmp[k])
        ans.append(cnt)


        que.union(d[i][0], d[i][1])

    ans.reverse()
    for tmp_a in ans:
        print(tmp_a)

if __name__ == '__main__':
    main()


Fixed submission:
import sys

# import math
# import bisect

# import copy
# import heapq
# from collections import deque
# import decimal

# sys.setrecursionlimit(100001)
# INF = sys.maxsize
# MOD = 10 ** 9 + 7

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline()


# ===CODE===
def main():
    class UnionFind():
        def __init__(self, n):
            self.n = n
            self.parents = [-1] * n

        def find(self, x):
            if self.parents[x] < 0:
                return x
            else:
                self.parents[x] = self.find(self.parents[x])
                return self.parents[x]

        def union(self, x, y):
            x = self.find(x)
            y = self.find(y)

            if x == y:
                return

            if self.parents[x] > self.parents[y]:
                x, y = y, x

            self.parents[x] += self.parents[y]
            self.parents[y] = x

        def size(self, x):
            return -self.parents[self.find(x)]

        def same(self, x, y):
            return self.find(x) == self.find(y)

        def members(self, x):
            root = self.find(x)
            return [i for i in range(self.n) if self.find(i) == root]

        def roots(self):
            return [i for i, x in enumerate(self.parents) if x < 0]

        def group_count(self):
            return len(self.roots())

        def all_group_members(self):
            return {r: self.members(r) for r in self.roots()}

        def __str__(self):
            return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())

    n, m = map(int, input().split())

    d = []
    for i in range(m):
        a, b = map(int, input().split())
        a -= 1
        b -= 1
        d.append((a, b))

    d.reverse()
    ans = []
    a = n*(n-1)//2
    que = UnionFind(n)

    for i in range(m):
        ans.append(a)
        x,y = d[i]
        if not que.same(x,y):
            a -= que.size(x)*que.size(y)
            que.union(x,y)

    ans.reverse()
    for tmp_a in ans:
        print(tmp_a)


if __name__ == '__main__':
    main()

Buggy python submission (verdict: Time Limit Exceeded):
import sys

# import math
# import bisect

# import copy
# import heapq
# from collections import deque
# import decimal

# sys.setrecursionlimit(100001)
# INF = sys.maxsize
# MOD = 10 ** 9 + 7

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline()


# ===CODE===
def main():
    class UnionFind():
        def __init__(self, n):
            self.n = n
            self.parents = [-1] * n

        def find(self, x):
            if self.parents[x] < 0:
                return x
            else:
                self.parents[x] = self.find(self.parents[x])
                return self.parents[x]

        def union(self, x, y):
            x = self.find(x)
            y = self.find(y)

            if x == y:
                return

            if self.parents[x] > self.parents[y]:
                x, y = y, x

            self.parents[x] += self.parents[y]
            self.parents[y] = x

        def size(self, x):
            return -self.parents[self.find(x)]

        def same(self, x, y):
            return self.find(x) == self.find(y)

        def members(self, x):
            root = self.find(x)
            return [i for i in range(self.n) if self.find(i) == root]

        def roots(self):
            return [i for i, x in enumerate(self.parents) if x < 0]

        def group_count(self):
            return len(self.roots())

        def all_group_members(self):
            return {r: self.members(r) for r in self.roots()}

        def __str__(self):
            return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())

    n, m = map(int, input().split())

    ans = 0
    d = []
    for i in range(m):
        a, b = map(int, input().split())
        a -= 1
        b -= 1
        d.append((a, b))

    d.reverse()
    ans =[]
    que = UnionFind(n)
    for i in range(m):
        tmp = list(que.all_group_members().values())
        cnt = 0
        for j in range(len(tmp)):
            for k in range(j + 1, len(tmp)):
                cnt += len(tmp[j]) * len(tmp[k])
        ans.append(cnt)


        que.union(d[i][0], d[i][1])

    ans.reverse()
    for tmp_a in ans:
        print(tmp_a)

if __name__ == '__main__':
    main()


Fixed submission:
import sys

# import math
# import bisect

# import copy
# import heapq
# from collections import deque
# import decimal

# sys.setrecursionlimit(100001)
# INF = sys.maxsize
# MOD = 10 ** 9 + 7

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline()


# ===CODE===
def main():
    class UnionFind():
        def __init__(self, n):
            self.n = n
            self.parents = [-1] * n

        def find(self, x):
            if self.parents[x] < 0:
                return x
            else:
                self.parents[x] = self.find(self.parents[x])
                return self.parents[x]

        def union(self, x, y):
            x = self.find(x)
            y = self.find(y)

            if x == y:
                return

            if self.parents[x] > self.parents[y]:
                x, y = y, x

            self.parents[x] += self.parents[y]
            self.parents[y] = x

        def size(self, x):
            return -self.parents[self.find(x)]

        def same(self, x, y):
            return self.find(x) == self.find(y)

        def members(self, x):
            root = self.find(x)
            return [i for i in range(self.n) if self.find(i) == root]

        def roots(self):
            return [i for i, x in enumerate(self.parents) if x < 0]

        def group_count(self):
            return len(self.roots())

        def all_group_members(self):
            return {r: self.members(r) for r in self.roots()}

        def __str__(self):
            return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())

    n, m = map(int, input().split())

    d = []
    for i in range(m):
        a, b = map(int, input().split())
        a -= 1
        b -= 1
        d.append((a, b))

    d.reverse()
    ans = []
    a = n*(n-1)//2
    que = UnionFind(n)

    for i in range(m):
        ans.append(a)
        x,y = d[i]
        if not que.same(x,y):
            a -= que.size(x)*que.size(y)
            que.union(x,y)

    ans.reverse()
    for tmp_a in ans:
        print(tmp_a)


if __name__ == '__main__':
    main()

Buggy python submission (verdict: Time Limit Exceeded):
import math
import copy
from copy import deepcopy
import sys
import fractions
# import numpy as np
from functools import reduce
# import statistics
import heapq
import collections

sys.setrecursionlimit(100001)

# input = sys.stdin.readline
# sys.setrecursionlimit(10**6)

# ===FUNCTION===

def getInputInt():
    inputNum = int(input())
    return inputNum


def getInputListInt():
    outputData = []
    inputData = input().split()
    outputData = [int(n) for n in inputData]

    return outputData


def getSomeInputInt(n):
    outputDataList = []
    for i in range(n):
        inputData = int(input())
        outputDataList.append(inputData)

    return outputDataList


def getSomeInputListInt(n):
    inputDataList = []
    outputDataList = []
    for i in range(n):
        inputData = input().split()
        inputDataList = [int(n) for n in inputData]
        outputDataList.append(inputDataList)

    return outputDataList


# ===CODE===

n, m = map(int, input().split())

input_data = []
data = []

inputDataList = []
outputDataList = []
for i in range(m):
    inputData = input().split()
    inputDataList = [int(n)-1 for n in inputData]
    outputDataList.append(inputDataList)

outputDataList.append([-1, -1])
outputDataList.reverse()
table = [[i] for i in range(n)]

def swapNum(mat, min_num, max_num):
    if min_num == -1:
        return

    flg_index = False
    flg_target = False
    tmp_index = -1
    tmp_target = -1

    for i in range(len(mat)):
        if min_num in mat[i]:
            tmp_index = i
        if max_num in mat[i]:
            tmp_target = i
        if flg_index and flg_target:
            break

    if tmp_index == tmp_target:
        return
    else:
        mat[tmp_index] += mat[tmp_target]
        del mat[tmp_target]




def calcAns(counted_list):
    ans = 0
    l = len(counted_list)

    for i in range(l):
        for j in range(i+1, l, 1):
            ans += len(counted_list[i]) * len(counted_list[j])

    return ans

answer = 0
answer_list = []

for a, b in outputDataList:
    swapNum(table, min(a, b), max(a, b))
    answer = calcAns(table)
    answer_list.append(answer)

del answer_list[len(answer_list)-1]
answer_list.reverse()

print(*answer_list, sep="\n")




Fixed submission:
import sys

# import math
# import bisect

# import copy
# import heapq
# from collections import deque
# import decimal

# sys.setrecursionlimit(100001)
# INF = sys.maxsize
# MOD = 10 ** 9 + 7

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline()


# ===CODE===
def main():
    class UnionFind():
        def __init__(self, n):
            self.n = n
            self.parents = [-1] * n

        def find(self, x):
            if self.parents[x] < 0:
                return x
            else:
                self.parents[x] = self.find(self.parents[x])
                return self.parents[x]

        def union(self, x, y):
            x = self.find(x)
            y = self.find(y)

            if x == y:
                return

            if self.parents[x] > self.parents[y]:
                x, y = y, x

            self.parents[x] += self.parents[y]
            self.parents[y] = x

        def size(self, x):
            return -self.parents[self.find(x)]

        def same(self, x, y):
            return self.find(x) == self.find(y)

        def members(self, x):
            root = self.find(x)
            return [i for i in range(self.n) if self.find(i) == root]

        def roots(self):
            return [i for i, x in enumerate(self.parents) if x < 0]

        def group_count(self):
            return len(self.roots())

        def all_group_members(self):
            return {r: self.members(r) for r in self.roots()}

        def __str__(self):
            return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())

    n, m = map(int, input().split())

    d = []
    for i in range(m):
        a, b = map(int, input().split())
        a -= 1
        b -= 1
        d.append((a, b))

    d.reverse()
    ans = []
    a = n*(n-1)//2
    que = UnionFind(n)

    for i in range(m):
        ans.append(a)
        x,y = d[i]
        if not que.same(x,y):
            a -= que.size(x)*que.size(y)
            que.union(x,y)

    ans.reverse()
    for tmp_a in ans:
        print(tmp_a)


if __name__ == '__main__':
    main()

Buggy python submission (verdict: Time Limit Exceeded):
import math
import copy
from copy import deepcopy
import sys
import fractions
# import numpy as np
from functools import reduce
# import statistics
import heapq
import collections

sys.setrecursionlimit(100001)

# input = sys.stdin.readline
# sys.setrecursionlimit(10**6)

# ===FUNCTION===

def getInputInt():
    inputNum = int(input())
    return inputNum


def getInputListInt():
    outputData = []
    inputData = input().split()
    outputData = [int(n) for n in inputData]

    return outputData


def getSomeInputInt(n):
    outputDataList = []
    for i in range(n):
        inputData = int(input())
        outputDataList.append(inputData)

    return outputDataList


def getSomeInputListInt(n):
    inputDataList = []
    outputDataList = []
    for i in range(n):
        inputData = input().split()
        inputDataList = [int(n) for n in inputData]
        outputDataList.append(inputDataList)

    return outputDataList


# ===CODE===

n, m = map(int, input().split())

input_data = []
data = []

inputDataList = []
outputDataList = []
for i in range(m):
    inputData = input().split()
    inputDataList = [int(n)-1 for n in inputData]
    outputDataList.append(inputDataList)

outputDataList.append([-1, -1])
outputDataList.reverse()
table = [i for i in range(n)]

def swapNum(mat, min_num, max_num):
    if min_num == -1:
        return

    target_num = mat[max_num]
    for i in range(n):
        if mat[i] == target_num:
            mat[i] = mat[min_num]

def countUpNum(mat):
    count_list = [0]*n
    for i in range(n):
        count_list[mat[i]] += 1
    return count_list

def calcAns(counted_list):
    ans = 0
    for i in range(n):
        if counted_list[i] == 0:
            continue

        for j in range(i+1, n, 1):
            if counted_list[j] == 0:
                continue
            ans += counted_list[i] * counted_list[j]

    return ans

answer = 0
answer_list = []

for a, b in outputDataList:
    swapNum(table, min(a, b), max(a, b))
    counted_table = countUpNum(table)
    answer = calcAns(counted_table)
    answer_list.append(answer)

del answer_list[len(answer_list)-1]
answer_list.reverse()

print(*answer_list, sep="\n")




Fixed submission:
import sys

# import math
# import bisect

# import copy
# import heapq
# from collections import deque
# import decimal

# sys.setrecursionlimit(100001)
# INF = sys.maxsize
# MOD = 10 ** 9 + 7

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline()


# ===CODE===
def main():
    class UnionFind():
        def __init__(self, n):
            self.n = n
            self.parents = [-1] * n

        def find(self, x):
            if self.parents[x] < 0:
                return x
            else:
                self.parents[x] = self.find(self.parents[x])
                return self.parents[x]

        def union(self, x, y):
            x = self.find(x)
            y = self.find(y)

            if x == y:
                return

            if self.parents[x] > self.parents[y]:
                x, y = y, x

            self.parents[x] += self.parents[y]
            self.parents[y] = x

        def size(self, x):
            return -self.parents[self.find(x)]

        def same(self, x, y):
            return self.find(x) == self.find(y)

        def members(self, x):
            root = self.find(x)
            return [i for i in range(self.n) if self.find(i) == root]

        def roots(self):
            return [i for i, x in enumerate(self.parents) if x < 0]

        def group_count(self):
            return len(self.roots())

        def all_group_members(self):
            return {r: self.members(r) for r in self.roots()}

        def __str__(self):
            return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())

    n, m = map(int, input().split())

    d = []
    for i in range(m):
        a, b = map(int, input().split())
        a -= 1
        b -= 1
        d.append((a, b))

    d.reverse()
    ans = []
    a = n*(n-1)//2
    que = UnionFind(n)

    for i in range(m):
        ans.append(a)
        x,y = d[i]
        if not que.same(x,y):
            a -= que.size(x)*que.size(y)
            que.union(x,y)

    ans.reverse()
    for tmp_a in ans:
        print(tmp_a)


if __name__ == '__main__':
    main()