new question added

Author: arorarahul

README.md

@@ -123,6 +123,7 @@ values.
 value to be at the top of the tree with min edge length (or path to be traversed) and min at bottom with
 max edge or path to be traversed to minimize work.
 - Min cost spanning tree and shortest path problems are two different things. In shortest path a source will be given and we will have to reach the target in the shortest path possible given weight of each edge. In case of min cost spanning tree we have to construct a graph with min weight possible connecting ALL the nodes. Therefore priority of the algo varies
+- In greedy method, to min or max something (different methods), we can be greedy about something to solve the algo, and bring in cases which can defy out method. One of them will work.
 
 # Topic0: Programming Questions
 
@@ -298,6 +299,8 @@ max edge or path to be traversed to minimize work.
 - [Program for DIJKSTRA algorithm](/greedy/question7.c)
 - [Program to implement a simple graph](/greedy/question8.c)
 - [Consider n-ropes with different length. Find algo to tie up all the rope into a single rope with min cost](/greedy/question9.c)
+- [Find max intervals from given intervals such that none of them are overlapping](/greedy/question10.c)
+- [Number of railway platforms](/greedy/question11.c)
 
 ## Some important concepts to solve algos better
 

code/test1.c

@@ -0,0 +1,6 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(){
+	return 0;
+}

code/test2.c

@@ -0,0 +1,13 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+
+int main(){
+	int cases;
+	scanf("%d",&cases);
+	int i;
+	for(i=0;i<cases;i++){
+		
+	}
+	return 0;
+}

code/test3.c

@@ -0,0 +1,88 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int checkOperations(int *arr, int size){
+	int sum = 0;
+	if(size%2==0){
+		int sum1 = 0;
+	
+		sum1 = sum1 + arr[0];
+		arr[0] = 0;
+		int i,j;
+		for(i=1; i<=(size/2);i++){
+			sum1 += (arr[i]-i);
+		}
+		int sub = 1;
+		for(j=size-1;j>=(size/2)+1;j--){
+			sum1 += (arr[j]-sub);
+			sub++;
+		}
+
+		int sum2 = 0;
+		sum2 = sum2 + arr[size-1];
+		arr[size-1] = 0;
+		int k,l;
+		for(k=0; k<=(size-1)/2;k++){
+			sum2 += (arr[k]-(k+1));
+		}	
+		int val = 1;
+		for(l=(size-2);l>=(((size-1)/2)+1);l--){
+			sum2 += (arr[l]-val);
+			val++;
+		}
+		sum = (sum1 < sum2)?sum1:sum2;
+		
+	}else{
+		int i,j;
+		for(i=0; i<=(size/2);i++){
+			sum += (arr[i]-(i+1));
+		}
+		int sub = 1;
+		for(j=size-1;j>=(size/2)+1;j--){
+			sum += (arr[j]-sub);
+			sub++;
+		}
+	}
+	return sum;
+}
+
+
+int checkOperations(int *arr, int start, int end){
+
+	int middle = (start-end)/2;
+	int size = end+1;
+	int value = (size/2)+1;
+
+	if(arr[middle] >= value || arr[middle-1] >=value){
+		return calculate(arr,start, end);
+	}
+	int subSize;
+	if(size%2==0){
+		subSize = size-3;
+	}else{
+		subSize= size-2;
+	}
+
+	int i;
+	for(i=0;i<size-subSize;i++){
+		j=subSize;
+		checkOperations(arr,i,j);
+	}
+	
+}
+
+int main(){
+	int cases,blocks;
+	scanf("%d",&cases);
+	int i, j;
+	for(i=0;i<cases;i++){
+		scanf("%d",&blocks);
+		int arr[blocks];
+		for(j=0;j<blocks;j++){
+			scanf("%d",&arr[j]);
+		}
+		int number = checkOperations(arr,0,blocks-1);
+		printf("%d\n", number);
+	}
+	return 0;
+}

greedy/question10.c

