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
  • Practice Backtracking
  • Interview Problems on Backtracking
  • MCQs on Backtracking
  • Tutorial on Backtracking
  • Backtracking vs Recursion
  • Backtracking vs Branch & Bound
  • Print Permutations
  • Subset Sum Problem
  • N-Queen Problem
  • Knight's Tour
  • Sudoku Solver
  • Rat in Maze
  • Hamiltonian Cycle
  • Graph Coloring
Open In App
Next Article:
Rat in a Maze with multiple steps or jump allowed
Next article icon

Maximum number possible by doing at-most K swaps

Last Updated : 12 May, 2025
Comments
Improve
Suggest changes
Like Article
Like
Report
Try it on GfG Practice
redirect icon

Given a string s and an integer k, the task is to find the maximum possible number by performing swap operations on the digits of s at most k times.

Examples: 

Input: s = "7599", k = 2
Output: 9975
Explanation: Two Swaps can make input 7599 to 9975. First swap 9 with 5 so number becomes 7995, then swap 9 with 7 so number becomes 9975

Input: s = "1234567", k = 4
Output: 7654321
Explanation: Three swaps can make the input 1234567 to 7654321. First swap 1 with 7, then swap 2 with 6 and finally swap 3 with 5.

Input: s = "76543", k = 1 
Output: 76543
Explanation: No swap is required.

Table of Content

  • [Approach 1] Using Recursion - O((n^2)^k) Time and O(k) Space
  • [Approach 2] Swap the Max Digit - O((n^2)^k) Time and O(k) Space

[Approach 1] Using Recursion - O((n^2)^k) Time and O(k) Space

The idea is to generate the maximum possible number by performing at most k swaps on the given string. We iterate through all pairs of characters and swap them if it results in a larger number. After each swap, we recursively call the function with one fewer swap left. The algorithm backtracks after each swap to explore all possible combinations, and the largest number found is returned as the result.

