Number of Simple Paths
You are given an undirected graph consisting of $$$n$$$ vertices and $$$n$$$ edges. It is guaranteed that the given graph is connected (i. e. it is possible to reach any vertex from any other vertex) and there are no self-loops and multiple edges in the graph.Your task is to calculate the number of simple paths of length at least $$$1$$$ in the given graph. Note that paths that differ only by their direction are considered the same (i. e. you have to calculate the number of undirected paths). For example, paths $$$[1, 2, 3]$$$ and $$$[3, 2, 1]$$$ are considered the same.You have to answer $$$t$$$ independent test cases.Recall that a path in the graph is a sequence of vertices $$$v_1, v_2, \ldots, v_k$$$ such that each pair of adjacent (consecutive) vertices in this sequence is connected by an edge. The length of the path is the number of edges in it. A simple path is such a path that all vertices in it are distinct.
Consider the second test case of the example. It looks like that:There are $$$11$$$ different simple paths:  $$$[1, 2]$$$;  $$$[2, 3]$$$;  $$$[3, 4]$$$;  $$$[2, 4]$$$;  $$$[1, 2, 4]$$$;  $$$[1, 2, 3]$$$;  $$$[2, 3, 4]$$$;  $$$[2, 4, 3]$$$;  $$$[3, 2, 4]$$$;  $$$[1, 2, 3, 4]$$$;  $$$[1, 2, 4, 3]$$$. 
The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 2 \cdot 10^4$$$) — the number of test cases. Then $$$t$$$ test cases follow.The first line of the test case contains one integer $$$n$$$ ($$$3 \le n \le 2 \cdot 10^5$$$) — the number of vertices (and the number of edges) in the graph.The next $$$n$$$ lines of the test case describe edges: edge $$$i$$$ is given as a pair of vertices $$$u_i$$$, $$$v_i$$$ ($$$1 \le u_i, v_i \le n$$$, $$$u_i \ne v_i$$$), where $$$u_i$$$ and $$$v_i$$$ are vertices the $$$i$$$-th edge connects. For each pair of vertices $$$(u, v)$$$, there is at most one edge between $$$u$$$ and $$$v$$$. There are no edges from the vertex to itself. So, there are no self-loops and multiple edges in the graph. The graph is undirected, i. e. all its edges are bidirectional. The graph is connected, i. e. it is possible to reach any vertex from any other vertex by moving along the edges of the graph.It is guaranteed that the sum of $$$n$$$ does not exceed $$$2 \cdot 10^5$$$ ($$$\sum n \le 2 \cdot 10^5$$$).
For each test case, print one integer: the number of simple paths of length at least $$$1$$$ in the given graph. Note that paths that differ only by their direction are considered the same (i. e. you have to calculate the number of undirected paths).
from sys import stdin, stdout
import collections, heapq, bisect, math
input = stdin.readline

def rint():
    return int(input())

def rstr():
    return input().strip()

def rlstr():
    return list(input().strip().split())

def rlint():
    return list(map(int, input().split()))

def main():
    n = rint()
    graph = collections.defaultdict(set)
    queue = collections.deque()
    count = [1] * n
    res = 0
    for _ in range(n):
        (u, v) = rlint()
        u -= 1
        v -= 1
        graph[u].add(v)
        graph[v].add(u)
    for i in range(n):
        if len(graph[i]) == 1:
            queue.append(i)
    while queue:
        u = queue.popleft()
        p = graph[u].pop()
        graph[p].remove(u)
        count[p] += count[u]
        count[u] = 0
        if len(graph[p]) == 1:
            queue.append(p)
    for i in range(n):
        res += count[i] * (count[i] - 1) // 2 + count[i] * (n - count[i])
    print(res)
if __name__ == '__main__':
    for _ in range(rint()):
        main()
from collections import deque
tt = int(input())
for loop in range(tt):
    n = int(input())
    lis = [[] for i in range(n)]
    link = [0] * n
    num = [1] * n
    for i in range(n):
        (u, v) = map(int, input().split())
        u -= 1
        v -= 1
        lis[u].append(v)
        lis[v].append(u)
        link[u] += 1
        link[v] += 1
    q = deque([])
    for i in range(n):
        if link[i] == 1:
            q.append(i)
    while q:
        v = q.popleft()
        link[v] = 0
        for nex in lis[v]:
            if link[nex] != 0:
                num[nex] += num[v]
                link[nex] -= 1
                if link[nex] == 1:
                    q.append(nex)
    ans = n * (n - 1)
    for i in range(n):
        if link[i] != 0:
            ans -= num[i] * (num[i] - 1) // 2
    print(ans)
import sys
import threading
from copy import deepcopy
import io, os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
sys.setrecursionlimit(10 ** 9)
threading.stack_size(16 * 2048 * 2048)

def getnum(index, neigh, visited):
    output = [0, 0]
    endlist = []
    for ele in neigh[index]:
        if visited[ele]:
            continue
        visited[ele] = True
        [end, notend] = getnum(ele, neigh, visited)
        endlist.append(end + 1)
        output[1] += notend + end
    endtot = sum(endlist)
    output[0] += endtot
    notend = 0
    for ele in endlist:
        notend += (endtot - ele) * ele
    output[1] += notend // 2
    return output

def findloop(index, neigh, pre, visited, loop):
    if loop:
        return
    if len(pre) > 1 and index == pre[-2]:
        return
    if visited[index]:
        i = len(pre) - 1
        while pre[i] != index:
            loop.append(pre[i])
            i -= 1
        loop.append(index)
        return
    pre.append(index)
    visited[index] = True
    for ele in neigh[index]:
        findloop(ele, neigh, pre, visited, loop)
        if loop:
            return
    pre.pop()
    visited[index] = False

def main(n, neigh):
    loop = []
    visited = [False] * n
    findloop(0, neigh, [], visited, loop)
    visited = [False] * n
    for loopele in loop:
        visited[loopele] = True
    endlist = []
    notendlist = []
    m = len(loop)
    for i in range(m):
        if len(neigh[loop[i]]) == 2:
            continue
        [end, notend] = getnum(loop[i], neigh, visited)
        endlist.append(end)
        notendlist.append(notend)
    ans = 0
    ans += sum(notendlist)
    ans += m * (m - 1)
    tot = sum(endlist)
    for ele in endlist:
        ans += ele * (2 * m - 1)
        ans += (tot - ele) * ele
    return ans

def solve():
    T = int(input())
    r = 1
    while r <= T:
        n = int(input())
        ans = 0
        neigh = [[] for i in range(n)]
        for i in range(n):
            (p, q) = map(int, input().split())
            neigh[p - 1].append(q - 1)
            neigh[q - 1].append(p - 1)
        ans = main(n, neigh)
        print(ans)
        r += 1
threading.Thread(target=solve).start()