Backtracking Programs

Sorting/mergeSort.java

@@ -1,72 +1,86 @@
+class Sort 
+{
+    void merge(int arr[], int left, int middle, int right)
+    {
+        int low = middle - left + 1;                   
+        int high = right - middle;                      
+
+        int L[] = new int[low];                             
+        int R[] = new int[high];
 
-public class MergeSort {
-
-    public static void main(String args[]) {	
-		int arr[] = {23, 12, 85, 39, 98, 7, 16, 97, 54};
-
-		System.out.println("Given Array");
-		printArray(arr);
-
-		MergeSort ob = new MergeSort();
-		ob.sort(arr, 0, arr.length - 1);
-
-		System.out.println("\nSorted array");
-		printArray(arr);
-	}
-
-    void merge(int arr[], int low, int mid, int up) {	
-		int n1 = mid - low + 1;
-		int n2 = up - mid;
-
-		int Left[] = new int[n1];
-		int Right[] = new int[n2];
-
-		for (int i = 0; i < n1; ++i)
-			Left[i] = arr[low + i];
-		for (int j = 0; j < n2; ++j)
-			Right[j] = arr[mid + 1 + j];
-
-		int i = 0, j = 0;
-
-		int k = low;
-		while (i < n1 && j < n2) {
-			if (Left[i] <= Right[j]) {
-				arr[k] = Left[i];
-				i++;
-			}
-			else {
-				arr[k] = Right[j];
-				j++;
-			}
-			k++;
-		}
-		while (i < n1) {
-			arr[k] = Left[i];
-			i++;
-			k++;
-		}
-		while (j < n2) {
-			arr[k] = Right[j];
-			j++;
-			k++;
-		}
-	}
+        int i = 0, j = 0;
+
+        for (i = 0; i < low; i++)                               
+        {
+            L[i] = arr[left + i];
+        }
+        for (j = 0; j < high; j++)                             
+        {
+            R[j] = arr[middle + 1 + j];
+        }
+
+
+        int k = left;                                          
+        i = 0;                                           
+        j = 0;
 
-	void sort(int arr[], int low, int up) {	
-		if (low < up) {
-			int mid =low + (up-low)/2;
+        while (i < low && j < high)                     
+        {
+            if (L[i] <= R[j]) 
+            {
+                arr[k] = L[i];
+                i++;
+            }
+            else 
+            {
+                arr[k] = R[j];
+                j++;
+            }
+            k++;
+        }
+
+        while (i < low)                          
+        {
+            arr[k] = L[i];
+            i++;
+            k++;
+        }
+
+        while (j < high)                       
+        {
+            arr[k] = R[j];
+            j++;
+            k++;
+        }
+    }
+
 
-			sort(arr, low, mid);
-			sort(arr, mid + 1, up);
+    void mergeSort(int arr[], int left, int right)      
+    {
+        int middle;
+        if (left < right) {                             
+            middle = (left + right) / 2;
+
+            mergeSort(arr, left, middle);                    
+            mergeSort(arr, middle + 1, right);              
+
+            merge(arr, left, middle, right);               
+        }
+    }
+
+    void display(int arr[])                
+    {  
+        for (int i=0; i<arr.length; ++i) 
+        {
+            System.out.print(arr[i]+" ");
+        } 
+    } 
 
-			merge(arr, low, mid, up);
-		}
-	}
-
-	static void printArray(int arr[]) {	
-		int n = arr.length;
-		for (int i = 0; i < n; ++i)
-			System.out.print(arr[i] + " ");
-		System.out.println();
-	}	
+    public static void main(String args[])
+    {
+        int arr[] = { 9, 3, 1, 5, 13, 12 };
+        Sort ob = new Sort();
+        ob.mergeSort(arr, 0, arr.length - 1);
+        ob.display(arr);
+    }
 }

backtracking/permutaion_dub.cpp

@@ -0,0 +1,43 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+void helper(vector<int> a, vector<vector<int>> &ans, int idx)
+{
+    if (idx == a.size())
+    {
+        /* code */
+        ans.push_back(a);
+        return;
+    }
+    for (int i = 0; i < a.size(); i++)
+    {
+        if(i != idx and a[i] == a[idx])
+        continue;
+        swap(a[i], a[idx]);
+    }
+
+
+}
+
+vector<vector<int>> permute(vector<int> nums){
+    sort(nums.begin(), nums.end());
+    vector<vector<int>> ans;
+    helper(nums, ans , 0);
+    return ans;
+}
+int main()
+{
+    int n;
+    cin>>n;
+    vector<int> a(n);
+    for(auto &i : a)
+    cin>> i;
+    vector<vector<int>> res = permute(a);
+    for(auto v : res)
+    {
+        for(auto i : v)
+            cout<<i<<" ";
+        cout<<"\n";
+    }
+    return 0;
+}

backtracking/permutation.cpp

@@ -0,0 +1,36 @@
+//distinc array given
+#include<iostream>
+#include<bits/stdc++.h>
+using namespace std;
+vector<vector<int>> ans;
+void permute(vector<int> &a , int idx)
+{
+    if(idx == a.size()){
+        ans.push_back(a);
+        return;
+    }
+    for (int i = idx; i < a.size(); i++)
+    {
+        /* code */
+        swap(a[i],a[idx]);
+        permute(a,idx+1);
+        swap(a[i], a[idx]);
+    }
+    return;
+}
+int main()
+{
+    int n;
+cin>>n;
+    vector<int> a(n);
+    for(auto &i : a)
+        cin>>i;
+    permute(a, 0);
+    for(auto v: ans){
+        for(auto i : v)
+            cout<<i<<" ";
+        cout<<"\n";
+    }
+
+    return 0;
+}

backtracking/permutation_sort.cpp

@@ -0,0 +1,42 @@
+//distinc array given using stl build function
+#include<iostream>
+#include<bits/stdc++.h>
+using namespace std;
+vector<vector<int>> ans;
+void permute(vector<int> &a , int idx)
+{
+    if(idx == a.size()){
+        ans.push_back(a);
+        return;
+    }
+    for (int i = idx; i < a.size(); i++)
+    {
+        /* code */
+        swap(a[i],a[idx]);
+        permute(a,idx+1);
+        swap(a[i], a[idx]);
+    }
+    return;
+}
+int main()
+{
+    int n;
+cin>>n;
+    vector<int> a(n);
+    for(auto &i : a)
+        cin>>i;
+    sort(a.begin(), a.end());
+    do
+    {
+        /* code */
+        ans.push_back(a);
+    } while (next_permutation(a.begin(), a.end()));
+
+    for(auto v: ans){
+        for(auto i : v)
+            cout<<i<<" ";
+        cout<<"\n";
+    }
+
+    return 0;
+}

backtracking/ratinmaze.cpp

@@ -0,0 +1,89 @@
+#include<iostream>
+using namespace std;
+
+bool isSafe(int** arr, int x , int y , int n){
+    if (x<n && y<n && arr[x][y]==1)
+    {
+        /* code */
+        return true;
+    }
+    return false;
+
+}
+
+bool ratinMaze(int** arr, int x ,int n, int y , int** solArr)
+{
+    if (x==n-1 && y==n-1)
+    {
+        /* code */
+        solArr[x][y]=1;
+        return true;
+    }
+
+
+    if (isSafe(arr, x, y , n))
+    {
+        /* code */
+        solArr[x][y]=1;
+        if (ratinMaze(arr, x+1 , y , n , solArr))
+        {
+            /* code */
+            return true;
+        }
+        if (ratinMaze(arr, x, y+1 , n , solArr))
+        {
+            /* code */
+            return true;
+        }
+        solArr[x][y]=0;//backtracking
+        return false;
+
+    }
+    return false;
+
+}
+
+int main()
+{
+    int n;
+    cin>>n;
+
+    int** arr=new int*[n];
+    for (int  i = 0; i < n; i++)
+    {
+        arr[i]= new int[n];
+    }
+    for (int i = 0; i < n; i++)
+    {
+        for (int j = 0; j < n; j++)
+        {
+            cin>>arr[i][j];
+        }
+
+    }
+    int** solArr = new int*[n];
+    for (int i = 0; i < n; i++)
+    {
+        solArr[i]=new int[n];
+        for (int j = 0; j < n; j++)
+        {
+            solArr[i][j]=0;
+        }
+
+
+    }
+    if (ratinMaze(arr, 0 , 0 , n , solArr))
+    {
+       for (int i = 0; i < n; i++)
+    {
+        for (int j = 0; j < n; j++)
+        {
+            cout<<solArr[i][j]<<" ";
+        }cout<<endl;
+
+    }
+    }
+
+
+    return 0;
+}