C++ 
// C++ Implementation to Find the maximum // number possible after at most `k` swaps // using Recursion #include <bits/stdc++.h> using namespace std;  string findMax(string &s, int k) {      // Base case: If no swaps are allowed     if (k == 0) {         return s;     }      int n = s.size();     string ans = s;      // Iterate through all character pairs     for (int i = 0; i < n - 1; i++) {         for (int j = i + 1; j < n; j++) {              // Swap only if s[j] > s[i]             if (s[i] < s[j]) {                  // Perform the swap                 swap(s[i], s[j]);                  // Recur to check maximum with                 // one less swap allowed                 ans = max(ans, findMax(s, k - 1));                  // Backtrack to original state                 swap(s[i], s[j]);             }         }     }      return ans; }  string findMaximumNum(string s, int k) {      // Wrapper function to find result     return findMax(s, k); }  int main() {      string s = "7599";     int k = 2;      cout << findMaximumNum(s, k) << endl;      return 0; }
Java 
// Java Implementation to Find the maximum  // number possible after at most `k` swaps  // using Recursion import java.util.*;  class GfG {      static String findMax(String s, int k) {                  // Base case: If no swaps are allowed         if (k == 0) {             return s;         }          int n = s.length();         String ans = s;          // Iterate through all character pairs         for (int i = 0; i < n - 1; i++) {             for (int j = i + 1; j < n; j++) {                  // Swap only if s[j] > s[i]                 if (s.charAt(i) < s.charAt(j)) {                      // Perform the swap                     s = swap(s, i, j);                      // Recur to check maximum with                     // one less swap allowed                     String recResult = findMax(s, k - 1);                     if (recResult.compareTo(ans) > 0) {                         ans = recResult;                     }                      // Backtrack to original state                     s = swap(s, i, j);                 }             }         }          return ans;     }      static String findMaximumNum(String s, int k) {          // Wrapper function to find result         return findMax(s, k);     }      static String swap(String s, int i, int j) {          // Swap characters at indices i and j         char[] arr = s.toCharArray();         char temp = arr[i];         arr[i] = arr[j];         arr[j] = temp;         return new String(arr);     }      public static void main(String[] args) {                String s = "7599";         int k = 2;          System.out.println(findMaximumNum(s, k));     } }
Python 
# Python Implementation to Find the maximum  # number possible after at most `k` swaps  # using Recursion  def findMax(s, k):        # Base case: If no swaps are allowed     if k == 0:         return s      n = len(s)     ans = s      # Iterate through all character pairs     for i in range(n - 1):         for j in range(i + 1, n):              # Swap only if s[j] > s[i]             if s[i] < s[j]:                                  # Perform the swap                 swapped = list(s)                 swapped[i], swapped[j] = swapped[j], swapped[i]                 swapped = ''.join(swapped)                  # Recur to check maximum with                 # one less swap allowed                 rec_result = findMax(swapped, k - 1)                 if rec_result > ans:                     ans = rec_result      return ans  def findMaximumNum(s, k):        # Wrapper function to find result     return findMax(s, k)  if __name__ == "__main__":        s = "7599"     k = 2      print(findMaximumNum(s, k))
C# 
// C# Implementation to Find the maximum // number possible after at most `k` swaps // using Recursion using System;  class GfG {      static string findMax(string s, int k) {          // Base case: If no swaps are allowed         if (k == 0) {             return s;         }          int n = s.Length;         string ans = s;          // Iterate through all character pairs         for (int i = 0; i < n - 1; i++) {             for (int j = i + 1; j < n; j++) {                  // Swap only if s[j] > s[i]                 if (s[i] < s[j]) {                      // Perform the swap                     s = swap(s, i, j);                      // Recur to check maximum with                     // one less swap allowed                     string recResult = findMax(s, k - 1);                     if (string.Compare(recResult, ans)                         > 0) {                         ans = recResult;                     }                      // Backtrack to original state                     s = swap(s, i, j);                 }             }         }          return ans;     }      static string findMaximumNum(string s, int k) {          // Wrapper function to find result         return findMax(s, k);     }      static string swap(string s, int i, int j) {          // Swap characters at indices i and j         char[] arr = s.ToCharArray();         char temp = arr[i];         arr[i] = arr[j];         arr[j] = temp;         return new string(arr);     }      static void Main(string[] args) {         string s = "7599";         int k = 2;          Console.WriteLine(findMaximumNum(s, k));     } }
JavaScript 
// JavaScript Implementation to Find the maximum // number possible after at most `k` swaps // using Recursion  function findMax(s, k) {      // Base case: If no swaps are allowed     if (k === 0) {         return s;     }      const n = s.length;     let ans = s;      // Iterate through all character pairs     for (let i = 0; i < n - 1; i++) {         for (let j = i + 1; j < n; j++) {              // Swap only if s[j] > s[i]             if (s[i] < s[j]) {                  // Perform the swap                 let swapped = s.split("");                 [swapped[i], swapped[j]] =                     [ swapped[j], swapped[i] ];                  swapped = swapped.join("");                  // Recur to check maximum with                 // one less swap allowed                 const recResult = findMax(swapped, k - 1);                  if (recResult > ans) {                     ans = recResult;                 }             }         }     }      return ans; }  function findMaximumNum(s, k) {      // Wrapper function to find result     return findMax(s, k); }  //driver code const s = "7599"; const k = 2;  console.log(findMaximumNum(s, k));

Output
9975

Time Complexity: O((n^2)^k), where n is the length of the string and k is the maximum number of swaps. For each recursion, O(n^2) operations are performed, and there are k levels of recursion).
Auxiliary Space: O(k), for the recursion stack.

[Approach 2] Swap the Max Digit - O((n^2)^k) Time and O(k) Space