@@ -0,0 +1,69 @@
+/*
+Find max intervals from given intervals such that none of them are overlapping
+
+METHOD:
+we can go by three methods here but only one works fine
+Greedy about duration: Thought process is to be greedy about duration and choose the one with min
+duration so that probability of overlapping is less. But in this case if a short duration is
+overlapping in between two big durations, we wont be able to pick the other two. So wont give us the
+max output
+
+Greedy about start time. Choose start time as early as possible. That can minimize overlapping. But
+if something starts very early and ends really late, we wont be able to pick the other durations cos
+of that
+
+Greedy about end time: This is the correct method because in this case we can have max outputs.
+
+*/
+#include <stdio.h>
+#include <stdlib.h>
+
+int cmpfunc(const void *a, const void *b){
+	return (*(int *)a - *(int *)b);
+}
+
+struct node{
+	int left;
+	int right;
+};
+
+int maxIntervals(struct node *arr, int size){
+	int counter = 1;
+	for(int i=0; i<size-1; i++){
+		if(arr[i].right < arr[i+1].left){
+			counter++;			
+		}
+	}
+	if(counter == 1){
+		return counter;
+	}
+	return counter+1;
+}
+
+int main(){
+	int size = 6;
+	struct node *arr = (struct node *)malloc(sizeof(struct node)*size);
+	
+	arr[0].right = 11;
+	arr[0].left = 7;
+	
+	arr[1].right = 13;
+	arr[1].left = 10;
+
+	arr[2].right = 14;
+	arr[2].left = 9;
+
+	arr[3].right = 16;
+	arr[3].left = 12;
+
+	arr[4].right = 25;
+	arr[4].left = 20;
+
+	arr[5].right = 50;
+	arr[5].left = 1;
+
+	//already sorted
+	int max = maxIntervals(arr,size);
+	printf("max intervals are %d\n", max);
+	return 0;
+}

greedy/question11.c

@@ -0,0 +1,60 @@
+/*
+Number of railway platforms
+What is the min number of railway platforms required such that all trains will stand at station w/o colliding
+given train names and arrival time and departure time.
+
+METHOD:
+We will be given arrival and departures times for different trains. Basis that we need to find the min
+platforms requires at any given time so that trains do not collide
+
+One method is to find all intervals that overlap with each other and see how many trains are the maximum
+at any instance of time.
+
+Other method is to sort all given values and place them in a single array. Then see if they are arrival
+or departure. If they are arrival increment counter, for departure decrement counter. Maintain a variable
+to record the max value from the scan. That will be the answer
+
+Time complexity: O(nlogn) //sorting the inputs
+Space complexity: O(n) //because we will store it in structure
+*/
+#include <stdio.h>
+#include <stdlib.h>
+
+int calculatePlatforms(int arr[], int dep[],int size){
+	int counter = 0;
+	int max = 0;
+	int i = 0,j=0;
+	while(i < size && j < size){
+		// printf("arrival is %d\n", arr[i]);
+		// printf("dep is %d\n", dep[j]);
+		if(arr[i]<dep[j]){
+			counter++;
+			i++;
+		}else{
+			counter--;
+			j++;
+		}
+		if(max < counter){
+			max = counter;
+		}
+	}
+	return max;
+}
+
+int cmpfnc(const void *a, const void *b){
+	return (*(int *)a - *(int *)b);
+}
+
+int main(){
+	int arr[] = {1000,1015,1030,1040};
+	int dep[] = {1020,1400,1500,1055};
+
+	int size = sizeof(arr)/sizeof(arr[0]);
+
+	qsort(arr,size,sizeof(int),cmpfnc);
+	qsort(dep,size,sizeof(int),cmpfnc);
+
+	int minPlatforms = calculatePlatforms(arr,dep,size);
+	printf("min platforms req are %d\n", minPlatforms);
+	return 0;
+}

nextquestions.md

@@ -63,4 +63,5 @@ TODO:
 - strings question12 to be done
 - min heap implementation of PRIMS in greedy
 - solve KRUSKAL from greedy
-- solve DIJKSTRA alog from greedy
+- solve DIJKSTRA alog from greedy
+- greedy question2 to be seen from geeks for geeks