Bellman ford algo from gfg

Author: Pankajcoder1

Diff for: GFG/Negative_weight_cycle.cpp

@@ -0,0 +1,49 @@
+// { Driver Code Starts
+#include<bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+class Solution {
+public:
+	int isNegativeWeightCycle(int n, vector<vector<int>>edges){
+	    // Code here
+	    vector<int> vertex(n,INT_MAX);
+	    vertex[0]=0;
+	    int V=edges.size();
+	    for(int i=1;i<n;i++){
+	        for(auto x:edges){
+	            int u=x[0],v=x[1],w=x[2];
+	            if(vertex[u]!=INT_MAX&&vertex[v]>vertex[u]+w){
+	                vertex[v]=vertex[u]+w;
+	            }
+	        }
+	    }
+	    for(auto x:edges){
+	        int u=x[0],v=x[1],w=x[2];
+	        if(vertex[u]!=INT_MAX&&vertex[u]+w<vertex[v]){
+	            return 1;
+	        }
+	    }
+	    return 0;
+	}
+};
+
+// { Driver Code Starts.
+int main(){
+	int tc;
+	cin >> tc;
+	while(tc--){
+		int n, m;
+		cin >> n >> m;
+		vector<vector<int>>edges;
+		for(int i = 0; i < m; i++){
+			int x, y, z;
+			cin >> x >> y >> z;
+			edges.push_back({x,y,z});
+		}
+		Solution obj;
+		int ans = obj.isNegativeWeightCycle(n, edges);
+		cout << ans <<"\n";
+	}
+	return 0;
+}  // } Driver Code Ends

Diff for: Hackerearth/Practice/colorful_floors.cpp

@@ -0,0 +1,16 @@
+#include<iostream>
+using namespace std;
+
+int main()
+{
+	int N,K;
+	cin>>N>>K;
+	if(k<=N)
+	{
+		cout<<0<<endl;
+	}
+	else
+	{
+		
+	}
+}

Diff for: Hackerearth/Practice/distribute_chocolates.cpp

@@ -0,0 +1,25 @@
+#include<iostream>
+using namespace std;
+
+int main()
+{
+	int T;
+	// yanh pe agar ans and k ko else ke andar declare karo
+	// ya int declare kiye to wrong dega.
+	long int c,n,ans,k;
+	cin>>T;
+	for(int i=0;i<T;i++)
+	{
+		cin>>c>>n;
+		if(c<(n*(n+1))/2)
+		{
+			cout<<c<<endl;
+		}
+		else
+		{
+			k=(c-(n*(n-1))/2)/n;
+			ans =c-n*k-(n*(n-1))/2;
+			cout<<ans<<endl;
+		}
+	}
+}

Diff for: Hackerearth/Practice/equal_subarray.cpp

@@ -0,0 +1,18 @@
+#include<iostream>
+using namespace std;
+
+int main()
+{
+	int N,K;
+	cin>>N>>K;
+	int *arr=new int[N];
+	for(int i=0;i<N;i++)
+	{
+		cin>>arr[i];
+	}
+	cout<<"array is ";
+	for(int i=0;i<N;i++)
+	{
+		cout<<arr[i];
+	}
+}

Diff for: Hackerearth/Practice/fredo_and_array_update.cpp

@@ -0,0 +1,19 @@
+#include<iostream>
+using namespace std;
+
+int main()
+{
+	int N,sum=0,d;
+	cin>>N;
+	int *arr = new int[N];
+	for(int i=0;i<N;i++)
+	{
+		cin>>arr[i];
+		sum = sum+arr[i];
+	}
+	if(sum%N==0)
+		d=sum/N;
+	else
+		d=(sum/N);
+	cout<<d+1;
+}

Diff for: Hackerearth/Practice/little_shino_common_factor.cpp

@@ -0,0 +1,33 @@
+#include<iostream>
+#include<math.h>
+using namespace std;
+long int hcf(long int a,long int b);
+
+int main()
+{
+	long int a,b,count=0,temp;
+	cin>>a>>b;
+	if(a>b)
+	{
+		temp=a;
+		a=b;
+		b=temp;
+	}
+	temp=hcf(a,b);
+	for(long int i=1;i<=sqrt(temp)+1;i++)
+	{
+		if(a%i==0 && b%i==0)
+		{
+			count ++;
+		}
+	}
+	cout<<count;
+}
+
+long int hcf(long int a,long int b)
+{
+	if(b%a==0)
+		return b;
+	else
+		return hcf(b,b%a);
+}