The idea is to recursively iterate through the string, finding the maximum digit for the current position, and swapping it with a larger digit later in the string. The algorithm uses a backtracking technique, meaning after each swap, it recurses to explore further swaps and then undoes the swap (backtracks). This process continues until no swaps are left or the maximum number is achieved.
C++ 
// C++ Implementation to Find the maximum  // number possible after at most `k` swaps  // using Recursion with focused digit placement. #include <bits/stdc++.h> using namespace std;  // Function to keep the maximum result void match(string &curr, string &result) {        // If current number is larger, update result     if (curr > result) {         result = curr;     } }  // Function to set highest possible digits at given index void setDigit(string &s, int index, string &res, int k) {        // Base case: If no swaps left or index reaches      // the last character, update result     if (k == 0 || index == s.size() - 1) {         match(s, res);         return;     }      int maxDigit = 0;      // Finding maximum digit for placing at given index     for (int i = index; i < s.size(); i++) {         maxDigit = max(maxDigit, s[i] - '0');     }      // If the digit at current index is already max     if (s[index] - '0' == maxDigit) {         setDigit(s, index + 1, res, k);         return;     }      // Try swapping with the maximum digit found     for (int i = index + 1; i < s.size(); i++) {                // If max digit is found at current position         if (s[i] - '0' == maxDigit) {                        // Swap to get the max digit at the required index             swap(s[index], s[i]);              // Call the recursive function to set the next digit             setDigit(s, index + 1, res, k - 1);              // Backtrack: swap the digits back             swap(s[index], s[i]);         }     } }  // Function to find the largest number after k swaps string findMaximumNum(string s, int k) {     string res = s;     setDigit(s, 0, res, k);      // Returning the result     return res; }  int main() {        string s = "7599";      int k = 2;          cout << findMaximumNum(s, k) << endl;       return 0; }
Java 
// Java Implementation to Find the maximum  // number possible after at most `k` swaps  // using Recursion with focused digit placement. class GfG {      // Function to keep the maximum result     static void match(String curr,                               StringBuilder result) {                  // If current number is larger, update result         if (curr.compareTo(result.toString()) > 0) {             result.replace(0, result.length(), curr);         }     }      // Function to set highest possible digits at given index     static void setDigit(StringBuilder s,                          int index, StringBuilder res, int k) {                  // Base case: If no swaps left or index reaches          // the last character, update result         if (k == 0 || index == s.length() - 1) {             match(s.toString(), res);             return;         }          int maxDigit = 0;          // Finding maximum digit for placing at given index         for (int i = index; i < s.length(); i++) {             maxDigit = Math.max(maxDigit, s.charAt(i) - '0');         }          // If the digit at current index is already max         if (s.charAt(index) - '0' == maxDigit) {             setDigit(s, index + 1, res, k);             return;         }          // Try swapping with the maximum digit found         for (int i = index + 1; i < s.length(); i++) {                          // If max digit is found at current position             if (s.charAt(i) - '0' == maxDigit) {                                  // Swap to get the max digit at the required index                 char temp = s.charAt(index);                 s.setCharAt(index, s.charAt(i));                 s.setCharAt(i, temp);                  // Call the recursive function to set                 // the next digit                 setDigit(s, index + 1, res, k - 1);                  // Backtrack: swap the digits back                 s.setCharAt(i, s.charAt(index));                 s.setCharAt(index, temp);             }         }     }      // Function to find the largest number after k swaps     static String findMaximumNum(String s, int k) {         StringBuilder res = new StringBuilder(s);         setDigit(new StringBuilder(s), 0, res, k);          // Returning the result         return res.toString();     }      public static void main(String[] args) {                  String s = "7599";           int k = 2;           System.out.println(findMaximumNum(s, k));      } }
Python 
# Python Implementation to Find the maximum  # number possible after at most `k` swaps  # using Recursion with focused digit placement.  # Function to keep the maximum result def match(curr, res):        # If current number is larger, update result     if curr > res:         res = curr     return res  # Function to set highest possible digits # at given index def setDigit(s, index, res, k):        # Base case: If no swaps left or index reaches      # the last character, update result     if k == 0 or index == len(s) - 1:         res = match(s, res)         return res      maxDigit = 0      # Finding maximum digit for placing at given index     for i in range(index, len(s)):         maxDigit = max(maxDigit, int(s[i]))      # If the digit at current index is already max     if int(s[index]) == maxDigit:         res = setDigit(s, index + 1, res, k)         return res      # Try swapping with the maximum digit found     for i in range(index + 1, len(s)):                # If max digit is found at current position         if int(s[i]) == maxDigit:                        # Swap to get the max digit at the required index             s = swap(s, index, i)              # Call the recursive function to set the next digit             res = setDigit(s, index + 1, res, k - 1)              # Backtrack: swap the digits back             s = swap(s, index, i)      return res  # Function to swap characters in the string def swap(s, i, j):        # Convert string to list for mutation,     # then back to string     s_list = list(s)     s_list[i], s_list[j] = s_list[j], s_list[i]     return ''.join(s_list)  # Function to find the largest number after k swaps def findMaximumNum(s, k):     res = s     res = setDigit(s, 0, res, k)      # Returning the result     return res  if __name__ == "__main__":        s = "7599"       k = 2     print(findMaximumNum(s, k))
C# 
// C# Implementation to Find the maximum // number possible after at most `k` swaps // using Recursion with focused digit placement. using System;  class GfG {      // Function to keep the maximum result     static void match(string curr, ref string result) {          // If current number is larger, update result         if (String.Compare(curr, result) > 0) {             result = curr;         }     }      // Function to set highest possible digits at given     // index     static void setDigit(ref string s, int index,                          ref string res, int k) {          // Base case: If no swaps left or index reaches         // the last character, update result         if (k == 0 || index == s.Length - 1) {             match(s, ref res);             return;         }          int maxDigit = 0;          // Finding maximum digit for placing at given index         for (int i = index; i < s.Length; i++) {             maxDigit = Math.Max(maxDigit, s[i] - '0');         }          // If the digit at current index is already max         if (s[index] - '0' == maxDigit) {             setDigit(ref s, index + 1, ref res, k);             return;         }          // Try swapping with the maximum digit found         for (int i = index + 1; i < s.Length; i++) {              // If max digit is found at current position             if (s[i] - '0' == maxDigit) {                  // Swap to get the max digit at the required                 // index                 char[] arr = s.ToCharArray();                 char temp = arr[index];                 arr[index] = arr[i];                 arr[i] = temp;                 s = new string(arr);                  // Call the recursive function to set the                 // next digit                 setDigit(ref s, index + 1, ref res, k - 1);                  // Backtrack: swap the digits back                 arr[i] = arr[index];                 arr[index] = temp;                 s = new string(arr);             }         }     }      // Function to find the largest number after k swaps     static string findMaximumNum(string s, int k) {         string res = s;         setDigit(ref s, 0, ref res, k);          // Returning the result         return res;     }      static void Main() {          string s = "7599";         int k = 2;         Console.WriteLine(findMaximumNum(s, k));     } }
JavaScript 
// JavaScript Implementation to Find the maximum // number possible after at most `k` swaps // using Recursion with focused digit placement.  // Function to keep the maximum result function match(curr, res) {      // If current number is larger, update result     if (curr > res) {         res = curr;     }     return res; }  // Function to set highest possible digits at given index function setDigit(s, index, res, k) {      // Base case: If no swaps left or index reaches     // the last character, update result     if (k === 0 || index === s.length - 1) {         res = match(s, res);         return res;     }      let maxDigit = 0;      // Finding maximum digit for placing at given index     for (let i = index; i < s.length; i++) {         maxDigit = Math.max(maxDigit, s[i] - "0");     }      // If the digit at current index is already max     if (s[index] - "0" === maxDigit) {         res = setDigit(s, index + 1, res, k);         return res;     }      // Try swapping with the maximum digit found     for (let i = index + 1; i < s.length; i++) {          // If max digit is found at current position         if (s[i] - "0" === maxDigit) {              // Swap to get the max digit at the required             // index             s = swap(s, index, i);              // Call the recursive function to set the next             // digit             res = setDigit(s, index + 1, res, k - 1);              // Backtrack: swap the digits back             s = swap(s, index, i);         }     }     return res; }  // Function to swap characters in the string function swap(s, i, j) {     let arr = s.split("");     let temp = arr[i];     arr[i] = arr[j];     arr[j] = temp;     return arr.join(""); }  // Function to find the largest number after k swaps function findMaximumNum(s, k) {     let res = s;     res = setDigit(s, 0, res, k);      // Returning the result     return res; }  // driver code let s = "7599"; let k = 2;  console.log(findMaximumNum(s, k));

