// Complete the maxRegion function below. static int maxRegion(int[][] matrix) { var xOffset = new[] { -1, 0, 1, -1 }; var yOffset = new[] { -1, -1, -1, 0 }; var ds = new DisjointSets(); var rows = matrix.Length; var cols = matrix[0].Length; var max = 0; Func <int, int, bool> isValid = (int x, int y) => { return(x >= 0 && x < cols && y >= 0 && y < rows); }; for (int y = 0; y < rows; y++) { for (int x = 0; x < cols; x++) { if (matrix[y][x] == 0) { continue; } var current = new CellKey(x, y); ds.AddNew(current); max = Math.Max(max, 1); for (int index = 0; index < xOffset.Length; index++) { var ox = x + xOffset[index]; var oy = y + yOffset[index]; if (!isValid(ox, oy)) { continue; } if (matrix[oy][ox] == 0) { continue; } var offset = new CellKey(ox, oy); if (ds.Find(current) != ds.Find(offset)) { max = Math.Max(max, ds.Union(current, offset)); } } } } return(max); }
public List <Edge> GetMST(Graph graph) { List <Edge> mst = new List <Edge>(); // Sort the edges in ascending order of their weights List <Edge> sortedEdges = graph.AllEdges.OrderBy(e => e.Weight).ToList(); int totalNumOfVertices = graph.AllVertices.Count(); DisjointSets <int> ds = new DisjointSets <int>(); foreach (Edge e in sortedEdges) { if (mst.Count() >= totalNumOfVertices) { // total number of edges in an mst will be total number of vertices in a graph -1 break; } if (!ds.Find(e.StId, e.EndId)) { // the stId and endId vertex of the edge are not in the same set // hence adding this edge wont create a cycle ds.Union(e.StId, e.EndId); mst.Add(e); } } return(mst); }
/* * Complete the 'kruskals' function below. * * The function is expected to return an INTEGER. * The function accepts WEIGHTED_INTEGER_GRAPH g as parameter. */ /* * For the weighted graph, <name>: * * 1. The number of nodes is <name>Nodes. * 2. The number of edges is <name>Edges. * 3. An edge exists between <name>From[i] and <name>To[i]. The weight of the edge is <name>Weight[i]. * */ public static int kruskals(int gNodes, List <int> gFrom, List <int> gTo, List <int> gWeight) { var ds = new DisjointSets(gNodes); var edges = new Edge[gFrom.Count]; for (var index = 0; index < gFrom.Count; index++) { edges[index] = new Edge { From = gFrom[index], To = gTo[index], Weight = gWeight[index] }; } Array.Sort(edges); var edgesUsed = 0; var sum = 0; foreach (var edge in edges) { if (edgesUsed == gNodes - 1) { break; } if (ds.Find(edge.From) == ds.Find(edge.To)) { continue; } edgesUsed++; sum += edge.Weight; ds.Union(edge.From, edge.To); } return(sum); }
public MST <V> Execute() { var mst = new MST <V>(); var orderedEdges = _g.AllEdges().OrderBy(e => e.Weight); var ds = new DisjointSets <Node <V> >(); foreach (var edge in orderedEdges) { var head = ds.Find(edge.Head); var tail = ds.Find(edge.Tail); if (!head.Equals(tail)) { mst.Edges.Add(edge); ds.Union(head, tail); } } return(mst); }
/// <summary> /// Procedurally generates the 2-dimensional data for a maze with the dimensions set by the /// <see cref="MazeGenerator(int, int)"/> constructor.<para /> /// Calling this method consecutively will always generate an entirely new maze but of same Rows by Cols /// dimensions of the given object instance. To change the dimensions, a new object must be instantiated. /// </summary> public void GenerateMaze() { int visitedCells = 1; int currCell = rand.Next(CellNum); int adjCell; bool adjacentFound; // Index - 0: above, 1: below, 2: left, 3: right // If adjacentCells[Index] = -1 then that adjacent cell does not exist. int[] adjCells = new int[Max_Adjacency]; Stack <int> cellStack = new Stack <int>(); while (visitedCells < CellNum) { adjCell = -1; adjacentFound = false; if (currCell < Cols) { adjCells[0] = -1; } else { adjCells[0] = currCell - Cols; } if (currCell >= (CellNum - Cols)) { adjCells[1] = -1; } else { adjCells[1] = currCell + Cols; } if (currCell % Cols == 0) { adjCells[2] = -1; } else { adjCells[2] = currCell - 1; } if ((currCell + 1) % Cols == 0) { adjCells[3] = -1; } else { adjCells[3] = currCell + 1; } for (int i = 0; i < adjCells.Length; ++i) { if (adjCells[i] >= 0 && (sets.Find(currCell) != sets.Find(adjCells[i]))) { adjacentFound = true; } else { adjCells[i] = -1; } } if (adjacentFound) { int wallIndex; do { wallIndex = rand.Next(Max_Adjacency); adjCell = adjCells[wallIndex]; }while (adjCell < 0); sets.Union(currCell, adjCell); // Adjacent cell is - 0: above, 1: below, 2: left, 3: right switch (wallIndex) { case 0: // Connect currentCell with adjacentCell above. grid[currCell] = new Cell(false, grid[currCell].belowWall, grid[currCell].leftWall, grid[currCell].rightWall); grid[adjCell] = new Cell(grid[adjCell].aboveWall, false, grid[adjCell].leftWall, grid[adjCell].rightWall); break; case 1: // Connect currentCell with adjacentCell below. grid[currCell] = new Cell(grid[currCell].aboveWall, false, grid[currCell].leftWall, grid[currCell].rightWall); grid[adjCell] = new Cell(false, grid[adjCell].belowWall, grid[adjCell].leftWall, grid[adjCell].rightWall); break; case 2: // Connect currentCell with adjacentCell on left. grid[currCell] = new Cell(grid[currCell].aboveWall, grid[currCell].belowWall, false, grid[currCell].rightWall); grid[adjCell] = new Cell(grid[adjCell].aboveWall, grid[adjCell].belowWall, grid[adjCell].leftWall, false); break; case 3: // Connect currentCell with adjacentCell on right. grid[currCell] = new Cell(grid[currCell].aboveWall, grid[currCell].belowWall, grid[currCell].leftWall, false); grid[adjCell] = new Cell(grid[adjCell].aboveWall, grid[adjCell].belowWall, false, grid[adjCell].rightWall); break; default: Debug.LogError ("GenerateMaze() error: invalid wallIndex value."); break; } cellStack.Push(currCell); currCell = adjCell; ++visitedCells; } else { if (cellStack.Count > 0) { currCell = cellStack.Pop(); } } } }