Skip to content
geeksforgeeks
  • Tutorials
    • Python
    • Java
    • Data Structures & Algorithms
    • ML & Data Science
    • Interview Corner
    • Programming Languages
    • Web Development
    • CS Subjects
    • DevOps And Linux
    • School Learning
    • Practice Coding Problems
  • Courses
    • DSA to Development
    • Get IBM Certification
    • Newly Launched!
      • Master Django Framework
      • Become AWS Certified
    • For Working Professionals
      • Interview 101: DSA & System Design
      • Data Science Training Program
      • JAVA Backend Development (Live)
      • DevOps Engineering (LIVE)
      • Data Structures & Algorithms in Python
    • For Students
      • Placement Preparation Course
      • Data Science (Live)
      • Data Structure & Algorithm-Self Paced (C++/JAVA)
      • Master Competitive Programming (Live)
      • Full Stack Development with React & Node JS (Live)
    • Full Stack Development
    • Data Science Program
    • All Courses
  • DSA
  • Interview Problems on Graph
  • Practice Graph
  • MCQs on Graph
  • Graph Tutorial
  • Graph Representation
  • Graph Properties
  • Types of Graphs
  • Graph Applications
  • BFS on Graph
  • DFS on Graph
  • Graph VS Tree
  • Transpose Graph
  • Dijkstra's Algorithm
  • Minimum Spanning Tree
  • Prim’s Algorithm
  • Topological Sorting
  • Floyd Warshall Algorithm
  • Strongly Connected Components
  • Advantages & Disadvantages
Open In App
Next Article:
Minimum initial vertices to traverse whole matrix with given conditions
Next article icon

Minimum initial vertices to traverse whole matrix with given conditions

Last Updated : 23 Feb, 2023
Comments
Improve
Suggest changes
Like Article
Like
Report

We are given a matrix that contains different values in each cell. Our aim is to find the minimal set of positions in the matrix such that the entire matrix can be traversed starting from the positions in the set. 
We can traverse the matrix under the below conditions: 

  • We can move only to those neighbors that contain values less than or equal to the current cell's value. A neighbour of the cell is defined as the cell that shares a side with the given cell.

Examples: 

Input : 1 2 3         2 3 1         1 1 1 Output : 1 1          0 2 If we start from 1, 1 we can cover 6  vertices in the order (1, 1) -> (1, 0) -> (2, 0)  -> (2, 1) -> (2, 2) -> (1, 2). We cannot cover the entire matrix with this vertex. Remaining  vertices can be covered (0, 2) -> (0, 1) -> (0, 0).   Input : 3 3         1 1 Output : 0 1 If we start from 0, 1, we can traverse  the entire matrix from this single vertex  in this order (0, 0) -> (0, 1) -> (1, 1) -> (1, 0).  Traversing the matrix in this order  satisfies all the conditions stated above.


From the above examples, we can easily identify that in order to use a minimum number of positions, we have to start from the positions having the highest cell value. Therefore, we pick the positions that contain the highest value in the matrix. We take the vertices having the highest value in a separate array. We perform DFS at every vertex starting from the
highest value. If we encounter any unvisited vertex during dfs then we have to include this vertex in our set. When all the cells have been processed, then the set contains the required vertices.

How does this work? 
We need to visit all vertices and to reach the largest values we must start with them. If the two largest values are not adjacent, then both of them must be picked. If the two largest values are adjacent, then any of them can be picked as moving to equal value neighbors is allowed.

Implementation:

