Design And Analysis of Algorithm KCS (503)

For
Academic Year (2023-24)

BUNDELKHAND INSTITUTE OF ENGINEERING

AND TECHNOLOGY
(BIET JHANSI)-284128

SUBMITTED TO: SUBMITTED BY:

Er. Sweta Rajpoot NIKHIL KUMAR

( 2100430100033)
1. Objective: To implement the Bubble, Insertion and Selection Sort and
analyze thetime complexity from its graph.
Bubble Sort
Code:
#include<bits/stdc++.h>

#include<ctime>
using namespace std;

int main(){
freopen("random.txt","r",stdin);
int
ran[]={10000,20000,30000,40000,80000,100000,120000,150000,180000,200000 }
; int ts[10];

for(int i=0;i<10;i++){

int n=ran[i];
int curr=time(NULL);

int arr[n];

for(int i=0;i<n;i++){
cin>>arr[i];
}
for(int i=0;i<n;i++){
for(int j=0;j<n-i-1;j++){
if(arr[j+1],arr[j])
swap(arr[j],arr[j+1]);
}

}
ts[i]=time(NULL)-curr;
cout<<ts[i]<<" ";
}
return 0;
}
Graph:

Bubble_Sort
1000

800

600

400

200

0
10000 20000 30000 40000 80000 100000 120000 150000 180000 200000

Best case Avg Case Worst Case

Selection Sort:
Code:
#include<bits/stdc++.h>

#include<ctime>
using namespace std;

int main(){
freopen("File2.txt","r",stdin);
int
ran[]={10000,20000,30000,40000,80000,100000,120000,150000,180000,200000 }
; int ts[10];

for(int i=0;i<10;i++){
int n=ran[i];
int curr=time(NULL);

int arr[n];

for(int i=0;i<n;i++){
cin>>arr[i];
}
for (int i = 0; i < n-1; i++){
int min_idx = i;
for (int j = i+1; j < n; j++){if (arr[j]
< arr[min_idx]) min_idx = j;
}

int temp = arr[min_idx];

arr[min_idx] = arr[i]; arr[i] =
temp;
}

ts[i]=time(NULL)-curr;
cout<<ts[i]<<" ";

}
return 0;
}

SELECTION_SORT
700
600
500
400
300
200
100
0
10000 20000 30000 40000 80000 100000 120000 150000 180000 200000

Best case Avg Case Worst Case

Insertion Sort

#include <bits/stdc++.h>
#include <fstream>
#include <stdio.h> #include
<string> #include <time.h>
using namespace std;
int main(void)
{
clock_t start_b,end_b;
double t;
vector<int> a(100000);
int i = 0;
FILE *f;
if (f = fopen("random.txt", "r"))
{

while (fscanf(f, "%d", &a[i]) != EOF)

{
if(i>a.size())
break;
i++;
}
fclose(f);
start_b =clock();
int i, key, j;
for (i = 1; i < z*10000; i++)
{
key =a[i];
j = i - 1;
while (j >= 0 && a[j] > key)
{
a[j + 1] = a[j];
j = j - 1;
}
a[j + 1] = key;
}
end_b=clock();
for(int i=0;i<100000;i++)
cout<<a[i]<<endl;
t=((double)(end_b-start_b))/CLOCKS_PER_SEC;
cout<<t;

}
return 0;
}
 Graph

INSERTION SORT
200

150

100

50

0
10000 20000 30000 40000 50000 100000 120000 150000 180000 200000

Best case Avg Case Worst Case

2. Objective: To implement the Linear Search and Binary Search and find the
number ofcomparisons and analyze the time complexity from its graph.
Linear Search

#include <bits/stdc++.h>
#include <fstream>
#include <stdio.h> #include
<string> #include <time.h>
using namespace std; int
main(void)
{ clock_t start_b,end_b;
double t;
vector<int> a(100000);
int i = 0;
FILE *f;
if (f = fopen("file1.txt", "r"))
{

while (fscanf(f, "%d", &a[i]) != EOF)

{
if(i>a.size())
break;
i++;
}
fclose(f);
for(int z=1;z<11;z++)
{
int x=10;
int c=0;
 for(int i=0;i<z*10000;i++)
{
if(a[i]==x)
{
break;
}
else c++;
}
cout<<c<<endl;
}
}
return 0;
}

Graph

Binary Search