Output
9975

Time Complexity: O(n^2 ^ k), where n is the length of the string and k is the maximum number of swaps. In the worst case, the recursion can go as deep as k. Therefore, the total time complexity can be approximated as O(n^2 ^ k)
Auxiliary Space: O(k), due to recursion stack.


Next Article
Rat in a Maze with multiple steps or jump allowed

A

aditya.goel
Improve
Article Tags :
  • Strings
  • Greedy
  • Backtracking
  • DSA
  • number-digits
Practice Tags :
  • Backtracking
  • Greedy
  • Strings

Similar Reads

    Backtracking Algorithm
    Backtracking algorithms are like problem-solving strategies that help explore different options to find the best solution. They work by trying out different paths and if one doesn't work, they backtrack and try another until they find the right one. It's like solving a puzzle by testing different pi
    4 min read
    Introduction to Backtracking
    Backtracking is like trying different paths, and when you hit a dead end, you backtrack to the last choice and try a different route. In this article, we'll explore the basics of backtracking, how it works, and how it can help solve all sorts of challenging problems. It's like a method for finding t
    7 min read
    Difference between Backtracking and Branch-N-Bound technique
    Algorithms are the methodical sequence of steps which are defined to solve complex problems. In this article, we will see the difference between two such algorithms which are backtracking and branch and bound technique. Before getting into the differences, lets first understand each of these algorit
    4 min read
    What is the difference between Backtracking and Recursion?
    What is Recursion?The process in which a function calls itself directly or indirectly is called recursion and the corresponding function is called a recursive function.Real Life ExampleImagine we have a set of boxes, each containing a smaller box. To find an item, we open the outermost box and conti
    4 min read

    Standard problems on backtracking

    The Knight's tour problem
    Given an n × n chessboard with a Knight starting at the top-left corner (position (0, 0)). The task is to determine a valid Knight's Tour where where the Knight visits each cell exactly once following the standard L-shaped moves of a Knight in chess.If a valid tour exists, print an n × n grid where
    15+ min read
    Rat in a Maze
    Given an n x n binary matrix representing a maze, where 1 means open and 0 means blocked, a rat starts at (0, 0) and needs to reach (n - 1, n - 1).The rat can move up (U), down (D), left (L), and right (R), but:It cannot visit the same cell more than once.It can only move through cells with value 1.
    9 min read
    N Queen Problem
    Given an integer n, the task is to find the solution to the n-queens problem, where n queens are placed on an n*n chessboard such that no two queens can attack each other. The N Queen is the problem of placing N chess queens on an N×N chessboard so that no two queens attack each other. For example,
    15+ min read
    Subset Sum Problem using Backtracking
    Given a set[] of non-negative integers and a value sum, the task is to print the subset of the given set whose sum is equal to the given sum. Examples:  Input: set[] = {1,2,1}, sum = 3Output: [1,2],[2,1]Explanation: There are subsets [1,2],[2,1] with sum 3. Input: set[] = {3, 34, 4, 12, 5, 2}, sum =
    8 min read
    M-Coloring Problem
    Given an edges of graph and a number m, the your task is to find weather is possible to color the given graph with at most m colors such that no two adjacent vertices of the graph are colored with the same color.ExamplesInput: V = 4, edges[][] = [[0, 1], [0, 2], [0,3], [1, 3], [2, 3]], m = 3Output:
    13 min read
    Hamiltonian Cycle
    Hamiltonian Cycle or Circuit in a graph G is a cycle that visits every vertex of G exactly once and returns to the starting vertex.If a graph contains a Hamiltonian cycle, it is called Hamiltonian graph otherwise it is non-Hamiltonian.Finding a Hamiltonian Cycle in a graph is a well-known NP-complet
    12 min read
    Algorithm to Solve Sudoku | Sudoku Solver
    Given an incomplete Sudoku in the form of matrix mat[][] of order 9*9, the task is to complete the Sudoku.A sudoku solution must satisfy all of the following rules:Each of the digits 1-9 must occur exactly once in each row.Each of the digits 1-9 must occur exactly once in each column.Each of the dig
    15+ min read
    Magnet Puzzle
    The puzzle game Magnets involves placing a set of domino-shaped magnets (or electrets or other polarized objects) in a subset of slots on a board so as to satisfy a set of constraints. For example, the puzzle on the left has the solution shown on the right:   Each slot contains either a blank entry
    15+ min read
    Remove Invalid Parentheses
    Given a string str consisting only of lowercase letters and the characters '(' and ')'. Your task is to delete minimum parentheses so that the resulting string is balanced, i.e., every opening parenthesis has a matching closing parenthesis in the correct order, and no extra closing parentheses appea
    15+ min read
    A backtracking approach to generate n bit Gray Codes
    Given a number n, the task is to generate n bit Gray codes (generate bit patterns from 0 to 2^n-1 such that successive patterns differ by one bit) Examples: Input : 2 Output : 0 1 3 2Explanation : 00 - 001 - 111 - 310 - 2Input : 3 Output : 0 1 3 2 6 7 5 4 We have discussed an approach in Generate n-
    6 min read
    Permutations of given String
    Given a string s, the task is to return all permutations of a given string in lexicographically sorted order.Note: A permutation is the rearrangement of all the elements of a string. Duplicate arrangement can exist.Examples:Input: s = "ABC"Output: "ABC", "ACB", "BAC", "BCA", "CAB", "CBA"Input: s = "
    5 min read

    Easy Problems on Backtracking

    Print all subsets of a given Set or Array
    Given an array arr of size n, your task is to print all the subsets of the array in lexicographical order.A subset is any selection of elements from an array, where the order does not matter, and no element appears more than once. It can include any number of elements, from none (the empty subset) t
    12 min read
    Check if a given string is sum-string
    Given a string s, the task is to determine whether it can be classified as a sum-string. A string is a sum-string if it can be split into more than two substring such that, the rightmost substring is equal to the sum of the two substrings immediately before it. This rule must recursively apply to th
    14 min read
    Count all possible Paths between two Vertices
    Given a Directed Graph with n vertices represented as a list of directed edges represented by a 2D array edgeList[][], where each edge is defined as (u, v) meaning there is a directed edge from u to v. Additionally, you are given two vertices: source and destination. The task is to determine the tot
    15+ min read
    Find all distinct subsets of a given set using BitMasking Approach
    Given an array arr[] that may contain duplicates. The task is to return all possible subsets. Return only unique subsets and they can be in any order.Note: The individual subsets should be sorted.Examples: Input: arr[] = [1, 2, 2]Output: [], [1], [2], [1, 2], [2, 2], [1, 2, 2]Explanation: The total
    7 min read
    Find if there is a path of more than k weight from a source
    Given an undirected graph represented by the edgeList[][], where each edgeList[i] contains three integers [u, v, w], representing an undirected edge from u to v, having distance w. You are also given a source vertex, and a positive integer k. Your task is to determine if there exist a simple path (w
    10 min read
    Print all paths from a given source to a destination
    Given a directed acyclic graph, a source vertex src and a destination vertex dest, print all paths from given src to dest. Examples:Input: V = 4, edges[ ][ ] = [[0, 1], [1, 2], [1, 3], [2, 3]], src = 0, dest = 3Output: [[0, 1, 2, 3], [0, 1, 3]]Explanation: There are two ways to reach at 3 from 0. Th
    12 min read
    Print all possible strings that can be made by placing spaces
    Given a string you need to print all possible strings that can be made by placing spaces (zero or one) in between them. Input: str[] = "ABC" Output: ABC AB C A BC A B C Source: Amazon Interview Experience | Set 158, Round 1, Q 1. Recommended PracticePermutation with SpacesTry It! The idea is to use
    11 min read

    Medium prblems on Backtracking

    Tug of War
    Given an array arr[] of size n, the task is to divide it into two subsets such that the absolute difference between the sum of elements in the two subsets.If n is even, both subsets must have exactly n/2 elements.If n is odd, one subset must have (n−1)/2 elements and the other must have (n+1)/2 elem
    11 min read
    8 queen problem
    Given an 8x8 chessboard, the task is to place 8 queens on the board such that no 2 queens threaten each other. Return a matrix of size 8x8, where 1 represents queen and 0 represents an empty position. Approach:The idea is to use backtracking to place the queens one by one on the board. Starting from
    9 min read
    Combination Sum
    Given an array of distinct integers arr[] and an integer target, the task is to find a list of all unique combinations of array where the sum of chosen element is equal to target.Note: The same number may be chosen from array an unlimited number of times. Two combinations are unique if the frequency
    8 min read
    Warnsdorff's algorithm for Knight’s tour problem
    Problem : A knight is placed on the first block of an empty board and, moving according to the rules of chess, must visit each square exactly once. Following is an example path followed by Knight to cover all the cells. The below grid represents a chessboard with 8 x 8 cells. Numbers in cells indica
    15+ min read
    Find paths from corner cell to middle cell in maze
    Given a square maze represented by a matrix mat[][] of positive numbers, the task is to find all paths from all four corner cells to the middle cell. From any cell mat[i][j] with value n, you are allowed to move exactly n steps in one of the four cardinal directions—North, South, East, or West. That
    14 min read
    Maximum number possible by doing at-most K swaps
    Given a string s and an integer k, the task is to find the maximum possible number by performing swap operations on the digits of s at most k times.Examples: Input: s = "7599", k = 2Output: 9975Explanation: Two Swaps can make input 7599 to 9975. First swap 9 with 5 so number becomes 7995, then swap
    15 min read
    Rat in a Maze with multiple steps or jump allowed
    You are given an n × n maze represented as a matrix. The rat starts from the top-left corner (mat[0][0]) and must reach the bottom-right corner (mat[n-1][n-1]).The rat can move forward (right) or downward.A 0 in the matrix represents a dead end, meaning the rat cannot step on that cell.A non-zero va
    11 min read
    N Queen in O(n) space
    Given an integer n, the task is to find the solution to the n-queens problem, where n queens are placed on an n*n chessboard such that no two queens can attack each other.The N Queen is the problem of placing N chess queens on an N×N chessboard so that no two queens attack each other.For example, th
    7 min read

    Hard problems on Backtracking

    Power Set in Lexicographic order
    This article is about generating Power set in lexicographical order. Examples : Input : abcOutput : a ab abc ac b bc cThe idea is to sort array first. After sorting, one by one fix characters and recursively generates all subsets starting from them. After every recursive call, we remove last charact
    9 min read
    Word Break Problem using Backtracking
    Given a non-empty sequence s and a dictionary dict[] containing a list of non-empty words, the task is to return all possible ways to break the sentence in individual dictionary words.Note: The same word in the dictionary may be reused multiple times while breaking.Examples: Input: s = “catsanddog”
    8 min read
    Partition of a set into K subsets with equal sum
    Given an integer array arr[] and an integer k, the task is to check if it is possible to divide the given array into k non-empty subsets of equal sum such that every array element is part of a single subset.Examples: Input: arr[] = [2, 1, 4, 5, 6], k = 3 Output: trueExplanation: Possible subsets of
    9 min read
    Longest Possible Route in a Matrix with Hurdles
    Given an M x N matrix, with a few hurdles arbitrarily placed, calculate the length of the longest possible route possible from source to a destination within the matrix. We are allowed to move to only adjacent cells which are not hurdles. The route cannot contain any diagonal moves and a location on
    15+ min read
    Find shortest safe route in a path with landmines
    Given a path in the form of a rectangular matrix having few landmines arbitrarily placed (marked as 0), calculate length of the shortest safe route possible from any cell in the first column to any cell in the last column of the matrix. We have to avoid landmines and their four adjacent cells (left,
    15+ min read
    Printing all solutions in N-Queen Problem
    Given an integer n, the task is to find all distinct solutions to the n-queens problem, where n queens are placed on an n * n chessboard such that no two queens can attack each other. Note: Each solution is a unique configuration of n queens, represented as a permutation of [1,2,3,....,n]. The numbe
    15+ min read
    Print all longest common sub-sequences in lexicographical order
    You are given two strings, the task is to print all the longest common sub-sequences in lexicographical order. Examples: Input : str1 = "abcabcaa", str2 = "acbacba" Output: ababa abaca abcba acaba acaca acbaa acbcaRecommended PracticePrint all LCS sequencesTry It! This problem is an extension of lon
    14 min read
    Top 20 Backtracking Algorithm Interview Questions
    Backtracking is a powerful algorithmic technique used to solve problems by exploring all possible solutions in a systematic and recursive manner. It is particularly useful for problems that require searching through a vast solution space, such as combinatorial problems, constraint satisfaction probl
    1 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