C++ 
// C++ program to find minimum initial // vertices to reach whole matrix. #include <bits/stdc++.h> using namespace std;  const int MAX = 100;  // (n, m) is current source cell from which // we need to do DFS. N and M are total no. // of rows and columns. void dfs(int n, int m, bool visit[][MAX],          int adj[][MAX], int N, int M) {     // Marking the vertex as visited     visit[n][m] = 1;      // If below neighbor is valid and has     // value less than or equal to current     // cell's value     if (n + 1 < N &&         adj[n][m] >= adj[n + 1][m] &&         !visit[n + 1][m])         dfs(n + 1, m, visit, adj, N, M);      // If right neighbor is valid and has     // value less than or equal to current     // cell's value     if (m + 1 < M &&         adj[n][m] >= adj[n][m + 1] &&         !visit[n][m + 1])         dfs(n, m + 1, visit, adj, N, M);      // If above neighbor is valid and has     // value less than or equal to current     // cell's value     if (n - 1 >= 0 &&         adj[n][m] >= adj[n - 1][m] &&         !visit[n - 1][m])         dfs(n - 1, m, visit, adj, N, M);      // If left neighbor is valid and has     // value less than or equal to current     // cell's value     if (m - 1 >= 0 &&         adj[n][m] >= adj[n][m - 1] &&         !visit[n][m - 1])         dfs(n, m - 1, visit, adj, N, M); }  void printMinSources(int adj[][MAX], int N, int M) {     // Storing the cell value and cell indices     // in a vector.     vector<pair<long int, pair<int, int> > > x;     for (int i = 0; i < N; i++)         for (int j = 0; j < M; j++)             x.push_back(make_pair(adj[i][j],                         make_pair(i, j)));       // Sorting the newly created array according     // to cell values     sort(x.begin(), x.end());      // Create a visited array for DFS and     // initialize it as false.     bool visit[N][MAX];     memset(visit, false, sizeof(visit));      // Applying dfs for each vertex with     // highest value     for (int i = x.size()-1; i >=0 ; i--)     {         // If the given vertex is not visited         // then include it in the set         if (!visit[x[i].second.first][x[i].second.second])         {             cout << x[i].second.first << " "                  << x[i].second.second << endl;             dfs(x[i].second.first, x[i].second.second,                visit, adj, N, M);         }     } }  // Driver code int main() {     int N = 2, M = 2;      int adj[N][MAX] = {{3, 3},                        {1, 1}};     printMinSources(adj, N, M);     return 0; }
Java 
// Java program to find minimum initial // vertices to reach whole matrix. import java.io.*; import java.util.*;  class Cell {     public int val, i, j;     public Cell(int val, int i, int j)     {         this.val = val;         this.i = i;         this.j = j;     } }  class CellComparer implements Comparator<Cell> {     public int compare(Cell a, Cell b)     {         return a.val - b.val;     } }  public class GFG {     static final int MAX = 100;      // (n, m) is current source cell from which     // we need to do DFS. N and M are total no.     // of rows and columns.     static void dfs(int n, int m, Boolean[][] visit,                     int[][] adj, int N, int M)     {         // Marking the vertex as visited         visit[n][m] = true;          // If below neighbor is valid and has         // value less than or equal to current         // cell's value         if (n + 1 < N && adj[n][m] >= adj[n + 1][m]             && !visit[n + 1][m])             dfs(n + 1, m, visit, adj, N, M);          // If right neighbor is valid and has         // value less than or equal to current         // cell's value         if (m + 1 < M && adj[n][m] >= adj[n][m + 1]             && !visit[n][m + 1])             dfs(n, m + 1, visit, adj, N, M);          // If above neighbor is valid and has         // value less than or equal to current         // cell's value         if (n - 1 >= 0 && adj[n][m] >= adj[n - 1][m]             && !visit[n - 1][m])             dfs(n - 1, m, visit, adj, N, M);          // If left neighbor is valid and has         // value less than or equal to current         // cell's value         if (m - 1 >= 0 && adj[n][m] >= adj[n][m - 1]             && !visit[n][m - 1])             dfs(n, m - 1, visit, adj, N, M);     }      static void printMinSources(int[][] adj, int N, int M)     {         // Storing the cell value and cell indices         // in a list.         LinkedList<Cell> x = new LinkedList<Cell>();         for (int i = 0; i < N; i++) {             for (int j = 0; j < M; j++) {                 x.add(new Cell(adj[i][j], i, j));             }         }          // Sorting the newly created array according         // to cell values         Collections.sort(x, new CellComparer());          // Create a visited array for DFS and         // initialize it as false.         Boolean[][] visit = new Boolean[N][MAX];         for (int i = 0; i < N; i++) {             for (int j = 0; j < MAX; j++)                 visit[i][j] = false;         }          // Applying dfs for each vertex with         // highest value         for (int i = x.size() - 1; i >= 0; i--) {             // If the given vertex is not visited             // then include it in the set             if (!visit[x.get(i).i][x.get(i).j]) {                 System.out.printf("%d %d\n", x.get(i).i,                                   x.get(i).j);                 dfs(x.get(i).i, x.get(i).j, visit, adj, N,                     M);             }         }     }      public static void main(String[] args)     {         int N = 2, M = 2;         int[][] adj = { { 3, 3 }, { 1, 1 } };         printMinSources(adj, N, M);     } }  // This code is contributed by cavi4762.
Python3 
# Python3 program to find minimum initial # vertices to reach whole matrix MAX = 100   # (n, m) is current source cell from which # we need to do DFS. N and M are total no. # of rows and columns. def dfs(n, m, visit, adj, N, M):          # Marking the vertex as visited     visit[n][m] = 1       # If below neighbor is valid and has     # value less than or equal to current     # cell's value     if (n + 1 < N and          adj[n][m] >= adj[n + 1][m] and          not visit[n + 1][m]):         dfs(n + 1, m, visit, adj, N, M)       # If right neighbor is valid and has     # value less than or equal to current     # cell's value     if (m + 1 < M and          adj[n][m] >= adj[n][m + 1] and          not visit[n][m + 1]):         dfs(n, m + 1, visit, adj, N, M)       # If above neighbor is valid and has     # value less than or equal to current     # cell's value     if (n - 1 >= 0 and          adj[n][m] >= adj[n - 1][m] and          not visit[n - 1][m]):         dfs(n - 1, m, visit, adj, N, M)       # If left neighbor is valid and has     # value less than or equal to current     # cell's value     if (m - 1 >= 0 and          adj[n][m] >= adj[n][m - 1] and          not visit[n][m - 1]):         dfs(n, m - 1, visit, adj, N, M)  def printMinSources(adj, N, M):      # Storing the cell value and cell      # indices in a vector.     x = []          for i in range(N):         for j in range(M):             x.append([adj[i][j], [i, j]])       # Sorting the newly created array according     # to cell values     x.sort()       # Create a visited array for DFS and     # initialize it as false.     visit = [[False for i in range(MAX)]                     for i in range(N)]          # Applying dfs for each vertex with     # highest value     for i in range(len(x) - 1, -1, -1):                  # If the given vertex is not visited         # then include it in the set         if (not visit[x[i][1][0]][x[i][1][1]]):             print('{} {}'.format(x[i][1][0],                                  x[i][1][1]))                          dfs(x[i][1][0],                  x[i][1][1],                 visit, adj, N, M)          # Driver code if __name__=='__main__':      N = 2     M = 2       adj = [ [ 3, 3 ], [ 1, 1 ] ]          printMinSources(adj, N, M)  # This code is contributed by rutvik_56
C# 
// C# program to find minimum initial // vertices to reach whole matrix. using System; using System.Collections.Generic;  class GFG {   static readonly int MAX = 100;    // (n, m) is current source cell from which   // we need to do DFS. N and M are total no.   // of rows and columns.   static void dfs(int n, int m, bool[, ] visit,                   int[, ] adj, int N, int M)   {     // Marking the vertex as visited     visit[n, m] = true;      // If below neighbor is valid and has     // value less than or equal to current     // cell's value     if (n + 1 < N && adj[n, m] >= adj[n + 1, m]         && !visit[n + 1, m])       dfs(n + 1, m, visit, adj, N, M);      // If right neighbor is valid and has     // value less than or equal to current     // cell's value     if (m + 1 < M && adj[n, m] >= adj[n, m + 1]         && !visit[n, m + 1])       dfs(n, m + 1, visit, adj, N, M);      // If above neighbor is valid and has     // value less than or equal to current     // cell's value     if (n - 1 >= 0 && adj[n, m] >= adj[n - 1, m]         && !visit[n - 1, m])       dfs(n - 1, m, visit, adj, N, M);      // If left neighbor is valid and has     // value less than or equal to current     // cell's value     if (m - 1 >= 0 && adj[n, m] >= adj[n, m - 1]         && !visit[n, m - 1])       dfs(n, m - 1, visit, adj, N, M);   }    static void printMinSources(int[, ] adj, int N, int M)   {     // Storing the cell value and cell indices     // in a list.     List<Tuple<int, Tuple<int, int> > > x       = new List<Tuple<int, Tuple<int, int> > >();     for (int i = 0; i < N; i++) {       for (int j = 0; j < M; j++) {         x.Add(Tuple.Create(adj[i, j],                            Tuple.Create(i, j)));       }     }      // Sorting the newly created array according     // to cell values     x.Sort();      // Create a visited array for DFS and     // initialize it as false.     bool[, ] visit = new bool[N, MAX];     for (int i = 0; i < N; i++) {       for (int j = 0; j < MAX; j++)         visit[i, j] = false;     }      // Applying dfs for each vertex with     // highest value     for (int i = x.Count - 1; i >= 0; i--) {       // If the given vertex is not visited       // then include it in the set       if (!visit[x[i].Item2.Item1,                  x[i].Item2.Item2]) {         Console.WriteLine("{0} {1}",                           x[i].Item2.Item1,                           x[i].Item2.Item2);         dfs(x[i].Item2.Item1, x[i].Item2.Item2,             visit, adj, N, M);       }     }   }    static void Main(string[] args)   {     int N = 2, M = 2;     int[, ] adj = { { 3, 3 }, { 1, 1 } };     printMinSources(adj, N, M);   } }  // This code is contributed by cavi4762.
JavaScript 
<script> // Javascript program to find minimum initial // vertices to reach whole matrix.  var MAX = 100;   // (n, m) is current source cell from which // we need to do DFS. N and M are total no. // of rows and columns. function dfs( n,  m,  visit, adj, N, M) {     // Marking the vertex as visited     visit[n][m] = 1;       // If below neighbor is valid and has     // value less than or equal to current     // cell's value     if (n + 1 < N &&         adj[n][m] >= adj[n + 1][m] &&         !visit[n + 1][m])         dfs(n + 1, m, visit, adj, N, M);       // If right neighbor is valid and has     // value less than or equal to current     // cell's value     if (m + 1 < M &&         adj[n][m] >= adj[n][m + 1] &&         !visit[n][m + 1])         dfs(n, m + 1, visit, adj, N, M);       // If above neighbor is valid and has     // value less than or equal to current     // cell's value     if (n - 1 >= 0 &&         adj[n][m] >= adj[n - 1][m] &&         !visit[n - 1][m])         dfs(n - 1, m, visit, adj, N, M);       // If left neighbor is valid and has     // value less than or equal to current     // cell's value     if (m - 1 >= 0 &&         adj[n][m] >= adj[n][m - 1] &&         !visit[n][m - 1])         dfs(n, m - 1, visit, adj, N, M); }   function printMinSources( adj,  N,  M) {     // Storing the cell value and cell indices     // in a vector.     var x = [];     for (var i = 0; i < N; i++)         for (var j = 0; j < M; j++)             x.push([adj[i][j],[i, j]]);                  // Sorting the newly created array according     // to cell values     x = x.sort();       // Create a visited array for DFS and     // initialize it as false.     var visit = new Array(N);     for (var i = 0; i < N; i++) {         visit[i] = [];         for (var j = 0; j < MAX; j++) {             visit[i].push(false);         }     }       // Applying dfs for each vertex with     // highest value     for (var i = x.length-1; i >=0 ; i--)     {         // If the given vertex is not visited         // then include it in the set         if (!visit[x[i][1][0]][x[i][1][1]])         {             document.write(x[i][1][0] + " "                  + x[i][1][1] + "<br>");             dfs(x[i][1][0], x[i][1][1],                visit, adj, N, M);         }     } }    // driver code var N = 2 var M = 2  var adj = [ [ 3, 3 ], [ 1, 1 ] ]  printMinSources(adj, N, M) // This code contributed by shivani </script>