#include <bits/stdc++.h>
#include <fstream>
#include <stdio.h> #include
<string> #include <time.h>
using namespace std; int
main(void)
{
clock_t start_b,end_b;
double t;
vector<int> a(100000);
int i = 0;
FILE *f;
if (f = fopen("file1.txt", "r"))
{
while (fscanf(f, "%d", &a[i]) != EOF)
{
if(i>a.size())
break;
i++;
}
fclose(f);
for(int z=1;z<11;z++)
{
int x=1000;
int c=0;
int l=0,r=z*10000;
while (l <= r) {
int m = l + (r - l) / 2;
if (a[m] == x)
{ c+
+;
cout<<m<<endl;
}
if (a[m] < x)
{
l = m + 1;
c++;
}
else
{
r = m - 1;
c++;
}
}
cout<<c<<endl;
}
}
return 0;
}

Graph
 BINARY SEARCH
18
16
14
12
10
8
6
4
2
0
50000 35000 20000 15000 10000 5000 4000 3000 2500 1000

3. Objective: To implement the CountingSort and Radix Sort and

analyze thetime complexity from its graph.

Count Sort
#include <bits/stdc++.h>
#include <fstream>
#include <stdio.h> #include
<string> #include <time.h>
using namespace std;
void countingsort(vector<int>&vt,int n,int t)
{ long int arr[t+1];
long int c[n];
for(int i=0;i<=t;i++){
arr[i]=0;
}
for(int i=0;i<n;i++){
arr[vt[i]]++;
}
for(int i=1;i<=t;i++)
{ arr[i]=arr[i]+arr[i-
1];
}
for(int i=n-1;i>=0;i--){
c[--arr[vt[i]]]=vt[i];
}
}
int main(){
freopen("count.txt","r",stdin);
vector<int> vt1(100000); for(int
i=0;i<100000;i++){ cin>>vt1[i];
}
int
Range[10]={100000,90000,80000,70000,60000,50000,40000,30000,20000,10000};
for(int i=0;i<10;i++)
{ cloct_t start,end;
int tests=Range[i];
vector<int>vt=vt1;
start=clock();
countingsort(vt,tests-1,10);
end=clock();
double total_time=double(end-start)/CLOCTS_PER_SEC; cout<<"time
taken for "<<tests<<" inputs is : "<<total_time<<endl;
}
}

Radix Sort
#include <bits/stdc++.h>
#include <fstream>
#include <stdio.h> #include
<string> #include <time.h>
using namespace std;
void print(vector<string>& st, int n)
{
for (int i = 0; i < n; i++)
{ cout << st[i] << " ";
}
cout <<endl;
}
int char_at(string st, int k)
{
if (st.size() <= k)
return -1;
else
return st.at(k);
}
void radix sort(vector<string>& st, int lo, int hi, int k)
{
if (hi <= lo) {
return;
}
int count[256 + 2] = { 0 };
unordered_map<int, string> temp; for
(int i = lo; i <= hi; i++) {
int c = char_at(st[i], k);
count[c+2]++;
}
 for (int r = 0; r < 256 + 1; r++)
count[r + 1] += count[r];
for (int i = lo; i <= hi; i++)
{ int c = char_at(st[i], k);
temp[count[c+1]++] = st[i];
}
for (int i = lo; i <= hi; i++)
st[i] = temp[i - lo];
for (int r = 0; r < 256; r++)
radixsort(st, lo + count[r], lo + count[r + 1] - 1,k + 1);
}
int main()
{
freopen("radix.txt","r",stdin);
vector<string> v1(100000);
for(int i=0;i<100000;i++)
cin>>v1[i];
int range[10]={1000,2000,3000,4000,5000,6000,7000,8000,9000,10000};
for(int i=0;i<10;i++)
{ clock_t ti,tf;
int inputs=range[i];
vector<string>v=v1;
v.resize(inputs); ti=clock();
radixsort(v,0,inputs-1,0);
tf=clock();
double tt=double(tf-ti)/CLOCKS_PER_SEC;
//print(v,inputs);
cout<<" "<<tt<<endl;
}
}

4. Objective: To implement the Heap Sort and analyze the time complexity
from its graph.

Heap Sort
#include <bits/stdc++.h>
#include <fstream>
#include <string> #include
<stdio.h>
using namespace std;

#include <time.h>

void heapify(vector<int>arr, int N, int i)

