nonlocal count
stackDFS = [i]
finish = set()
while stackDFS:
vertex = stackDFS.pop()
if not vertex in exploredNodes:
exploredNodes.add(vertex)
if vertex in graph:
stackDFS.extend(graph[vertex] - exploredNodes)
finish.add(vertex)
count += len(finish)
for i in reversed(finishTimes):
count = 0
if not i in exploredNodes:
_DFS(i)
countOfSCC.append(count)
countOfSCC.sort(reverse=True)
return countOfSCC
if __name__ == "__main__":
inputList = readAsListOfDict('_410e934e6553ac56409b2cb7096a44aa_SCC.txt',
'\s+',
2,
fieldDataList=[int, int])
writeSingleToFile(
'Problem4.txt', ','.join(
[str(i) for i in getStronglyConnectedComponents(inputList)[0:5]]))
for edge in edgeList:
array[edge["tail"]][edge["head"]] = edge["cost"]
for k in range(vertexCount + 1):
for i in range(1, vertexCount + 1):
for j in range(1, vertexCount + 1):
array[i][j] = min(array[i][j], array[i][k] + array[k][j])
if i == j and array[i][j] < 0:
return inf #infinity signifies negative cycle
return min(min(array, key=lambda v: min(v)))
if __name__ == "__main__":
inputListG1 = readAsListOfDict('_6ff856efca965e8774eb18584754fd65_g1.txt',
'\s+', 3, ["tail", "head", "cost"],
[int, int, int], 0, 1)
vertexCountG1, edgeCountG1 = [
int(i) for i in inputListG1.pop(0).split(' ')
]
inputListG2 = readAsListOfDict('_6ff856efca965e8774eb18584754fd65_g2.txt',
'\s+', 3, ["tail", "head", "cost"],
[int, int, int], 0, 1)
vertexCountG2, edgeCountG2 = [
int(i) for i in inputListG2.pop(0).split(' ')
]
inputListG3 = readAsListOfDict('_6ff856efca965e8774eb18584754fd65_g3.txt',
'\s+', 3, ["tail", "head", "cost"],
[int, int, int], 0, 1)
vertexCountG3, edgeCountG3 = [
int(i) for i in inputListG3.pop(0).split(' ')
deletedNodes[randomEdge[1]]=randomEdge[0]
for key,value in deletedNodes.items():
if value == randomEdge[1]:
deletedNodes[key]=randomEdge[0]
for i,e in enumerate(edgesInGraph):
temp = [e[0],e[1]]
if e[0] in deletedNodes:
temp[0]=deletedNodes[e[0]]
if e[1] in deletedNodes:
temp[1]=deletedNodes[e[1]]
edgesInGraph[i] = (temp[0],temp[1])
edgesInGraph=list(filter(lambda v: v[0]!=v[1],edgesInGraph))
minCuts = min(minCuts,len(edgesInGraph))
return minCuts
if __name__=='__main__':
inputList = readAsListOfDict('_f370cd8b4d3482c940e4a57f489a200b_kargerMinCut.txt','\s+',2,["vertex","neighbours"])
vertexList=set([ int(item["vertex"]) for item in inputList])
edgeList = set([ (min(int(item["vertex"]),int(neighbour)),max(int(item["vertex"]),int(neighbour))) for item in
inputList for neighbour in item["neighbours"].strip().split('\t') if int(item["vertex"]) != int(
neighbour) ])
start = time.time()
writeSingleToFile('Problem3.txt',countKargersMinimumCuts(vertexList,edgeList))
end=time.time()
print(end-start)
ADVICE: If you're not getting the correct answer, try debugging your algorithm using some small test cases. And
then post them to the discussion forum!
"""
__author__ = 'Vinayak'
from fileIO import readAsListOfDict,writeSingleToFile
def calculateOptimalKnapsack(itemList, size, count):
"""Returns optimal value when items from itemList are scheduled on knapsack of size size"""
# Sub-problems Array
knapsackValues = [[0 for i in range(size+1)] for j in range(count)]
for c in range(1,count):
for s in range(size+1):
if itemList[c]["weight"] > s:
knapsackValues[c][s]=knapsackValues[c-1][s]
else:
knapsackValues[c][s] = max(knapsackValues[c-1][s],knapsackValues[c-1][s-itemList[c]["weight"]] +
itemList[c]["value"])
return knapsackValues[count-1][size]
if __name__=='__main__':
inputList = readAsListOfDict("_6dfda29c18c77fd14511ba8964c2e265_knapsack1.txt",'\s+'
,2,['value','weight'],[int,int],0,1)
knapsackSize, itemCount = [int(value) for value in inputList.pop(0).split(' ')]
writeSingleToFile("Problem3a.txt",calculateOptimalKnapsack(inputList, knapsackSize, itemCount))
def kruskalClustering(edgeList, nodeCount, numberOfClusters):
"""Return cost of maximum spacing edge after kruskal clustering"""
edgeList.sort(key=lambda v: v["cost"])
UFObj = UnionFind(list(range(1, nodeCount + 1)))
while UFObj.uniqueLeaders() != numberOfClusters:
edge = edgeList.pop(0)
UFObj.union(edge["node1"], edge["node2"])
maxSpacingEdge = {}
while edgeList:
maxSpacingEdge = edgeList.pop(0)
if (UFObj.find(maxSpacingEdge["node1"]) != UFObj.find(
maxSpacingEdge["node2"])):
break
return maxSpacingEdge["cost"]
if __name__ == '__main__':
inputList = readAsListOfDict(
"_fe8d0202cd20a808db6a4d5d06be62f4_clustering1.txt", '\s+', 3,
['node1', 'node2', 'cost'], [int, int, int], 0, 1)
nodeCount = int(inputList.pop(0))
writeSingleToFile("Problem2a.txt",
kruskalClustering(inputList, nodeCount, 4))
min_dist, curr_node = heapq.heappop(minHeap)
indexHeap = {tup[1]: i for i, tup in enumerate(minHeap)}
unexploredNodes.remove(curr_node)
shortestPath[curr_node] = min_dist
for edge in graph[curr_node]:
if edge[0] in unexploredNodes:
dist, node = minHeap[indexHeap[edge[0]]]
minHeap[indexHeap[edge[0]]] = (min(dist, min_dist + edge[1]),
edge[0])
heapq.heapify(minHeap)
return shortestPath
if __name__ == "__main__":
inputList = readAsListOfDict(
"_dcf1d02570e57d23ab526b1e33ba6f12_dijkstraData.txt", '\s+', 2,
["node", "neighbourStr"], [int, str])
graph = {
details["node"]: [
tuple(int(x) for x in neighbourDetails.split(','))
for neighbourDetails in details["neighbourStr"].strip().split('\t')
]
for details in inputList
}
shortestPaths = runDijkstra(graph, 1, list(range(1, 201)))
# print(shortestPaths)
writeSingleToFile(
"Problem5.txt", ",".join([
str(shortestPaths[key])
for key in [7, 37, 59, 82, 99, 115, 133, 165, 188, 197]
]))
#!/usr/bin/env python
"""
For this problem, use the same data set as in the previous problem.
Your task now is to run the greedy algorithm that schedules jobs (optimally) in decreasing order of the ratio
(weight/length). In this algorithm, it does not matter how you break ties. You should report the sum of weighted
completion times of the resulting schedule --- a positive integer --- in the box below.
"""
__author__ = 'Vinayak'
from fileIO import readAsListOfDict,writeSingleToFile
from itertools import accumulate
def calculateWeightedCompleteTime(jobs):
"""Schedule jobs based on difference (weight - length) and return weighted total time."""
jobs.sort(key=lambda v:v['weight']/v['length'],reverse=True)
finishTime = list(accumulate([0]+jobs,lambda s,v:s+v['length']))
weightedCompletedTime = sum((jobs[i]['weight']*finishTime[i+1] for i in range(len(jobs))))
return weightedCompletedTime
if __name__=="__main__":
jobList=readAsListOfDict('_642c2ce8f3abe387bdff636d708cdb26_jobs.txt','\s+',
2,['weight','length'],[int,int],1)
writeSingleToFile("Problem1b.txt",calculateWeightedCompleteTime(jobList))
pass
heapq.heapify(edgeHeap)
edge = heapq.heappop(edgeHeap)
cost, node1, node2 = edge[0], edge[1][0], edge[1][1]
if node1 not in exploredNodes:
exploredNodes.add(node1)
unexploredNodes.remove(node1)
if node2 not in exploredNodes:
exploredNodes.add(node2)
unexploredNodes.remove(node2)
MSTCost += cost
edgesInMST.add((node1, node2, cost))
edgeList = list(
filter(
lambda e: e[1][0] in unexploredNodes or e[1][1] in
unexploredNodes, edgeList))
return edgesInMST, MSTCost
if __name__ == "__main__":
inputList = readAsListOfDict('_d4f3531eac1d289525141e95a2fea52f_edges.txt',
'\s+', 3, ['node1', 'node2', 'cost'],
[int, int, int], 0, 1)
nodeCount, edgeCount = [int(i) for i in inputList[0].split(' ')]
del inputList[0]
writeSingleToFile("Problem1c.txt", prim(inputList, nodeCount)[1])