Added more problems

Author: Mehulcoder

DP1(Very important)/Hasanandtrip.cpp

@@ -0,0 +1,102 @@
+/*
+
+				Name: Mehul Chaturvedi
+				IIT-Guwahati
+
+*/
+
+/*
+				PROBLEM STATEMENT
+Hasan has finally finished his final exams and he decided to go in a trip among cities in Syria.
+There are N cities in Syria and they are numbered from 1 to N, each city has coordinates on plane, i-th city is in (Xi, Yi).
+Hasan is in first city and he wants to visit some cities by his car in the trip but the final destination should be N-th city and the sequence of cities he will visit should be increasing in index (i.e. if he is in city i he can move to city j if and only if i < j ).
+Visiting i-th city will increase Hasan's happiness by Fi units (including first and last cities), also Hasan doesn't like traveling too much, so his happiness will decrease by total distance traveled by him.
+Help Hasan by choosing a sequence of cities to visit which maximizes his happiness.
+Input format:
+First line contain integer N.
+Next N lines contains three integers each, i-th line contains coordinates of i-th city Xi, Yi and Fi.
+Output format:
+Output one number rounded to 6 digits after floating point, the maximum possible happiness Hasan can get. Note: If answer is 2 print 2.000000
+Constraints:
+1 <= N <= 3,000
+0 <= Xi, Yi, Fi <= 100,000
+Sample Input
+3
+0 0 1
+3 1 1
+6 0 9
+Sample Output
+4.675445
+
+*/	
+#include <bits/stdc++.h>
+
+using namespace std;
+
+class city{
+public:
+	int x;
+	int y;
+	int happiness;
+};
+double distance(city a, city b){
+	double ans = 0;
+	long long X = (long long)pow(a.x-b.x, 2);
+	long long Y = (long long)pow(a.y-b.y, 2);
+	
+	ans = (double)sqrt(X+Y);
+	return ans;
+}
+double go(vector<city> v){
+	int n = v.size();
+	vector<double> dp(n, 0);
+	dp[0] = v[0].happiness;
+
+	for (int i = 1; i < n; ++i)
+	{
+		double temp = -1e9;
+		for (int j = 0; j <i; ++j)
+		{
+			temp = max(temp, dp[j]+v[i].happiness-distance(v[i], v[j]));
+		}
+		dp[i] = temp;
+		//cout << "dp[i] "<<i<<" "<<dp[i] << '\n';
+
+
+		//dp[i] = max(dp[0]+v[i].happiness-distance(v[0],v[i]), dp[i-1]+v[i].happiness-distance(v[i-1], v[i]));
+	}
+
+	return dp[n-1];
+}
+
+int main( int argc , char ** argv )
+{
+	ios_base::sync_with_stdio(false) ; 
+	cin.tie(NULL) ; 
+	
+	int n;
+	cin>>n;
+	std::vector<city> v;
+	for (int i = 0; i < n; ++i)
+	{
+		int a;
+		int b;
+		int c;
+		cin>>a>>b>>c;
+		city temp;
+		temp.x = a;
+		temp.y = b;
+		temp.happiness = c;
+		v.push_back(temp);
+	}
+
+	//cout << distance(v[0], v[1]) << '\n';
+
+	cout <<fixed << setprecision(6)<< go(v) << '\n';
+
+
+	return 0 ; 
+
+
+
+}

DP1(Very important)/Test.txt

@@ -1,2 +1,2 @@
-8
-1 3 3 4 5 5 6 6
+3
+1 2 3

DP1(Very important)/Vanya and gcd

@@ -0,0 +1,101 @@
+/*
+
+				Name: Mehul Chaturvedi
+				IIT-Guwahati
+
+*/
+
+/*
+				PROBLEM STATEMENT
+Vanya has been studying all day long about sequences and other Complex Mathematical Terms. She thinks she has now become really good at it. So, her friend Vasya decides to test her knowledge and keeps the following challenge it front of her:
+Vanya has been given an integer array A of size N. Now, she needs to find the number of increasing sub-sequences of this array with length ≥1 and GCD=1. A sub-sequence of an array is obtained by deleting some (or none) elements and maintaining the relative order of the rest of the elements. As the answer may be large, print it Modulo 109+7
+She finds this task really easy, and thinks that you can do it too. Can you?
+Input Format:
+The first line contains a single integer N denoting size of array A. The next line contains N space separated integers denoting the elements of array A
+Output Format:
+Print the required answer Modulo 10^9+7 on a single line.
+Constraints:
+1≤N≤500
+
+1≤A[i]≤100
+Sample Input
+3
+1 2 3
+Sample Output
+5
+*/
+
+#include <bits/stdc++.h>
+
+using namespace std;
+int go(vector<int> v){
+	int n = v.size();
+	vector<vector<int>> dp(101, vector<int>(n, 0));
+
+	for (int i = 0; i < n; ++i)
+		{
+			dp[v[i]][i] = 1;
+		}	
+
+	for (int i = 0; i < n; ++i)
+	{
+		for (int j = 0; j < i; ++j)
+		{
+			if (v[i]>v[j])
+			{
+				for (int k = 1; k < 101; ++k)
+				{
+					int gcn = __gcd(k, v[i]);
+					dp[gcn][i] = (dp[gcn][i]+dp[k][j])%1000000007;
+				}
+			}
+		}
+	}
+
+	int ans = 0;
+
+	// for (int i = 1; i < 101; ++i)
+	// {
+	// 	for (int j = 0; j < n; ++j)
+	// 	{
+	// 		cout<<dp[i][j]<<" ";
+	// 	}
+	// 	cout <<'\n';
+	// }
+
+	for (int i = 0; i < n; ++i)
+	{
+		ans=(ans+ dp[1][i])%1000000007;
+	}
+
+	return ans%1000000007;
+
+
+
+
+}
+
+int main( int argc , char ** argv )
+{
+	ios_base::sync_with_stdio(false) ; 
+	cin.tie(NULL) ; 
+	
+
+	int n;
+	cin>>n;
+	vector<int> v(n, 0);
+
+	for (int i = 0; i < n; ++i)
+	{
+		cin>>v[i];	
+	}
+
+	cout << go(v) << '\n';
+
+
+
+	return 0 ; 
+
+
+
+}