Output
0 1

Time Complexity : O(N*M *log(N*M))

Space Complexity : O(N*M)


Next Article
Minimum initial vertices to traverse whole matrix with given conditions

H
HGaur
Improve
Article Tags :
  • Graph
  • Greedy
  • Technical Scripter
  • Competitive Programming
  • DSA
  • DFS
Practice Tags :
  • DFS
  • Graph
  • Greedy

Similar Reads

    Greedy Algorithms
    Greedy algorithms are a class of algorithms that make locally optimal choices at each step with the hope of finding a global optimum solution. At every step of the algorithm, we make a choice that looks the best at the moment. To make the choice, we sometimes sort the array so that we can always get
    3 min read
    Greedy Algorithm Tutorial
    Greedy is an algorithmic paradigm that builds up a solution piece by piece, always choosing the next piece that offers the most obvious and immediate benefit. Greedy algorithms are used for optimization problems. An optimization problem can be solved using Greedy if the problem has the following pro
    9 min read
    Greedy Algorithms General Structure
    A greedy algorithm solves problems by making the best choice at each step. Instead of looking at all possible solutions, it focuses on the option that seems best right now.Example of Greedy Algorithm - Fractional KnapsackProblem structure:Most of the problems where greedy algorithms work follow thes
    5 min read
    Difference between Greedy Algorithm and Divide and Conquer Algorithm
    Greedy algorithm and divide and conquer algorithm are two common algorithmic paradigms used to solve problems. The main difference between them lies in their approach to solving problems. Greedy Algorithm:The greedy algorithm is an algorithmic paradigm that follows the problem-solving heuristic of m
    3 min read
    Greedy Approach vs Dynamic programming
    Greedy approach and Dynamic programming are two different algorithmic approaches that can be used to solve optimization problems. Here are the main differences between these two approaches: Greedy Approach:The greedy approach makes the best choice at each step with the hope of finding a global optim
    2 min read
    Comparison among Greedy, Divide and Conquer and Dynamic Programming algorithm
    Greedy algorithm, divide and conquer algorithm, and dynamic programming algorithm are three common algorithmic paradigms used to solve problems. Here's a comparison among these algorithms:Approach:Greedy algorithm: Makes locally optimal choices at each step with the hope of finding a global optimum.
    4 min read

    Standard Greedy algorithms

    Activity Selection Problem | Greedy Algo-1
    Given n activities with start times in start[] and finish times in finish[], find the maximum number of activities a single person can perform without overlap. A person can only do one activity at a time. Examples: Input: start[] = [1, 3, 0, 5, 8, 5], finish[] = [2, 4, 6, 7, 9, 9]Output: 4Explanatio
    13 min read
    Job Sequencing Problem
    Given two arrays: deadline[] and profit[], where the index of deadline[] represents a job ID, and deadline[i] denotes the deadline for that job and profit[i] represents profit of doing ith job. Each job takes exactly one unit of time to complete, and only one job can be scheduled at a time. A job ea
    13 min read
    Huffman Coding | Greedy Algo-3
    Huffman coding is a lossless data compression algorithm. The idea is to assign variable-length codes to input characters, lengths of the assigned codes are based on the frequencies of corresponding characters. The variable-length codes assigned to input characters are Prefix Codes, means the codes (
    12 min read
    Huffman Decoding
    We have discussed Huffman Encoding in a previous post. In this post, decoding is discussed. Examples: Input Data: AAAAAABCCCCCCDDEEEEEFrequencies: A: 6, B: 1, C: 6, D: 2, E: 5 Encoded Data: 0000000000001100101010101011111111010101010 Huffman Tree: '#' is the special character usedfor internal nodes
    15 min read
    Water Connection Problem
    You are given n houses in a colony, numbered from 1 to n, and p pipes connecting these houses. Each house has at most one outgoing pipe and at most one incoming pipe. Your goal is to install tanks and taps efficiently.A tank is installed at a house that has one outgoing pipe but no incoming pipe.A t
    8 min read
    Greedy Algorithm for Egyptian Fraction
    Every positive fraction can be represented as sum of unique unit fractions. A fraction is unit fraction if numerator is 1 and denominator is a positive integer, for example 1/3 is a unit fraction. Such a representation is called Egyptian Fraction as it was used by ancient Egyptians. Following are a
    11 min read
    Policemen catch thieves
    Given an array arr, where each element represents either a policeman (P) or a thief (T). The objective is to determine the maximum number of thieves that can be caught under the following conditions:Each policeman (P) can catch only one thief (T).A policeman can only catch a thief if the distance be
    12 min read
    Fitting Shelves Problem
    Given length of wall w and shelves of two lengths m and n, find the number of each type of shelf to be used and the remaining empty space in the optimal solution so that the empty space is minimum. The larger of the two shelves is cheaper so it is preferred. However cost is secondary and first prior
    9 min read
    Assign Mice to Holes
    There are N Mice and N holes are placed in a straight line. Each hole can accommodate only 1 mouse. A mouse can stay at his position, move one step right from x to x + 1, or move one step left from x to x -1. Any of these moves consumes 1 minute. Assign mice to holes so that the time when the last m
    8 min read

    Greedy algorithm on Array

    Minimum product subset of an array
    INTRODUCTION: The minimum product subset of an array refers to a subset of elements from the array such that the product of the elements in the subset is minimized. To find the minimum product subset, various algorithms can be used, such as greedy algorithms, dynamic programming, and branch and boun
    13 min read
    Maximize array sum after K negations using Sorting
    Given an array of size n and an integer k. We must modify array k number of times. In each modification, we can replace any array element arr[i] by -arr[i]. The task is to perform this operation in such a way that after k operations, the sum of the array is maximum.Examples : Input : arr[] = [-2, 0,
    10 min read
    Minimum sum of product of two arrays
    Find the minimum sum of Products of two arrays of the same size, given that k modifications are allowed on the first array. In each modification, one array element of the first array can either be increased or decreased by 2.Examples: Input : a[] = {1, 2, -3} b[] = {-2, 3, -5} k = 5 Output : -31 Exp
    14 min read
    Minimum sum of absolute difference of pairs of two arrays
    Given two arrays a[] and b[] of equal length n. The task is to pair each element of array a to an element in array b, such that sum S of absolute differences of all the pairs is minimum.Suppose, two elements a[i] and a[j] (i != j) of a are paired with elements b[p] and b[q] of b respectively, then p
    7 min read
    Minimum increment/decrement to make array non-Increasing
    Given an array a, your task is to convert it into a non-increasing form such that we can either increment or decrement the array value by 1 in the minimum changes possible. Examples : Input : a[] = {3, 1, 2, 1}Output : 1Explanation : We can convert the array into 3 1 1 1 by changing 3rd element of a
    11 min read
    Sorting array with reverse around middle
    Consider the given array arr[], we need to find if we can sort array with the given operation. The operation is We have to select a subarray from the given array such that the middle element(or elements (in case of even number of elements)) of subarray is also the middle element(or elements (in case
    6 min read
    Sum of Areas of Rectangles possible for an array
    Given an array, the task is to compute the sum of all possible maximum area rectangles which can be formed from the array elements. Also, you can reduce the elements of the array by at most 1. Examples: Input: a = {10, 10, 10, 10, 11, 10, 11, 10} Output: 210 Explanation: We can form two rectangles o
    13 min read
    Largest lexicographic array with at-most K consecutive swaps
    Given an array arr[], find the lexicographically largest array that can be obtained by performing at-most k consecutive swaps. Examples : Input : arr[] = {3, 5, 4, 1, 2} k = 3 Output : 5, 4, 3, 2, 1 Explanation : Array given : 3 5 4 1 2 After swap 1 : 5 3 4 1 2 After swap 2 : 5 4 3 1 2 After swap 3
    9 min read
    Partition into two subsets of lengths K and (N - k) such that the difference of sums is maximum
    Given an array of non-negative integers of length N and an integer K. Partition the given array into two subsets of length K and N - K so that the difference between the sum of both subsets is maximum. Examples : Input : arr[] = {8, 4, 5, 2, 10} k = 2 Output : 17 Explanation : Here, we can make firs
    7 min read

    Greedy algorithm on Operating System

    Program for First Fit algorithm in Memory Management
    Prerequisite : Partition Allocation MethodsIn the first fit, the partition is allocated which is first sufficient from the top of Main Memory.Example : Input : blockSize[] = {100, 500, 200, 300, 600}; processSize[] = {212, 417, 112, 426};Output:Process No. Process Size Block no. 1 212 2 2 417 5 3 11
    8 min read
    Program for Best Fit algorithm in Memory Management
    Prerequisite : Partition allocation methodsBest fit allocates the process to a partition which is the smallest sufficient partition among the free available partitions. Example: Input : blockSize[] = {100, 500, 200, 300, 600}; processSize[] = {212, 417, 112, 426}; Output: Process No. Process Size Bl
    8 min read
    Program for Worst Fit algorithm in Memory Management
    Prerequisite : Partition allocation methodsWorst Fit allocates a process to the partition which is largest sufficient among the freely available partitions available in the main memory. If a large process comes at a later stage, then memory will not have space to accommodate it. Example: Input : blo
    8 min read
    Program for Shortest Job First (or SJF) CPU Scheduling | Set 1 (Non- preemptive)
    The shortest job first (SJF) or shortest job next, is a scheduling policy that selects the waiting process with the smallest execution time to execute next. SJN, also known as Shortest Job Next (SJN), can be preemptive or non-preemptive.   Characteristics of SJF Scheduling: Shortest Job first has th
    13 min read
    Job Scheduling with two jobs allowed at a time
    Given a 2d array jobs[][] of order n * 2, where each element jobs[i], contains two integers, representing the start and end time of the job. Your task is to check if it is possible to complete all the jobs, provided that two jobs can be done simultaneously at a particular moment. Note: If a job star
    6 min read
    Optimal Page Replacement Algorithm
    In operating systems, whenever a new page is referred and not present in memory, page fault occurs, and Operating System replaces one of the existing pages with newly needed page. Different page replacement algorithms suggest different ways to decide which page to replace. The target for all algorit
    3 min read

    Greedy algorithm on Graph

    Prim’s Algorithm for Minimum Spanning Tree (MST)
    Prim’s algorithm is a Greedy algorithm like Kruskal's algorithm. This algorithm always starts with a single node and moves through several adjacent nodes, in order to explore all of the connected edges along the way.The algorithm starts with an empty spanning tree. The idea is to maintain two sets o
    15+ min read
    Boruvka's algorithm | Greedy Algo-9
    We have discussed the following topics on Minimum Spanning Tree.Applications of Minimum Spanning Tree Problem Kruskal’s Minimum Spanning Tree Algorithm Prim’s Minimum Spanning Tree AlgorithmIn this post, Boruvka's algorithm is discussed. Like Prim's and Kruskal's, Boruvka’s algorithm is also a Greed
    15+ min read
    Dial's Algorithm (Optimized Dijkstra for small range weights)
    Given a weighted Graph and a source vertex, the task is to find the shortest paths from the source node to all other vertices.Example:Input : n = 9, src = 0Output : 0 4 12 19 21 11 9 8 14 We have learned about how to find the shortest path from a given source vertex to all other vertex using Dijkstr
    10 min read
    Minimum cost to connect all cities
    There are n cities and there are roads in between some of the cities. Somehow all the roads are damaged simultaneously. We have to repair the roads to connect the cities again. There is a fixed cost to repair a particular road.Input is in the form of edges {u, v, w} where, u and v are city indices.
    7 min read
    Number of single cycle components in an undirected graph
    Given a set of 'n' vertices and 'm' edges of an undirected simple graph (no parallel edges and no self-loop), find the number of single-cycle components present in the graph. A single-cyclic component is a graph of n nodes containing a single cycle through all nodes of the component. Example: Let us
    9 min read
geeksforgeeks-footer-logo
Corporate & Communications Address:
A-143, 7th Floor, Sovereign Corporate Tower, Sector- 136, Noida, Uttar Pradesh (201305)
Registered Address:
K 061, Tower K, Gulshan Vivante Apartment, Sector 137, Noida, Gautam Buddh Nagar, Uttar Pradesh, 201305
GFG App on Play Store GFG App on App Store
Advertise with us
  • Company
  • About Us
  • Legal
  • Privacy Policy
  • In Media
  • Contact Us
  • Advertise with us
  • GFG Corporate Solution
  • Placement Training Program
  • Languages
  • Python
  • Java
  • C++
  • PHP
  • GoLang
  • SQL
  • R Language
  • Android Tutorial
  • Tutorials Archive
  • DSA
  • Data Structures
  • Algorithms
  • DSA for Beginners
  • Basic DSA Problems
  • DSA Roadmap
  • Top 100 DSA Interview Problems
  • DSA Roadmap by Sandeep Jain
  • All Cheat Sheets
  • Data Science & ML
  • Data Science With Python
  • Data Science For Beginner
  • Machine Learning
  • ML Maths
  • Data Visualisation
  • Pandas
  • NumPy
  • NLP
  • Deep Learning
  • Web Technologies
  • HTML
  • CSS
  • JavaScript
  • TypeScript
  • ReactJS
  • NextJS
  • Bootstrap
  • Web Design
  • Python Tutorial
  • Python Programming Examples
  • Python Projects
  • Python Tkinter
  • Python Web Scraping
  • OpenCV Tutorial
  • Python Interview Question
  • Django
  • Computer Science
  • Operating Systems
  • Computer Network
  • Database Management System
  • Software Engineering
  • Digital Logic Design
  • Engineering Maths
  • Software Development
  • Software Testing
  • DevOps
  • Git
  • Linux
  • AWS
  • Docker
  • Kubernetes
  • Azure
  • GCP
  • DevOps Roadmap
  • System Design
  • High Level Design
  • Low Level Design
  • UML Diagrams
  • Interview Guide
  • Design Patterns
  • OOAD
  • System Design Bootcamp
  • Interview Questions
  • Inteview Preparation
  • Competitive Programming
  • Top DS or Algo for CP
  • Company-Wise Recruitment Process
  • Company-Wise Preparation
  • Aptitude Preparation
  • Puzzles
  • School Subjects
  • Mathematics
  • Physics
  • Chemistry
  • Biology
  • Social Science
  • English Grammar
  • Commerce
  • World GK
  • GeeksforGeeks Videos
  • DSA
  • Python
  • Java
  • C++
  • Web Development
  • Data Science
  • CS Subjects
@GeeksforGeeks, Sanchhaya Education Private Limited, All rights reserved
We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox
Improvement
Suggest Changes
Help us improve. Share your suggestions to enhance the article. Contribute your expertise and make a difference in the GeeksforGeeks portal.
geeksforgeeks-suggest-icon
Create Improvement
Enhance the article with your expertise. Contribute to the GeeksforGeeks community and help create better learning resources for all.
geeksforgeeks-improvement-icon
Suggest Changes
min 4 words, max Words Limit:1000

Thank You!

Your suggestions are valuable to us.

What kind of Experience do you want to share?

Interview Experiences
Admission Experiences
Career Journeys
Work Experiences
Campus Experiences
Competitive Exam Experiences