def allShortestPath(g, n):
#node number range(1, n+1)
d = g
p = np.zeros((n, n))
utility.printMatrix(d)
for k in range(0, n):
for i in range(0, n):
for j in range(0, n):
if d[i][j] > d[i][k] + d[k][j]:
d[i][j] = d[i][k] + d[k][j]
p[i][j] = k + 1
return d, p
def optDNA_table_and_sequence(a, b):
m = len(a) # 10
n = len(b) # 8
table = [[0 for j in range(0, n + 1)] for i in range(0, m + 1)] # 11*9
minindex = [[(0, 0) for j in range(0, n + 1)]
for i in range(0, m + 1)] # 11*9
# 틈 행 채우기
for j in range(n - 1, -1, -1):
table[m][j] = table[m][j + 1] + 2
# 틈 열 채우기
for i in range(m - 1, -1, -1):
table[i][n] = table[i + 1][n] + 2
# table
for i in range(m - 1, -1, -1):
for j in range(n - 1, -1, -1):
if a[i] == b[j]:
penalty = 0 # 일치시 손해는 0
else:
penalty = 1 # 불일치시 손해는 1
table[i][j] = min(table[i + 1][j + 1] + penalty,
table[i + 1][j] + 2,
table[i][j + 1] + 2) # 틈 발생시 손해는 2
# minindex
for i in range(0, m):
for j in range(0, n):
if table[i][j] == table[i + 1][j] + 2:
minindex[i][j] = (i + 1, j)
elif table[i][j] == table[i][j + 1] + 2:
minindex[i][j] = (i, j + 1)
else:
minindex[i][j] = (i + 1, j + 1)
utility.printMatrix(table)
x = 0
y = 0
while (x < m and y < n):
tx, ty = x, y
print(minindex[x][y])
(x, y) = minindex[x][y] # 다음 opt(i,j) 갱신
if x == tx + 1 and y == ty + 1: # 좌상에서 온 경우, 좌상염기 출력
print(a[tx], " ", b[ty])
elif x == tx and y == ty + 1: # 좌에서 온 경우, x서열에 틈을 넣는다.
print(" - ", " ", b[ty])
else: # 상에서 온 경우, y서열에 틈을 넣는다.
print(a[tx], " ", "-")
def dpalignment(a, b):
m = len(a)
n = len(b)
table = [[0 for j in range(0, n + 1)] for i in range(0, m + 1)]
minindex = [[(0, 0) for j in range(0, n + 1)] for i in range(0, m + 1)]
for j in range(n - 1, -1, -1):
table[m][j] = table[m][j + 1] + 2
for i in range(m - 1, -1, -1):
table[i][n] = table[i + 1][n] + 2
for d in range(1, m):
j = n
for i in range(m - d, m):
if i <= 0:
break
j -= 1
if j < 0:
break
opt(i, j, a, b, table, minindex)
for d in range(n - 1, -1, -1):
for i in range(0, d + 1):
if i > m - 1:
break
j = d - i
opt(i, j, a, b, table, minindex)
utility.printMatrix(table)
x = 0
y = 0
print()
while x < m and y < n:
tx, ty = x, y
print(minindex[x][y])
(x, y) = minindex[x][y]
if x == tx + 1 and y == ty + 1:
print(a[tx], " ", b[ty])
elif x == tx and y == ty + 1:
print(" - ", " ", b[ty])
else:
print(a[tx], " ", " - ")
import utility
inf = 1000
w = [[0, 1, 3, inf, inf],
[1, 0, 3, 6, inf],
[3, 3, 0, 4, 2],
[inf, 6, 4, 0, 5],
[inf, inf, 2, 5, 0]]
# (1) Prim's
F = set()
print("(1)Prim")
utility.printMatrix(w)
n = len(w)
nearest = n*[0]
distance = n*[0]
def prim(n, w, F, nearest, distance):
for i in range(1, n):
nearest[i] = 0
distance[i] = w[0][i]
for j in range(0, n):
min = inf
for i in range(1, n):
if 0 <= distance[i] < min:
min = distance[i]
vnear = i
F.add((vnear, nearest[vnear]))
# 8 5
import utility
e = {0: [1, 2, 3], 1: [2, 5], 2: [3, 4, 5, 6], 3: [4, 6], 4: [6, 7]}
n = 8
a = [[0 for j in range(0, n)] for i in range(0, n)]
# index는 nlgn만큼만 보고(반만 보고), 값은 연결된 모든 index에 넣어준 matrix
for i in range(0, n - 1): # 0에서 6까지 . 7번째는 어차피 돌 필요 없음. identity는 검사 안하니까
for j in range(
i + 1,
n): #1에서 7까지 # [6][7]까지 다 도는 것. #upper triangular matrix만 검사
if i in e:
if j in e[i]:
a[i][j] = 1
a[j][i] = 1
utility.printMatrix(a)
# 0 1 1 1 0 0 0 0
# 1 0 1 0 0 1 0 0
# 1 1 0 1 1 1 1 0
# 1 0 1 0 1 0 1 0
# 0 0 1 1 0 0 1 1
# 0 1 1 0 0 0 0 0
# 0 0 1 1 1 0 0 0
# 0 0 0 0 1 0 0 0
visited = n * [0]
n = len(a)
seq = 1
# 왜 n 과 visited는 global로 지정도 안해줬는데 DFS에서 쓸 수 있고,
# k 는 global로 지정해줘야 쓰이는가?
m[i][i]=0
for diagonal in range(1,n):
for i in range(1, n-diagonal+1):
j=i+diagonal
min=10000
minpoint=0
for k in range(i,j):
if (m[i][k]+m[k+1][j]+d[i-1]*d[k]*d[j]<min):
min=m[i][k]+m[k+1][j]+d[i-1]*d[k]*d[j]
minpoint=k
p[i][j]=minpoint
m[i][j]=min
utility.printMatrix(m)
print()
utility.printMatrix(p)
order(p,1,6)
print()
print()
#(2)
class Node:
def __init__(self, data):
self.l_child=None
self.r_chile=None
table[i][n] = table[i + 1][n] + 2
for i in range(m - 1, -1, -1):
for j in range(n - 1, -1, -1):
penalty = 0
if a[i] != b[j]:
penalty = 1
tmin = table[i + 1][j + 1] + penalty
minindex[i][j] = (i + 1, j + 1)
if tmin > table[i + 1][j] + 2:
tmin = table[i + 1][j] + 2
minindex[i][j] = (i + 1, j)
if tmin > table[i][j + 1] + 2:
tmin = table[i][j + 1]
minindex[i][j] = (i, j + 1)
table[i][j] = tmin
utility.printMatrix(table)
x = 0
y = 0
while x < m and y < n:
tx, ty = x, y
# print(minindex[x][y])
(x, y) = minindex[x][y]
if x == tx + 1 and y == ty + 1:
print(a[tx], " ", b[ty])
elif x == tx and y == ty + 1:
print("-", " ", b[ty])
else:
print(a[tx], " ", "-")
def optsearchtree(n, p, a, r):
for diagonal in range(1, n):
for i in range(1, n-diagonal+1):
j = i + diagonal
# Initialize a&r&psum
a[i][j] = a[i][i-1] + a[i+1][j]
r[i][j] = i
psum = 0
for k in range(i, j+1):
# Sum of p[i to j]
psum += p[k]
if (a[i][k-1] + a[k+1][j]) < a[i][j]:
a[i][j] = a[i][k-1] + a[k+1][j]
r[i][j] = k
a[i][j] += psum
optsearchtree(n, p, a, r)
utility.printMatrixF(a)
print()
utility.printMatrix(r)
root = tree(key,r,1,n)
print("\nInorder")
utility.print_inOrder(root)
print("\nPreorder")
utility.print_preOrder(root)
print("\nPostorder")
utility.print_postOrder(root)
import utility
inf = 1000
w = [[0, 1, 3, inf, inf], [1, 0, 3, 6, inf], [3, 3, 0, 4, 2],
[inf, 6, 4, 0, 5], [inf, inf, 2, 5, 0]]
F = set()
utility.printMatrix(w) # v0 ~ v4
n = len(w) # len = 5
nearest = n * [0]
distance = n * [0]
for i in range(1, n): # Initializing nearest[i] & distance[i]
nearest[i] = 0
distance[i] = w[0][i]
for i in range(1, n): # repeat n-1 times
min = inf
for j in range(1, n):
if (0 <= distance[j] < min):
min = distance[j] # update the min
vnear = j # find a vnear
e = (nearest[i], vnear)
F.add(e)
distance[vnear] = -1 # 찾은 노드가 다시 검사되는 것을 방지(찾은 노드를 Y에 추가한다)
for k in range(1, n): # Y에서 X-Y로의 최단거리 및 가장 가까운 노드를 갱신
if (w[k][vnear] < distance[k]):
distance[k] = w[k][vnear]
nearest[k] = vnear
for j in range(0, n):
if d[i][j] > d[i][k] + d[k][j]:
d[i][j] = d[i][k] + d[k][j]
p[i][j] = k + 1
return d, p
def _path(p, q, r):
if (p[q][r] != 0):
_path(p, q, p[q][r] - 1)
print("v%d" % p[q][r], end=" ")
_path(p, p[q][r] - 1, r)
def path(p, q, r):
print("v%d" % q, end=" ")
_path(p, q - 1, r - 1)
print("v%d" % r, end=" ")
inf = 1000
g = [[0, 1, inf, 1, 5], [9, 0, 3, 2, inf], [inf, inf, 0, 4, inf],
[inf, inf, 2, 0, 3], [3, inf, inf, inf, 0]]
d, p = allShortestPath(g, 5)
print()
utility.printMatrix(d)
print()
utility.printMatrix(p)
path(p, 5, 3)