DP1(Very important)/Vanya and gcd.cpp

@@ -0,0 +1,91 @@
+/*
+
+				Name: Mehul Chaturvedi
+				IIT-Guwahati
+
+*/
+
+/*
+				PROBLEM STATEMENT
+Noor is a teacher. She wants to give some chocolates to the students in her class. All the students sit in a line and each of them has a score according to performance. Noor wants to give at least 1 chocolate to each student. She distributes chocolates to them such that If two students sit next to each other then the one with the higher score must get more chocolates. Noor wants to save money, so she wants to minimise the total number of chocolates.
+Note that when two students have equal score they are allowed to have different number of chocolates.
+Input Format:
+First Line: Integer N, the number of students in Noor’s class. 
+Second Line: Each of the student's score separated by spaces.
+Output Format:
+Output a single line containing the minimum number of chocolates Noor must give.
+Input Constraints
+ 1 <= N <= 100000
+ 1 <= score <= 100000
+Sample Input:
+4
+1 4 4 6
+sample Output:
+6
+Sample Input:
+3
+8 7 5
+sample Output:
+6
+*/
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+int getMin(int *arr, int n){
+	//left case
+
+	std::vector<int> dp(n, 0);
+	dp[0] = 1;
+	for (int i = 1; i < n; ++i)
+	{
+		if(arr[i]>arr[i-1])
+			dp[i] = dp[i-1]+1;
+		else
+			dp[i] = 1;  // made changes here
+	}
+
+
+	dp[n-1] = max(dp[n-1], 1);
+
+	for (int i = n-2; i >= 0; --i)
+	{
+		if(arr[i+1]<arr[i])
+			dp[i] = max(dp[i], dp[i+1]+1);
+		// else
+		// 	dp[i] = max(dp[i+1]-1, dp[i]);
+	}
+	int sum = 0;
+
+	for (int i = 0; i < n; ++i)
+	{
+		sum+=dp[i];
+	}
+
+	return sum;
+
+}
+
+int main( int argc , char ** argv )
+{
+	ios_base::sync_with_stdio(false) ; 
+	cin.tie(NULL) ; 
+	 
+	int n;
+    cin >> n;
+    int *arr = new int[n];
+    for(int i = 0; i < n; i++){
+        cin >> arr[i];
+    }
+
+    cout << getMin(arr, n);
+    delete []arr;
+
+
+
+	return 0 ; 
+
+
+
+}

DP1(Very important)/a.out

@@ -0,0 +1,62 @@
+/*
+
+				Name: Mehul Chaturvedi
+				IIT-Guwahati
+
+*/
+
+/*
+				PROBLEM STATEMENT
+Given an integer N, find and return the count of minimum numbers, sum of whose squares is equal to N.
+That is, if N is 4, then we can represent it as : {1^2 + 1^2 + 1^2 + 1^2} and {2^2}. Output will be 1, as 1 is the minimum count of numbers required.
+Note : x^y represents x raise to the power y.
+Input Format :
+Integer N
+Output Format :
+Required minimum count
+Constraints :
+1 <= N <= 1000
+Sample Input 1 :
+12
+Sample Output 1 :
+3
+Sample Output 1 Explanation :
+12 can be represented as :
+1^1 + 1^1 + 1^1 + 1^1 + 1^1 + 1^1 + 1^1 + 1^1 + 1^1 + 1^1 + 1^1 + 1^1
+1^1 + 1^1 + 1^1 + 1^1 + 1^1 + 1^1 + 1^1 + 1^1 + 2^2
+1^1 + 1^1 + 1^1 + 1^1 + 2^2 + 2^2
+2^2 + 2^2 + 2^2
+As we can see, the output should be 3.
+Sample Input 2 :
+9
+Sample Output 2 :
+1
+*/
+
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+int minCount(int n){
+    //non Recursive solution
+
+    
+	
+}
+
+int main( int argc , char ** argv )
+{
+	ios_base::sync_with_stdio(false) ; 
+	cin.tie(NULL) ; 
+	
+	 int num;
+    cin >> num;
+    cout << minCount(num)<<endl;
+
+
+	return 0 ; 
+
+
+
+}