def DFS2Iterative(
vertexIndex: int,
components: Dictionary,
component_index: int,
vertexes: VectorArray,
cache: SingleArray,
):
currentVertex = vertexes[vertexIndex]
stack = BasicStack()
stack.push(Node(None))
stack.push(Node(vertexIndex))
cache.add(vertexIndex)
while True:
components.insert(component_index, currentVertex.index)
for u in currentVertex.bindedVertexes:
if components[u.index] is not None \
or cache.getIndexByValue(u.index) is not None:
continue
else:
cache.add(u.index)
stack.push(Node(u.index))
components.insert(component_index, u.index)
stackValue = stack.pop().getItem()
if stackValue is None:
return
currentVertex = vertexes[stackValue]
def __init__(self, index: int):
self.index = index
self.passed = False
self.bindedVertexes = SingleArray()
self.incomingVertexes = SingleArray()
self.color = 'w'
self.incomingValue = 0
self.outgoingValue = 0
self.visited = False
def __init__(self, rows_count: int = None, vector: int = None):
self._array = SingleArray()
self._vector = vector if vector else 10
self._size = 0
self._rows_size = 0
if rows_count is not None:
for i in range(rows_count):
self._array.add(VectorArray(self._vector))
self._rows_size += 1
class Vertex:
def __init__(self, index: int):
self.index = index
self.passed = False
self.bindedVertexes = SingleArray()
def addBindedVertex(self, vertex):
self.bindedVertexes.add(vertex)
def clearBindedIndexes(self):
self.bindedVertexes = SingleArray()
class Vertex:
def __init__(self, index: int):
self.index = index
self.bindedVertexes = SingleArray()
self.label = float("inf")
def addBindedVertex(self, vertex):
self.bindedVertexes.add(vertex)
def clearBindedIndexes(self):
self.bindedVertexes = SingleArray()
def get_figures_by_code(self, code: str):
res = SingleArray()
for i in range(self._figures.rows_size()):
row = self._figures.get_row(i)
for j in range(8):
figure = row.get(j)
if figure is None:
continue
if figure.code == code:
res.add(figure)
return res
def makeAdjacencyVector(vertexIndexes: []):
uniqueCount = 0
uniqueIndexes = SingleArray()
for slaveVertexes in vertexIndexes:
for vertexIndex in slaveVertexes:
if not uniqueIndexes.getIndexByValue(vertexIndex) is None:
continue
uniqueIndexes.add(vertexIndex)
uniqueCount += 1
return AdjacencyVector(uniqueCount)
def get_unique_count(self):
uniqueVertexes = SingleArray()
for row in self._array:
if uniqueVertexes.getIndexByValue(row[0]) is None:
uniqueVertexes.add(row[0])
if uniqueVertexes.getIndexByValue(row[1]) is None:
uniqueVertexes.add(row[1])
return uniqueVertexes.size()
def get_table(self):
res = SingleArray()
all_count = 0
for j in range(8):
for move_key in self._moves:
if get_col_char(j) in move_key:
all_count += self._moves[move_key].size()
res.add(self._moves[move_key].join(' '))
res_all = "\n".join(res.get_all())
if len(res_all) > 0:
return str(all_count) + "\n" + res_all
else:
return str(all_count)
class Vertex:
def __init__(self, index: int):
self.index = index
self.passed = False
self.bindedVertexes = SingleArray()
self.incomingVertexes = SingleArray()
self.color = 'w'
self.incomingValue = 0
self.outgoingValue = 0
self.visited = False
def addBindedVertex(self, vertex):
self.bindedVertexes.add(vertex)
vertex.incomingVertexes.add(self)
def clearBindedIndexes(self):
self.bindedVertexes = SingleArray()
def isVisited(self):
return self.visited == True
class Vertex:
def __init__(self, index: int):
self.index = index
self.incidentEdges = SingleArray()
def addIncidentEdge(self, edge):
self.incidentEdges.add(edge)
def addIncidentEdges(self, edges):
for edge in edges:
self.incidentEdges.add(edge)
def clearIncidentEdges(self):
self.incidentEdges = SingleArray()
def findMinIncidentEdge(self):
minEdge = None
for edge in self.incidentEdges:
if (minEdge is None or edge.weight < minEdge.weight):
minEdge = edge
return minEdge
def __init__(self, rows_count: int):
self.vector = VectorArray(rows_count)
for i in range(rows_count):
self.vector.add(SingleArray())
def clearIncidentEdges(self):
self.incidentEdges = SingleArray()
def cosarayuIterative(vertexIndexes: []):
adjacencyVector = makeAdjacencyVector(vertexIndexes)
vertexes = makeVertexesArray(vertexIndexes, adjacencyVector)
invertedVector = adjacencyVector.getInvertedVector()
invertedVertexes = deepcopy(vertexes)
for rowVertexIndex, rowBindedVertexIndexes in enumerate(
invertedVector.vector):
invertedVertexes[rowVertexIndex].clearBindedIndexes()
for bindedVertexIndex in rowBindedVertexIndexes:
invertedVertexes[rowVertexIndex].addBindedVertex(
invertedVertexes[bindedVertexIndex])
components = Dictionary()
compVertexesQueue = BasicQueue()
compVertexesStack = BasicStack()
invertedMatrix = adjacencyVector.getInvertedVector()
for rowVertexIndex, rowBindedVertexIndexes in enumerate(
invertedMatrix.vector):
invertedVertexes[rowVertexIndex].clearBindedIndexes()
for bindedVertexIndex in rowBindedVertexIndexes:
invertedVertexes[rowVertexIndex].addBindedVertex(
invertedVertexes[bindedVertexIndex])
invertedVertexes[0].passed = True
cache = VectorArray()
for rowVertexIndex, rowBindedVertexIndexes in enumerate(
invertedMatrix.vector):
indexCachedVertex = cache.getIndexByValue(rowVertexIndex)
if indexCachedVertex is not None:
continue
cache.add(invertedVertexes[rowVertexIndex].index)
compVertexesQueue.enqueue(rowVertexIndex)
for vertexIndex in rowBindedVertexIndexes:
cachedVertex = cache.getIndexByValue(vertexIndex)
if cachedVertex is not None:
continue
vertex = invertedVertexes[vertexIndex]
if vertex.passed is False:
DFSIterative(vertex, compVertexesQueue, cache,
invertedVertexes)
while not compVertexesQueue.isEmpty():
compVertexesStack.push(compVertexesQueue.dequeue())
component_index = 0
cache = SingleArray()
while not compVertexesStack.isEmpty():
vertexIndex = compVertexesStack.pop()
if components[vertexIndex] is None:
DFS2Iterative(vertexIndex, components, component_index, vertexes,
cache)
component_index += 1
return components.get_all()
def __init__(self, index: int):
self.index = index
self.bindedVertexes = SingleArray()
self.label = float("inf")
def __init__(self, index: int):
self.index = index
self.incidentEdges = SingleArray()
def clearBindedIndexes(self):
self.bindedVertexes = SingleArray()
def test_single_array(self):
singleArray = SingleArray()
for i in range(30):
singleArray.add(i)
print(singleArray.get(15))
print(singleArray.size())
singleArray.insert('test', 15)
print(singleArray.get(15))
print(singleArray.size())
print(singleArray.remove(15))
print(singleArray.get(15))
print(singleArray.size())
def __init__(self, index: int):
self.index = index
self.passed = False
self.bindedVertexes = SingleArray()
def add_move(self, from_pos: str, move: str):
if from_pos not in self._moves:
self._moves[from_pos] = SingleArray()
self._moves[from_pos].add(move)
class MatrixArray(IArray):
def __init__(self, rows_count: int = None, vector: int = None):
self._array = SingleArray()
self._vector = vector if vector else 10
self._size = 0
self._rows_size = 0
if rows_count is not None:
for i in range(rows_count):
self._array.add(VectorArray(self._vector))
self._rows_size += 1
def size(self):
return self._size
def rows_size(self):
return self._rows_size
def __resize_replace(self):
if self.size() == self._array.size() * self._vector:
self._array.add(VectorArray(self._vector))
self._rows_size += 1
def __resize_insert(self):
if self._array.size() == 0 or self._array.get(
self._array.size() - 1).size() == self._vector:
self._array.add(VectorArray(self._vector))
self._rows_size += 1
def __shift_right(self, index: int = None):
if index is not None:
stop_row = int(index / self._vector)
stop_col = int(index % 10) - 1
single_array_size = self._array.size() - 1
for i in range(single_array_size, stop_row - 1, -1):
vector_array = self._array.get(i)
vector_array_size = vector_array.size()
col_index = stop_col if i == stop_row else 0
for j in range(vector_array_size - 1, col_index - 1, -1):
element = vector_array.get(j)
if j + 1 == vector_array_size:
if i == single_array_size - 1:
self._array.get(i + 1).insert(element, 0)
else:
self._array.get(i + 1).replace(element, 0)
else:
vector_array.replace(element, j + 1)
def add(self, item):
self.__resize_insert()
self._array.get(int(self._size / self._vector)).add(item)
self._size += 1
def insert(self, item, index: int):
self.__resize_insert()
self.__shift_right(index)
self._array.get(int(index / self._vector)).replace(
item,
int(index % self._vector) - 1)
self._size += 1
def replace(self, item, index: int):
self.__resize_replace()
self._array.get(int(index / self._vector)).replace(
item,
int(index % self._vector) - 1)
self._size += 1
def replace_by_indexes(self, item, x: int, y: int):
self.get_row(x).replace(item, y)
self._size += 1
def remove(self, index: int):
row_index = int(index / self._vector)
col_index = int(index % self._vector) - 1
self._array.get(row_index).replace(None, col_index)
if self._array.get(row_index).size() == 0:
self._array.remove(row_index)
self._size -= 1
def get(self, index: int, default: str = None):
try:
return self._array.get(int(
index / self._vector)).get(int(index % self._vector) - 1)
except IndexError:
return default
def get_row(self, row: int, default: str = None):
try:
return self._array.get(row)
except IndexError:
return default