Diff for: Hackerearth/Practice/set_numbers.cpp

@@ -0,0 +1,29 @@
+#include<iostream>
+using namespace std;
+#include<math.h>
+
+
+int main()
+{
+	int t,N,z=0;
+	int *arr=new int[31];
+	for(int i=0;i<=30;i++)
+	{
+		arr[i]=(pow(2,i)-1);
+	}
+	cin>>t;
+	for(int i=0;i<t;i++)
+	{
+		cin>>N;
+		int previous;
+		for(int j=0;j<30;j++)
+		{
+			previous=arr[j];
+			if(N<arr[j+1])
+			{
+				cout<<previous<<endl;
+				break ;
+			}
+		}
+	}
+}

Diff for: Hackerearth/Practice/zoos.cpp

@@ -0,0 +1,23 @@
+#include<iostream>
+#include<string.h>
+
+using namespace std;
+
+int main()
+{
+	int len=0,c_z=0,c_o=0;
+	string str;
+	cin>>str;
+	len = str.length();
+	for(int i=0;i<len;i++)
+	{
+		if(str[i]=='z')
+			c_z++;
+		else
+			c_o++;
+	}
+	if(c_o==2*c_z)
+		cout<<"Yes"<<endl;
+	else
+		cout<<"No"<<endl;
+}

Diff for: LeetCode/Practice/113.Path_Sum_II.cpp

@@ -0,0 +1,102 @@
+/*
+    written by Pankaj Kumar.
+    country:-INDIA
+    Institute: National Institute of Technology, Uttarakhand
+*/
+typedef long long ll ;
+typedef unsigned long long ull;
+typedef vector<int> vl;
+typedef vector<vector<int>> vvl;
+#define speed cin.tie(0);cout.tie(0);ios_base::sync_with_stdio(0);
+/*  Abbrevations  */
+#define ff first
+#define ss second
+#define mp make_pair
+#define pb push_back
+// loops
+#define forin(arr,n) for(ll i=0;i<n;i++) cin>>arr[i];
+// Some print
+#define no cout<<"NO"<<endl;
+#define yes cout<<"YES"<<endl;
+// sort
+#define all(V) (V).begin(),(V).end()
+#define srt(V) sort(all(V))
+#define srtGreat(V) sort(all(V),greater<ll>())
+// some extra
+#define printv(v) for(ll i=0;i<ll(v.size());i++){cout<<v[i]<<" ";} cout<<endl;
+#define precision(x) cout<<fixed<<setprecision(x);
+#define sz(V) ll(V.size())
+
+
+/* ascii value
+A=65,Z=90,a=97,z=122
+*/
+
+/* Some syntax 
+//Syntax to create a min heap for priority queue
+//priority_queue <int, vector<int>, greater<int>>pq;
+*/
+/*  --------------------MAIN PROGRAM----------------------------*/
+// to run ctrl+b
+const ll INF=1e18;
+const ll mod1=1e9+7;
+const ll mod2=998244353;
+// Techniques :
+// divide into cases, brute force, pattern finding
+// sort, greedy, binary search, two pointer
+// transform into graph
+
+// Experience :
+// Cp is nothing but only observation and mathematics.
+
+
+//Add main code here
+
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    vector<int> path;
+    vector<vector<int>> all_path;
+
+    void dfs(TreeNode* root,int targetSum,int& sum){
+        if(root==nullptr){
+            return ;
+        }
+        sum+=root->val;
+        path.pb(root->val);
+        if(root->left==nullptr&&root->right==nullptr&&sum==targetSum){
+            all_path.pb(path);
+        }
+        dfs(root->left,targetSum,sum);
+        dfs(root->right,targetSum,sum);
+        sum-=root->val;
+        path.pop_back();
+        return ;
+    }
+    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
+        int sum=0;
+        dfs(root,targetSum,sum);
+        return all_path;
+    }
+};
+
+
+
+/* -----------------END OF PROGRAM --------------------*/
+/*
+* stuff you should look before submission
+* constraint and time limit
+* int overflow
+* special test case (n=0||n=1||n=2)
+* don't get stuck on one approach if you get wrong answer
+*/