{
 int largest = i;

int l = 2 * i + 1;

int r = 2 * i + 2;

if (l < N && arr[l] >

arr[largest]) largest = l;

if (r < N && arr[r] > arr[largest])

largest = r;

if (largest != i) { swap(arr[i],
arr[largest]);

heapify(arr, N, largest);
}
}
void heapSort(vector<int>arr, int N)
{
for (int i = N / 2 - 1; i >= 0; i–
heapify(arr, N, i);

for (int i = N - 1; i > 0; i--) {

swap(arr[0], arr[i]);

heapify(arr, i, 0);
}
}
int main(void)
{
clock_t start, end; double
cpu_time_used;
vector<int>v(100000);
 int i = 0;
FILE *file;

if (file = fopen("f2.txt", "r"))

{ int x;
while (fscanf(file, "%d", &v[i]) != EOF)
{
if(i>v.size())
break;
i++;

}
fclose(file);
int n=v.size();
int hold;
start = clock();
heapSort(v, n);
end = clock();

cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;

cout<<cpu_time_used }
return 0;
}
BEST CASE AVERAGE WORST C
CASE

0.14 0.187 0.343 10000

0.281 0.375 0.906 20000

0.453 1.319 7.17 30000

0.734 2.765 13.386 40000

1.249 3.921 18.527 50000

2.062 7.326 37.096 60000

5.374 14.662 68.875 70000

8.455 21.41 96.808 80000

7.905 27.321 120.814 90000

14.069 33.523 146.732 100000

5. Objective: To implement the Merge Sort and Quick Sort algorithm and analyze
the timecomplexity from its graph.

Merge Sort

#include <bits/stdc++.h>
#include <fstream>
#include <stdio.h>
using namespace std;
#include <time.h>
void merge(vector<int>a, int x, int b, int c) {

int n1 = b- x + 1;
int n2 = c-b;
int L[n1], M[n2];
for (int i = 0; i < n1; i++)
L[i] = a[l+ i];
for (int j = 0; j < n2; j++)
M[j] = a[b + 1 + j];

int i, j, k;
i = 0;
j = 0;
k = x;
while (i < n1 && j < n2)
{ if (L[i] <= M[j]) {
a[k] = L[i];
i++;
} else
{ a[k] =
M[j]; j++;
} k+
+;
}
while (i < n1) {
a[k] = L[i]; i+
+;
k++;
}
while (j < n2) {
a[k] = M[j]; j+
+;
k++;
}
}
void mergeSort(vector<int>a, int l, int r) { if
(l < r) {
int m = l + (r - l) / 2;
mergeSort(a, l, m);
mergeSort(a, m + 1, r);
merge(a, l, m, r);
}
}
int main(void)
{
clock_t start,end;
double t;
vector<int> v(10000);
int i = 0;
FILE *file;
if (file = fopen("random.txt", "r"))
{
int x;
while (fscanf(file, "%d", &v[i]) != EOF)
{
if(i>v.size())
break;
i++;
}
fclose(file);
int n=v.size();
start =clock();

mergeSort(v,0,n-1);
end=clock();
t=((double)(end-start))/CLOCKS_PER_SEC;
cout<<t;
}
return 0
;}
 BEST CASE AVERAGE WORST C
CASE

0.53 0.35 0.36 10000

1.6 1.12 1.52 20000

1.82 1.95 1.96 30000

3.65 3.65 3.67 40000

5.74 5.36 5.8 50000

7.94 7.88 8.01 60000

18.64 18.76 18.71 70000

25.25 25.63 25.41 80000

40.69 40.72 40.71 90000

51.78 52.05 52.81 100000

Quick Sort

#include <bits/stdc++.h>
#include <fstream>
#include <stdio.h>
using namespace std;
#include <time.h>
void swap(int* x, int* y)
{ int t = *x;
*x = *y;
*y = t;
}
int partition(vector<int>a, int l, int h) { int
pivot = a[h];
int i= (l- 1);
for (int k = l; k <= h - 1; k++)
{ if (a[k] < pivot)
{ k++;
swap(&a[i], &a[k]);
}
}
swap(&a[i + 1], &a[h]);
return (i + 1);
}
void quickSort(vector<int>a, int l, int h) { if
(l < h) {
int p = partition(a, l, h);
quickSort(a, l, p - 1);
quickSort(a, p + 1, h);
}
}
int main()
{
clock_t start,end;
double t;
vector<int> vec(20000); int
i = 0;
FILE *file;
if (file = fopen("file1.txt", "r"))
{
int a;
while (fscanf(file, "%d", &vec[i]) != EOF)
{
if(i>vec.size())
break;
i++;
}
fclose(file);
int n=vec.size();
start =clock();
 quickSort(vec,0,n-1);
end=clock();
t=((double)(end-start))/CLOCKS_PER_SEC;
cout<<t;
}
return 0;
}
BEST CASE AVERAGE WORST C
CASE

0.53 0.35 1.12 10000

1.6 1.12 2.35 20000

1.82 1.95 2.98 30000

3.65 3.65 3.97 40000

5.74 5.36 5.98 50000

7.94 7.88 9.02 60000

18.64 18.71 19.05 70000

25.25 25.61 26.36 80000

40.69 40.65 42.15 90000

51.78 52.12 56.01 100000

Objective : To find the maximum and minimum numbers in a given array.

Theory : If n is odd then initialize min and max as the first element.
If n is even then initialize min and max as minimum and maximum of the first two elements respectively.
For the rest of the elements, pick them in pairs and compare their
maximum and minimum with max and min respectively

#include<bits/stdc++.h>
using namespace std;

struct Pair
{
int min;
int max;
};

struct Pair getMinMax(int arr[], int n)

{
struct Pair minmax;
int i;
if (n % 2 == 0)
{
if (arr[0] > arr[1])
{
minmax.max = arr[0];
minmax.min = arr[1];
}
else
{
minmax.min = arr[0];
minmax.max = arr[1];
}
i = 2;
}
else
{
minmax.min = arr[0];
minmax.max = arr[0];

i = 1;
}
while (i < n - 1)
{
if (arr[i] > arr[i + 1])
{
if(arr[i] > minmax.max)
minmax.max = arr[i];
 if(arr[i + 1] < minmax.min) minmax.min
= arr[i + 1];
}
else
{
if (arr[i + 1] > minmax.max)
minmax.max = arr[i + 1];

if (arr[i] < minmax.min)

minmax.min = arr[i];
}
i += 2;
}
return minmax;
}
int main()
{
int n;
cout<<"Enter the number of element : ";
cin>>n;
cout<<endl<<"Enter the elements : "; int
arr[n];
for(int i=0;i<n;i++)
{
cin>>arr[i];
}
Pair res=getMinMax(arr,n);
cout<<"Minimum Element is : "<<res.min<<endl; cout<<"Maximum
Element is : "<<res.max<<endl;
}

Objective : To find the Kth smallest number in a given array .

Theory : Used Priority Queue, and inserted first K elements in the array. Then ,for remaining
,each time we compare it with the top element of the priority queue , if the top element is greater than the
current element then we pop front the priority queue and insert the current element into the priority
queue.
#include<bits/stdc++.h>
using namespace std;
int findKthMin(int arr[],int n,int k)
{
priority_queue<int>pq;

for(int i=0;i<k;i++)
{
pq.push(arr[i]);
}
int ans;
for(int i=k;i<n;i++)
{
if(arr[i]<pq.top())
{
pq.pop();
pq.push(arr[i]);
}
}
return pq.top();
}
int main()
{
int n;
cout<<"Enter the number of element : ";
cin>>n;
cout<<endl<<"Enter the elements : "; int
arr[n];
for(int i=0;i<n;i++)
{
cin>>arr[i];
}
int k;
cout<<"Enter the value of k : ";
cin>>k;
int res=findKthMin(arr,n,k);
cout<<"Kthe = "<<k<<" smallest element is : "<<res<<endl;
}
Objective : To implement the Prim’s Algorithm to find a Minimum Spanning Tree.

Theory : Prim's Algorithm converts it to a tree such that the sum of all edges of the tree is minimum.
Such a tree is called a Minimum Spanning Tree.
It "scs tkc gíccdQ appíoack to fi⭲d tkis mi⭲im"m spa⭲⭲i⭲g tícc.

#include<bits/stdc++.h>

using namespace std;

#define V 6

int selectMinVertex(vector<int> &value, vector<bool>& setMST){ int

minimum = INT_MAX;
int vertex;
for(int i = 0; i < V; i++){
if(setMST[i] == false && value[i] < minimum)
{ vertex = i;
minimum = value[i];
}
}
return vertex;
}

void printMst(int parent[], int graph[V][V])

{ cout << "Src.\tDest.\tWeight\n";
for(int i = 1; i < V; i++){
cout << i << "\t" << parent[i] << "\t" << graph[i][parent[i]] << "\n";
}
}

void findMST(int graph[V][V])

{ int parent[V];
vector<int> value(V, INT_MAX);
vector<bool> setMST(V, false);

parent[0] = -1;
value[0] = 0;

for(int i = 0; i < V-1; i++){

int U = selectMinVertex(value, setMST); setMST[U]
= true;

for(int j = 0; j < V; j++){

if(graph[U][j] != 0 && setMST[j] == false && graph[U][j] < value[j])
{ value[j] = graph[U][j];
parent[j] = U;
}
}
 }
printMst(parent, graph);
}

int main(){
int graph[V][V] = {
{0, 4, 6, 0, 8, 8},
{4, 0, 6, 3, 4, 8},
{6, 2, 0, 1, 8, 1},
{0, 3, 6, 0, 2, 2},
{0, 4, 4, 2, 0, 3},
{0, 0, 0, 3, 7, 4},
};
findMST(graph);
return 0;
}

Objective : To implement the Kruskal’ s Algorithm to find a Minimum Spanning Tree

Theory : Kruskal’s algorithm to find the minimum cost spanning tree uses the greedy approach. The
Greedy Choice is to pick the smallest weight edge that does not cause a cycle in the MST constructed so
far.
#include<bits/stdc++.h>
using namespace std;

class DSU{

int *parent;
int *rank;
public:
 DSU(int n){

parent=new int[n];
rank=new int[n];
for(int i=0;i<n;i++)
{
parent[i]=i;
rank[i]=0;
}
}

int find(int node)

{ if(node==parent[node]) return node;
return parent[node]=find(parent[node]);
}

void Union(int u,int v){

u=find(u);
v=find(v);
if(u!=v)
{
if(rank[u]<rank[v])
{
int temp=u;
u=v;
v=temp;
}
parent[v]=u;

if(rank[u]==rank[v])
rank[u]++;
}
}
};
class Edge{ public:

int u,v,weight;

Edge(int U,int V,int Weight){

u=U;
v=V;
weight=Weight;
}
};
class Graph{
public:

int V, E; vector<Edge>
edges;
 Graph(int v,int e){
V=v;
E=e;
}
static bool comparator(Edge e1, Edge e2)
{
return e1.weight < e2.weight;
}
void MST_Kruskal(){

int e=0,i=0,sum=0;
DSU dsu(V);
sort(edges.begin(), edges.end(), comparator);
while(e<V-1)
{
Edge edge=edges[i++];

int u=dsu.find(edge.u);
int v=dsu.find(edge.v);
if(u!=v)
{
cout<<"Adding edge "<<edge.u<<" <---> "<<edge.v<<" to MST\n";

sum+=edge.weight; dsu.Union(u,v);

e++;
}
}

cout<<"MST has a weight of "<<sum;

}

void addEdge(int u,int v,int weight){

edges.push_back(Edge(u,v,weight));
}
};
int main(){

Graph g(6,9);
g.addEdge(0,1,5);
g.addEdge(0,3,8);
g.addEdge(1,9,3);
g.addEdge(1,4,6);
g.addEdge(2,3,4);
g.addEdge(1,4,4);
g.addEdge(8,4,2);
g.addEdge(4,5,2);
g.addEdge(4,5,2);

g.MST_Kruskal();
 return 0;
}

Objective : To implement Matrix Chain Multiplication using Dynamic Programming .

Theory : We will use almost the same approach as Recursive Implementation with the only change that,
we will maintain a 2-D array (say dp) of dimensions
n\times n
n×n all of whose entries initialized with -1 where dp[i][j] stores result for the sub-problem i..j. So for
calculating the answer for the sub-problem i..j firstly we will check if we already have calculated the
answer for it in past, by checking that if dp[i][j]!=-1. So if we already have calculated the answer for it
we need not solve it again instead, we can simply return dp[i][j].

#include<bits/stdc++.h>
using namespace std;

int **dp;

int MatrixChainMultiplication(int mat[],int low, int high){

if(low==high)
return 0;

if(dp[low][high]!=-1)
return dp[low][high];

dp[low][high]=INT_MAX;
for(int k=low;k<high;k++){
int cost=MatrixChainMultiplication(mat, low, k)+
MatrixChainMultiplication(mat, k+1, high)+
mat[low-1]*mat[k]*mat[high];
if(cost<dp[low][high])
dp[low][high]=cost;
}
return dp[low][high];
}
int main(){
int mat[]={2, 4, 6, 8, 6};
int n=sizeof(mat)/sizeof(mat[0]);
dp=new int*[n];
for(int i=0;i<n;i++)
{ dp[i]=new int[n];
for(int j=0;j<n;j++)
dp[i][j]=-1;
}
cout<<"Minimum number of steps are : ";
cout<<MatrixChainMultiplication(mat, 1, n-1);
return 0;
}

Objective : To implement Longest Common Subsequence Problem using Dynamic Programming .

Theory : The method of dynamic programming reduces the number of function calls. It stores the result
of each function call so that it can be used in future calls without the need for redundant calls.The time
taken by a dynamic approach is the time taken to fill the table (ie.
O(mn)).

#include <bits/stdc++.h>
using namespace std;

void lcsAlgo(char *S1, char *S2, int m, int n) { int

LCS_table[m + 1][n + 1];

for (int i = 0; i <= m; i++)

{ for (int j = 0; j <= n; j++)
{ if (i == 0 || j == 0)
LCS_table[i][j] = 0;
else if (S1[i - 1] == S2[j - 1])
LCS_table[i][j] = LCS_table[i - 1][j - 1] + 1; else
LCS_table[i][j] = max(LCS_table[i - 1][j], LCS_table[i][j - 1]);
 }
}

int index = LCS_table[m][n];

char lcsAlgo[index + 1];
lcsAlgo[index] = '\0';

int i = m, j = n;
while (i > 0 && j > 0) {
if (S1[i - 1] == S2[j - 1]) {
lcsAlgo[index - 1] = S1[i - 1];
i--;
j--;
index--;
}

else if (LCS_table[i - 1][j] > LCS_table[i][j - 1])

i--;
else
j--;
}
cout << "S1 : " << S1 << "\nS2 : " << S2 << "\nLCS: " << lcsAlgo << "\n";
}

int main() {
char S1[] = "abcdabab";
char S2[] = "acdbcba"; int
m = strlen(S1);
int n = strlen(S2);
lcsAlgo(S1, S2, m, n);
}
Objective : To do the case study of P , NP , NP Complete , NP Hard Problem.

P Class
The P in the P class stands for Polynomial Time. It is the collection of decision problems(problems
with a “yes” or “no” answer) that can be solved by a deterministic machine in polynomial time.
Features:
1. The solution to P problems is easy to find.
2. P is often a class of computational problems that are solvable and tractable. Tractable means
that the problems can be solved in theory as well as in practice. But the problems that can be
solved in theory but not in practice are known as intractable.

This class contains many natural problems like:

1. Calculating the greatest common divisor.
2. Finding a maximum matching.
3. Decision versions of linear programming.

NP Class
The NP in NP class stands for Non-deterministic Polynomial Time. It is the collection of decision
problems that can be solved by a non-deterministic machine in polynomial time.
Features:
1. The solutions of the NP class are hard to find since they are being solved by a non-
deterministic machine but the solutions are easy to verify.
2. Problems of NP can be verified by a Turing machine in polynomial time.

This class contains many problems that one would like to be able to solve effectively:

1. Boolean Satisfiability Problem (SAT).

2. Hamiltonian Path Problem.
3. Graph coloring.
 NP-hard class

An NP-hard problem is at least as hard as the hardest problem in NP and it is the class of the problems
such that every problem in NP reduces to NP-hard.

Features:

1. All NP-hard problems are not in NP.

2. It takes a long time to check them. This means if a solution for an NP-hard problem is
given then it takes a long time to check whether it is right or not.
3. A problem A is in NP-hard if, for every problem L in NP, there exists a
polynomial-time reduction from L to A.

Some of the examples of problems in Np-hard are:

1. Halting problem.
2. Qualified Boolean formulas.
3. No Hamiltonian cycle.

NP-complete class

A problem is NP-complete if it is both NP and NP-hard. NP-complete problems are the hard problems in
NP.

Features:

1. NP-complete problems are special as any problem in NP class can be transformed or

reduced into NP-complete problems in polynomial time.
2. If one could solve an NP-complete problem in polynomial time, then one could also solve
any NP problem in polynomial time.
3. Some example problems include:
1. Decision version of 0/1 Knapsack.
2. Hamiltonian Cycle.
3. Satisfiability.
4. Vertex cover.