diff --git a/2stack.cpp b/2stack.cpp
new file mode 100644
index 0000000..7df99e0
--- /dev/null
+++ b/2stack.cpp
@@ -0,0 +1,85 @@
+#include<bits/stdc++.h>
+using namespace std;
+#define ll long long
+
+class t2stack
+{
+ll *a;
+ll size,top1,top2;
+public:
+	t2stack(ll n)
+	{
+		size=n;
+		a=new ll[n];
+		top1=-1;
+		top2=size;
+	}
+
+	void push1(ll n)
+	{
+		if(top1+1<top2)
+		{
+			top1++;
+			a[top1]=n;
+		}
+		else{
+			cout<<"STACK OVERFLOW"<<endl;
+		}
+	}
+	void push2(ll n)
+	{
+		if(top1+1<top2)
+		{
+			top2--;
+			a[top2]=n;
+		}
+		else
+		{
+			cout<<"STACK OVERFLOW"<<endl;
+		}
+	}
+	void pop1()
+	{
+		if(top1>=0)
+		{
+			cout<<a[top1]<<endl;
+			top1--;
+		}
+		else
+		{
+			cout<<"STACK UNDERFLOW"<<endl;
+		}
+	}
+	void pop2()
+	{
+		if(top2<=size-1)
+		{
+			cout<<a[top2]<<endl;
+			top2++;
+		}
+		else
+		{
+			cout<<"STACK UNDERFLOW"<<endl;
+		}
+	}
+
+};
+
+int main(){
+	#ifndef ONLINE_JUDGE
+	freopen("input.txt","r",stdin);
+	freopen("output.txt","w",stdout);
+	#endif
+	
+    t2stack pr(4);
+    pr.push1(2);
+    pr.push2(3);
+    pr.push1(3);
+    pr.push2(5);
+    pr.pop1();
+    pr.pop2();
+
+  	
+
+	return 0;
+}
\ No newline at end of file
diff --git a/AVLTree.cpp b/AVLTree.cpp
new file mode 100644
index 0000000..21baed7
--- /dev/null
+++ b/AVLTree.cpp
@@ -0,0 +1,133 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+struct Node{
+	int data;
+	Node *left;
+	Node *right;
+	int height;
+}*Root = NULL;
+
+Node* new_Node(int DATA)  
+{  
+    Node* node = new Node(); 
+    node->data = DATA;  
+    node->left = NULL;  
+    node->right = NULL;  
+    node->height = 1; 
+    return(node);  
+}
+
+int height(Node *a)
+{
+    if(a==NULL)
+    return 0;
+    return a->height;
+}
+int balance(Node *a)
+{
+    if(a==NULL)
+    return 0;
+    int lh = height(a->left);
+    int rh = height(a->right);
+    return (lh-rh);
+}
+Node *RR(Node *y)  
+{  
+    Node *x = y->left;  
+    Node *T2 = x->right;  
+    x->right = y;  
+    y->left = T2;  
+    y->height = max(height(y->left), 
+                    height(y->right)) + 1;  
+    x->height = max(height(x->left), 
+                    height(x->right)) + 1;  
+    return x;  
+}  
+
+Node *LL(Node *x)  
+{  
+    Node *y = x->right;  
+    Node *T2 = y->left;  
+    y->left = x;  
+    x->right = T2; 
+    x->height = max(height(x->left),     
+                    height(x->right)) + 1;  
+    y->height = max(height(y->left),  
+                    height(y->right)) + 1;
+    return y;  
+}
+Node* insertToAVL(Node* root, int data)
+{
+    if(root==NULL)
+    {
+        Node* Nodes = new_Node(data);
+        return(Nodes);
+    }
+    if(root->data>data)
+    {
+        root->left = insertToAVL(root->left,data);
+    }
+    else if(root->data<data)
+    {
+        root->right = insertToAVL(root->right,data);
+    }
+    else
+    return root;
+    
+    root->height = max(height(root->left),height(root->right)) + 1;
+    
+    int factor = balance(root);
+    
+    if(factor > 1 && root->left->data > data)
+    {
+        return RR(root);
+    }
+    if(factor < -1 && root->right->data < data)
+    {
+        return LL(root);
+    }
+    if (factor > 1 && data > root->left->data)  
+    {  
+        root->left = LL(root->left);  
+        return RR(root);  
+    }  
+    if (factor < -1 && data < root->right->data)  
+    {  
+        root->right = RR(root->right);  
+        return LL(root);  
+    }  
+    return root;
+}
+void inorder(Node* root) 
+{
+    if(root != NULL) 
+    {
+        inorder(root->left);
+        cout << root->data << " ";
+        inorder(root->right);
+    }
+}
+int main()
+{
+    int size;
+    cout << "\nEnter num of node :- "; 
+    cin >> size;
+    vector<int> vec;
+    cout << "\nEnter values :- ";
+    for(int i = 0; i < size; i++) 
+    {
+        int x; 
+        cin >> x;
+        vec.push_back(x);
+    }
+    Root = insertToAVL(Root, vec[0]);
+    for(int i = 1; i < size; i++) {
+        Root = insertToAVL(Root, vec[i]);
+    }
+    cout << "\nInOrder Traversal is:- \n";
+    inorder(Root);
+    cout<< "\nRoot Node is:- \n";
+    cout<<Root->data<<"\n";
+    return 0;
+}
diff --git a/DynamicProgramming/BoardPath.java b/DynamicProgramming/BoardPath.java
new file mode 100644
index 0000000..938ee62
--- /dev/null
+++ b/DynamicProgramming/BoardPath.java
@@ -0,0 +1,77 @@
+package DynamicProgramming;
+/*
+* this is an important Algo in which 
+* we have starting and ending of board and we have to reach 
+* we have to count no. of ways 
+* that help to reach end point i.e number by rolling dice
+* which have 1 to 6 digits
+
+Test Case:
+here target is 10
+
+int n=10;
+		startAlgo();
+		System.out.println(bpR(0,n));
+		System.out.println(endAlgo()+"ms");
+		int[] strg=new int [n+1];
+		startAlgo();
+		System.out.println(bpRS(0,n,strg));
+		System.out.println(endAlgo()+"ms");
+		startAlgo();
+		System.out.println(bpIS(0,n,strg));
+		System.out.println(endAlgo()+"ms");
+		
+
+
+*/
+public class BoardPath {
+	public static long startTime;
+	public static long endTime;
+	public static void startAlgo() {
+		startTime=System.currentTimeMillis();
+	}
+	public static long endAlgo() {
+		endTime=System.currentTimeMillis();
+		return endTime-startTime;
+	}
+	public static int bpR(int start,int end){
+		if(start==end) {
+			return 1;
+		}
+		else if(start>end)
+			return 0;
+		int count=0;
+		for(int dice=1;dice<=6;dice++) {
+			count+=bpR(start+dice,end);
+		}
+		return count;
+	}
+	public static int bpRS(int curr,int end,int strg[]){
+		if(curr==end) {
+			return 1;
+		}
+		else if(curr>end)
+			return 0;
+		if(strg[curr]!=0)
+			return strg[curr];
+		int count=0;
+		for(int dice=1;dice<=6;dice++) {
+			count+=bpRS(curr+dice,end,strg);
+		}
+		strg[curr]=count;
+		return count;
+	}
+	public static int bpIS(int curr,int end,int[]strg){
+		strg[end]=1;
+		for(int i=end-1;i>=0;i--) {
+			int count=0;
+			for(int dice=1;dice<=6&&dice+i<strg.length;dice++) {
+				count+=strg[i+dice];
+			}
+			strg[i]=count;
+		}
+		return strg[0];
+	}
+
+
+}
diff --git a/DynamicProgramming/CoinChange.java b/DynamicProgramming/CoinChange.java
new file mode 100644
index 0000000..82992e0
--- /dev/null
+++ b/DynamicProgramming/CoinChange.java
@@ -0,0 +1,79 @@
+package DynamicProgramming;
+
+/**
+ * @author Varun Upadhyay (https://github.com/varunu28)
+ */
+public class CoinChange {
+
+    // Driver Program
+    public static void main(String[] args) {
+
+        int amount = 12;
+        int[] coins = {2, 4, 5};
+
+        System.out.println("Number of combinations of getting change for " + amount + " is: " + change(coins, amount));
+        System.out.println("Minimum number of coins required for amount :" + amount + " is: " + minimumCoins(coins, amount));
+
+    }
+
+    /**
+     * This method finds the number of combinations of getting change for a given amount and change coins
+     *
+     * @param coins  The list of coins
+     * @param amount The amount for which we need to find the change
+     *               Finds the number of combinations of change
+     **/
+    public static int change(int[] coins, int amount) {
+
+        int[] combinations = new int[amount + 1];
+        combinations[0] = 1;
+
+        for (int coin : coins) {
+            for (int i = coin; i < amount + 1; i++) {
+                combinations[i] += combinations[i - coin];
+            }
+            // Uncomment the below line to see the state of combinations for each coin
+            // printAmount(combinations);
+        }
+
+        return combinations[amount];
+    }
+
+    /**
+     * This method finds the minimum number of coins needed for a given amount.
+     *
+     * @param coins  The list of coins
+     * @param amount The amount for which we need to find the minimum number of coins.
+     *               Finds the the minimum number of coins that make a given value.
+     **/
+    public static int minimumCoins(int[] coins, int amount) {
+        //minimumCoins[i] will store the minimum coins needed for amount i
+        int[] minimumCoins = new int[amount + 1];
+
+        minimumCoins[0] = 0;
+
+        for (int i = 1; i <= amount; i++) {
+            minimumCoins[i] = Integer.MAX_VALUE;
+        }
+        for (int i = 1; i <= amount; i++) {
+            for (int coin : coins) {
+                if (coin <= i) {
+                    int sub_res = minimumCoins[i - coin];
+                    if (sub_res != Integer.MAX_VALUE && sub_res + 1 < minimumCoins[i])
+                        minimumCoins[i] = sub_res + 1;
+                }
+            }
+        }
+        // Uncomment the below line to see the state of combinations for each coin
+        //printAmount(minimumCoins);
+        return minimumCoins[amount];
+    }
+
+    // A basic print method which prints all the contents of the array
+    public static void printAmount(int[] arr) {
+        for (int i = 0; i < arr.length; i++) {
+            System.out.print(arr[i] + " ");
+        }
+        System.out.println();
+    }
+}
\ No newline at end of file
diff --git a/DynamicProgramming/CountNumBinaryStrings.java b/DynamicProgramming/CountNumBinaryStrings.java
new file mode 100644
index 0000000..44362d9
--- /dev/null
+++ b/DynamicProgramming/CountNumBinaryStrings.java
@@ -0,0 +1,97 @@
+package DynamicProgramming;
+/*
+* here is a important algo in this we have to count  
+* maximum no. of different binary strings which doesnot have 
+* consectuive 1s 
+
+
+
+Test Case:
+
+int n=30;
+		
+		startAlgo();
+		System.out.println(numStrIS(n));
+		System.out.println(endAlgo()+"ms");
+
+		startAlgo();
+		CountNumBinaryStr out=new CountNumBinaryStr();
+		System.out.println(out.numStrR(n).ans);
+		System.out.println(endAlgo()+"ms");
+		
+		startAlgo();
+		System.out.println(countStrings(n,0));
+		System.out.println(endAlgo()+"ms");
+		
+		
+		
+*/
+public class CountNumBinaryStr {
+	public static long startTime;
+	public static long endTime;
+	public static void startAlgo() {
+		startTime=System.currentTimeMillis();
+	}
+	public static long endAlgo() {
+		endTime=System.currentTimeMillis();
+		return endTime-startTime;
+	}
+	public static int numStrIS(int n) {
+		int[] zeros=new int[n];
+		int []ones=new int[n];
+		//seed
+		zeros[0]=1;
+		ones[0]=1;
+		for(int i=1;i<n;i++) {
+			zeros[i]=zeros[i-1]+ones[i-1];
+			ones[i]=zeros[i-1];
+		}
+		int ans=zeros[n-1]+ones[n-1];
+		return ans;
+	}
+	private class Binary{
+		int ones;
+		int zeros;
+		int ans;
+		Binary(int ones,int zeros){
+			this.ones=ones;
+			this.zeros=zeros;
+			this.ans=0;
+		}
+		Binary(){}
+	}
+	public  Binary numStrR(int n) {
+		if(n==1) {
+			Binary br=new Binary(1,1);
+			return br;
+		}
+		Binary mr=new Binary();
+		Binary rr=numStrR(n-1);
+		mr.zeros=rr.zeros+rr.ones;
+		mr.ones=rr.zeros;
+		mr.ans=mr.zeros+mr.ones;
+		return mr;
+	}
+	public static int countStrings(int n, int lastDigit)
+	{
+		if (n == 0) {
+			return 0;
+		}
+
+		// if only one digit is left
+		if (n == 1) {
+			return (lastDigit == 1) ? 1: 2;
+		}
+
+		// if last digit is 0, we can have both 0 and 1 at current pos
+		if (lastDigit == 0) {
+			return countStrings(n - 1, 0) + countStrings(n - 1, 1);
+		}
+		// if last digit is 1, we can have only 0 at current position
+		else {
+			return countStrings(n - 1, 0);
+		}
+	}
+
+
+}
diff --git a/DynamicProgramming/EditDistance.java b/DynamicProgramming/EditDistance.java
new file mode 100644
index 0000000..ab21cc6
--- /dev/null
+++ b/DynamicProgramming/EditDistance.java
@@ -0,0 +1,79 @@
+package DynamicProgramming;
+
+/**
+ * A DynamicProgramming based solution for Edit Distance problem In Java
+ * Description of Edit Distance with an Example:
+ * <p>
+ * Edit distance is a way of quantifying how dissimilar two strings (e.g., words) are to one another,
+ * by counting the minimum number of operations required to transform one string into the other. The
+ * distance operations are the removal, insertion, or substitution of a character in the string.
+ * <p>
+ * <p>
+ * The Distance between "kitten" and "sitting" is 3. A minimal edit script that transforms the former into the latter is:
+ * <p>
+ * kitten → sitten (substitution of "s" for "k")
+ * sitten → sittin (substitution of "i" for "e")
+ * sittin → sitting (insertion of "g" at the end).
+ *
+ * @author SUBHAM SANGHAI
+ **/
+
+import java.util.Scanner;
+
+public class EditDistance {
+
+    public static int minDistance(String word1, String word2) {
+        int len1 = word1.length();
+        int len2 = word2.length();
+        // len1+1, len2+1, because finally return dp[len1][len2]
+        int[][] dp = new int[len1 + 1][len2 + 1];
+     	/* If second string is empty, the only option is to
+   	  insert all characters of first string into second*/
+        for (int i = 0; i <= len1; i++) {
+            dp[i][0] = i;
+        }
+     	/* If first string is empty, the only option is to
+   	  insert all characters of second string into first*/
+        for (int j = 0; j <= len2; j++) {
+            dp[0][j] = j;
+        }
+        //iterate though, and check last char
+        for (int i = 0; i < len1; i++) {
+            char c1 = word1.charAt(i);
+            for (int j = 0; j < len2; j++) {
+                char c2 = word2.charAt(j);
+                //if last two chars equal
+                if (c1 == c2) {
+                    //update dp value for +1 length
+                    dp[i + 1][j + 1] = dp[i][j];
+                } else {
+			/* if two characters are different ,
+			then take the minimum of the various operations(i.e insertion,removal,substitution)*/
+                    int replace = dp[i][j] + 1;
+                    int insert = dp[i][j + 1] + 1;
+                    int delete = dp[i + 1][j] + 1;
+
+                    int min = replace > insert ? insert : replace;
+                    min = delete > min ? min : delete;
+                    dp[i + 1][j + 1] = min;
+                }
+            }
+        }
+        /* return the final answer , after traversing through both the strings*/
+        return dp[len1][len2];
+    }
+
+
+    public static void main(String[] args) {
+        Scanner input = new Scanner(System.in);
+        String s1, s2;
+        System.out.println("Enter the First String");
+        s1 = input.nextLine();
+        System.out.println("Enter the Second String");
+        s2 = input.nextLine();
+        //ans stores the final Edit Distance between the two strings
+        int ans = minDistance(s1, s2);
+        System.out.println("The minimum Edit Distance between \"" + s1 + "\" and \"" + s2 + "\" is " + ans);
+        input.close();
+    }
+}
diff --git a/DynamicProgramming/EggDropping.java b/DynamicProgramming/EggDropping.java
new file mode 100644
index 0000000..f6e2ab7
--- /dev/null
+++ b/DynamicProgramming/EggDropping.java
@@ -0,0 +1,49 @@
+package DynamicProgramming;
+
+/**
+ * DynamicProgramming solution for the Egg Dropping Puzzle
+ */
+public class EggDropping {
+
+    // min trials with n eggs and m floors 
+
+    private static int minTrials(int n, int m) {
+
+        int[][] eggFloor = new int[n + 1][m + 1];
+        int result, x;
+
+        for (int i = 1; i <= n; i++) {
+            eggFloor[i][0] = 0;   // Zero trial for zero floor.
+            eggFloor[i][1] = 1;   // One trial for one floor 
+        }
+
+        // j trials for only 1 egg
+
+        for (int j = 1; j <= m; j++)
+            eggFloor[1][j] = j;
+
+        // Using bottom-up approach in DP
+
+        for (int i = 2; i <= n; i++) {
+            for (int j = 2; j <= m; j++) {
+                eggFloor[i][j] = Integer.MAX_VALUE;
+                for (x = 1; x <= j; x++) {
+                    result = 1 + Math.max(eggFloor[i - 1][x - 1], eggFloor[i][j - x]);
+
+                    // choose min of all values for particular x
+                    if (result < eggFloor[i][j])
+                        eggFloor[i][j] = result;
+                }
+            }
+        }
+
+        return eggFloor[n][m];
+    }
+
+    public static void main(String args[]) {
+        int n = 2, m = 4;
+        // result outputs min no. of trials in worst case for n eggs and m floors
+        int result = minTrials(n, m);
+        System.out.println(result);
+    }
+}
diff --git a/DynamicProgramming/Fibonacci.java b/DynamicProgramming/Fibonacci.java
new file mode 100644
index 0000000..e623a0a
--- /dev/null
+++ b/DynamicProgramming/Fibonacci.java
@@ -0,0 +1,100 @@
+package DynamicProgramming;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Scanner;
+
+/**
+ * @author Varun Upadhyay (https://github.com/varunu28)
+ */
+
+public class Fibonacci {
+
+    private static Map<Integer, Integer> map = new HashMap<>();
+
+
+    public static void main(String[] args) {
+
+        // Methods all returning [0, 1, 1, 2, 3, 5, ...] for n = [0, 1, 2, 3, 4, 5, ...]
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt();
+        
+        System.out.println(fibMemo(n));
+        System.out.println(fibBotUp(n));
+        System.out.println(fibOptimized(n));
+        sc.close();
+    }
+
+    /**
+     * This method finds the nth fibonacci number using memoization technique
+     *
+     * @param n The input n for which we have to determine the fibonacci number
+     *          Outputs the nth fibonacci number
+     **/
+    public static int fibMemo(int n) {
+        if (map.containsKey(n)) {
+            return map.get(n);
+        }
+
+        int f;
+
+        if (n <= 1) {
+            f = n;
+        } else {
+            f = fibMemo(n - 1) + fibMemo(n - 2);
+            map.put(n, f);
+        }
+        return f;
+    }
+
+    /**
+     * This method finds the nth fibonacci number using bottom up
+     *
+     * @param n The input n for which we have to determine the fibonacci number
+     *          Outputs the nth fibonacci number
+     **/
+    public static int fibBotUp(int n) {
+
+        Map<Integer, Integer> fib = new HashMap<>();
+
+        for (int i = 0; i <= n; i++) {
+            int f;
+            if (i <= 1) {
+                f = i;
+            } else {
+                f = fib.get(i - 1) + fib.get(i - 2);
+            }
+            fib.put(i, f);
+        }
+
+        return fib.get(n);
+    }
+
+
+    /**
+     * This method finds the nth fibonacci number using bottom up
+     *
+     * @param n The input n for which we have to determine the fibonacci number
+     *          Outputs the nth fibonacci number
+     *          <p>
+     *          This is optimized version of Fibonacci Program. Without using Hashmap and recursion.
+     *          It saves both memory and time.
+     *          Space Complexity will be O(1)
+     *          Time Complexity will be O(n)
+     *          <p>
+     *          Whereas , the above functions will take O(n) Space.
+     * @author Shoaib Rayeen (https://github.com/shoaibrayeen)
+     **/
+    public static int fibOptimized(int n) {
+        if (n == 0) {
+            return 0;
+        }
+        int prev = 0, res = 1, next;
+        for (int i = 2; i <= n; i++) {
+            next = prev + res;
+            prev = res;
+            res = next;
+        }
+        return res;
+    }
+}
diff --git a/DynamicProgramming/FordFulkerson.java b/DynamicProgramming/FordFulkerson.java
new file mode 100644
index 0000000..f061d89
--- /dev/null
+++ b/DynamicProgramming/FordFulkerson.java
@@ -0,0 +1,72 @@
+package DynamicProgramming;
+
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.Vector;
+
+public class FordFulkerson {
+    final static int INF = 987654321;
+    // edges
+    static int V;
+    static int[][] capacity, flow;
+
+    public static void main(String[] args) {
+        System.out.println("V : 6");
+        V = 6;
+        capacity = new int[V][V];
+
+        capacity[0][1] = 12;
+        capacity[0][3] = 13;
+        capacity[1][2] = 10;
+        capacity[2][3] = 13;
+        capacity[2][4] = 3;
+        capacity[2][5] = 15;
+        capacity[3][2] = 7;
+        capacity[3][4] = 15;
+        capacity[4][5] = 17;
+
+        System.out.println("Max capacity in networkFlow : " + networkFlow(0, 5));
+    }
+
+    private static int networkFlow(int source, int sink) {
+        flow = new int[V][V];
+        int totalFlow = 0;
+        while (true) {
+            Vector<Integer> parent = new Vector<>(V);
+            for (int i = 0; i < V; i++)
+                parent.add(-1);
+            Queue<Integer> q = new LinkedList<>();
+            parent.set(source, source);
+            q.add(source);
+            while (!q.isEmpty() && parent.get(sink) == -1) {
+                int here = q.peek();
+                q.poll();
+                for (int there = 0; there < V; ++there)
+                    if (capacity[here][there] - flow[here][there] > 0 && parent.get(there) == -1) {
+                        q.add(there);
+                        parent.set(there, here);
+                    }
+            }
+            if (parent.get(sink) == -1)
+                break;
+
+            int amount = INF;
+            String printer = "path : ";
+            StringBuilder sb = new StringBuilder();
+            for (int p = sink; p != source; p = parent.get(p)) {
+                amount = Math.min(capacity[parent.get(p)][p] - flow[parent.get(p)][p], amount);
+                sb.append(p + "-");
+            }
+            sb.append(source);
+            for (int p = sink; p != source; p = parent.get(p)) {
+                flow[parent.get(p)][p] += amount;
+                flow[p][parent.get(p)] -= amount;
+            }
+            totalFlow += amount;
+            printer += sb.reverse() + " / max flow : " + totalFlow;
+            System.out.println(printer);
+        }
+
+        return totalFlow;
+    }
+}
diff --git a/DynamicProgramming/KadaneAlgorithm.java b/DynamicProgramming/KadaneAlgorithm.java
new file mode 100644
index 0000000..3b8051f
--- /dev/null
+++ b/DynamicProgramming/KadaneAlgorithm.java
@@ -0,0 +1,55 @@
+package DynamicProgramming;
+
+import java.util.Scanner;
+
+/**
+ * Program to implement Kadane’s Algorithm to
+ * calculate maximum contiguous subarray sum of an array
+ * Time Complexity: O(n)
+ *
+ * @author Nishita Aggarwal
+ */
+
+public class KadaneAlgorithm {
+
+    /**
+     * This method implements Kadane's Algorithm
+     *
+     * @param arr The input array
+     * @return The maximum contiguous subarray sum of the array
+     */
+    static int largestContiguousSum(int arr[]) {
+        int i, len = arr.length, cursum = 0, maxsum = Integer.MIN_VALUE;
+        if (len == 0)    //empty array
+            return 0;
+        for (i = 0; i < len; i++) {
+            cursum += arr[i];
+            if (cursum > maxsum) {
+                maxsum = cursum;
+            }
+            if (cursum <= 0) {
+                cursum = 0;
+            }
+        }
+        return maxsum;
+    }
+
+    /**
+     * Main method
+     *
+     * @param args Command line arguments
+     */
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int n, arr[], i;
+        n = sc.nextInt();
+        arr = new int[n];
+        for (i = 0; i < n; i++) {
+            arr[i] = sc.nextInt();
+        }
+        int maxContSum = largestContiguousSum(arr);
+        System.out.println(maxContSum);
+        sc.close();
+    }
+
+}
diff --git a/DynamicProgramming/Knapsack.java b/DynamicProgramming/Knapsack.java
new file mode 100644
index 0000000..1dda48b
--- /dev/null
+++ b/DynamicProgramming/Knapsack.java
@@ -0,0 +1,39 @@
+package DynamicProgramming;
+
+/**
+ * A DynamicProgramming based solution for 0-1 Knapsack problem
+ */
+
+public class Knapsack {
+
+    private static int knapSack(int W, int wt[], int val[], int n) throws IllegalArgumentException {
+        if(wt == null || val == null)
+            throw new IllegalArgumentException();
+        int i, w;
+        int rv[][] = new int[n + 1][W + 1];    //rv means return value
+
+        // Build table rv[][] in bottom up manner
+        for (i = 0; i <= n; i++) {
+            for (w = 0; w <= W; w++) {
+                if (i == 0 || w == 0)
+                    rv[i][w] = 0;
+                else if (wt[i - 1] <= w)
+                    rv[i][w] = Math.max(val[i - 1] + rv[i - 1][w - wt[i - 1]], rv[i - 1][w]);
+                else
+                    rv[i][w] = rv[i - 1][w];
+            }
+        }
+
+        return rv[n][W];
+    }
+
+
+    // Driver program to test above function
+    public static void main(String args[]) {
+        int val[] = new int[]{50, 100, 130};
+        int wt[] = new int[]{10, 20, 40};
+        int W = 50;
+        int n = val.length;
+        System.out.println(knapSack(W, wt, val, n));
+    }
+}
diff --git a/DynamicProgramming/LongestCommonSubsequence.java b/DynamicProgramming/LongestCommonSubsequence.java
new file mode 100644
index 0000000..1ab5700
--- /dev/null
+++ b/DynamicProgramming/LongestCommonSubsequence.java
@@ -0,0 +1,68 @@
+package DynamicProgramming;
+
+class LongestCommonSubsequence {
+
+    public static String getLCS(String str1, String str2) {
+
+        //At least one string is null
+        if (str1 == null || str2 == null)
+            return null;
+
+        //At least one string is empty
+        if (str1.length() == 0 || str2.length() == 0)
+            return "";
+
+        String[] arr1 = str1.split("");
+        String[] arr2 = str2.split("");
+
+        //lcsMatrix[i][j]  = LCS of first i elements of arr1 and first j characters of arr2
+        int[][] lcsMatrix = new int[arr1.length + 1][arr2.length + 1];
+
+        for (int i = 0; i < arr1.length + 1; i++)
+            lcsMatrix[i][0] = 0;
+        for (int j = 1; j < arr2.length + 1; j++)
+            lcsMatrix[0][j] = 0;
+        for (int i = 1; i < arr1.length + 1; i++) {
+            for (int j = 1; j < arr2.length + 1; j++) {
+                if (arr1[i - 1].equals(arr2[j - 1])) {
+                    lcsMatrix[i][j] = lcsMatrix[i - 1][j - 1] + 1;
+                } else {
+                    lcsMatrix[i][j] = lcsMatrix[i - 1][j] > lcsMatrix[i][j - 1] ? lcsMatrix[i - 1][j] : lcsMatrix[i][j - 1];
+                }
+            }
+        }
+        return lcsString(str1, str2, lcsMatrix);
+    }
+
+    public static String lcsString(String str1, String str2, int[][] lcsMatrix) {
+        StringBuilder lcs = new StringBuilder();
+        int i = str1.length(),
+                j = str2.length();
+        while (i > 0 && j > 0) {
+            if (str1.charAt(i - 1) == str2.charAt(j - 1)) {
+                lcs.append(str1.charAt(i - 1));
+                i--;
+                j--;
+            } else if (lcsMatrix[i - 1][j] > lcsMatrix[i][j - 1]) {
+                i--;
+            } else {
+                j--;
+            }
+        }
+        return lcs.reverse().toString();
+    }
+
+    public static void main(String[] args) {
+        String str1 = "DSGSHSRGSRHTRD";
+        String str2 = "DATRGAGTSHS";
+        String lcs = getLCS(str1, str2);
+
+        //Print LCS
+        if (lcs != null) {
+            System.out.println("String 1: " + str1);
+            System.out.println("String 2: " + str2);
+            System.out.println("LCS: " + lcs);
+            System.out.println("LCS length: " + lcs.length());
+        }
+    }
+}
\ No newline at end of file
diff --git a/DynamicProgramming/README.md b/DynamicProgramming/README.md
new file mode 100644
index 0000000..72ab87c
--- /dev/null
+++ b/DynamicProgramming/README.md
@@ -0,0 +1,16 @@
+# DynamicProgramming(using Java) <br>
+
+
+|Problem's| Solution |
+|:---------:|:----------:|
+|BoardPath|[BoardPath.java ](https://github.com/Kushal997-das/Competitive-programming-library/blob/master/DynamicProgramming/BoardPath.java)|
+|CoinChange|[CoinChange.java](https://github.com/Kushal997-das/Competitive-programming-library/blob/master/DynamicProgramming/CoinChange.java)|
+|EditDistance|[EditDistance.java ](https://github.com/Kushal997-das/Competitive-programming-library/blob/master/DynamicProgramming/EditDistance.java)|
+|EggDropping|[EggDropping.java ](https://github.com/Kushal997-das/Competitive-programming-library/blob/master/DynamicProgramming/EggDropping.java)|
+|Fibonacci|[Fibonacci.java](https://github.com/Kushal997-das/Competitive-programming-library/blob/master/DynamicProgramming/Fibonacci.java)|
+|FordFulkerson|[FordFulkerson.java ](https://github.com/Kushal997-das/Competitive-programming-library/blob/master/DynamicProgramming/FordFulkerson.java)|
+|KadaneAlgorithm|[KadaneAlgorithm.java](https://github.com/Kushal997-das/Competitive-programming-library/blob/master/DynamicProgramming/KadaneAlgorithm.java)|
+|Knapsack|[Knapsack.java ](https://github.com/Kushal997-das/Competitive-programming-library/blob/master/DynamicProgramming/Knapsack.java)|
+|SubsetSum|[SubsetSum.java ](https://github.com/Kushal997-das/CODE/blob/master/DynamicProgramming/SubsetSum.java)
+|CountNumBinaryStrings|[CountNumBinaryStrings.java](https://github.com/Kushal997-das/Competitive-programming-library/blob/master/DynamicProgramming/CountNumBinaryStrings.java)|
+|LongestCommonSubsequence|[LongestCommonSubsequence.java ](https://github.com/Kushal997-das/Competitive-programming-library/blob/master/DynamicProgramming/LongestCommonSubsequence.java)|
diff --git a/DynamicProgramming/SubsetSum.java b/DynamicProgramming/SubsetSum.java
new file mode 100644
index 0000000..cab94b1
--- /dev/null
+++ b/DynamicProgramming/SubsetSum.java
@@ -0,0 +1,46 @@
+package DynamicProgramming;
+
+public class SubsetSum {
+
+    /**
+     * Driver Code
+     */
+    public static void main(String[] args) {
+        int[] arr = new int[]{50, 4, 10, 15, 34};
+        assert subsetSum(arr, 64); /* 4 + 10 + 15 + 34 = 64 */
+        assert subsetSum(arr, 99); /* 50 + 15 + 34 = 99 */
+        assert !subsetSum(arr, 5);
+        assert !subsetSum(arr, 66);
+    }
+
+    /**
+     * Test if a set of integers contains a subset that sum to a given integer.
+     *
+     * @param arr the array contains integers.
+     * @param sum target sum of subset.
+     * @return {@code true} if subset exists, otherwise {@code false}.
+     */
+    private static boolean subsetSum(int[] arr, int sum) {
+        int n = arr.length;
+        boolean[][] isSum = new boolean[n + 2][sum + 1];
+
+        isSum[n + 1][0] = true;
+        for (int i = 1; i <= sum; i++) {
+            isSum[n + 1][i] = false;
+        }
+
+        for (int i = n; i > 0; i--) {
+            isSum[i][0] = true;
+            for (int j = 1; j <= arr[i - 1] - 1; j++) {
+                if (j <= sum) {
+                    isSum[i][j] = isSum[i + 1][j];
+                }
+            }
+            for (int j = arr[i - 1]; j <= sum; j++) {
+                isSum[i][j] = (isSum[i + 1][j] || isSum[i + 1][j - arr[i - 1]]);
+            }
+        }
+
+        return isSum[1][sum];
+    }
+}
\ No newline at end of file
diff --git a/README.md b/README.md
index 48735ab..9adf6ad 100644
--- a/README.md
+++ b/README.md
@@ -57,6 +57,22 @@ Code library for competitive programming purposes.
   - Aho Corasick
   - Z Algorithm
   - Manacher
+  
+- [DynamicProgramming](DynamicProgramming)
+  - [readme](DynamicProgramming/README.md)
+    - [BoardPath.java ](https://github.com/Kushal997-das/Competitive-programming-library/blob/master/DynamicProgramming/BoardPath.java)
+    - [coinChange.java ](https://github.com/Kushal997-das/Competitive-programming-library/blob/master/DynamicProgramming/CoinChange.java)
+    - [CountNumBinaryStrings.java](https://github.com/Kushal997-das/Competitive-programming-library/blob/master/DynamicProgramming/CountNumBinaryStrings.java)
+    - [EditDistance.java](https://github.com/Kushal997-das/Competitive-programming-library/blob/master/DynamicProgramming/EditDistance.java)
+    - [EggDropping.java](https://github.com/Kushal997-das/Competitive-programming-library/blob/master/DynamicProgramming/EggDropping.java)
+    - [Fibonacci.java](https://github.com/Kushal997-das/Competitive-programming-library/blob/master/DynamicProgramming/Fibonacci.java)
+    - [FordFulkerson.java](https://github.com/Kushal997-das/Competitive-programming-library/blob/master/DynamicProgramming/FordFulkerson.java)
+    - [KadaneAlgorithm.java](https://github.com/Kushal997-das/Competitive-programming-library/blob/master/DynamicProgramming/KadaneAlgorithm.java)
+    - [Knapsack.java](https://github.com/Kushal997-das/Competitive-programming-library/blob/master/DynamicProgramming/Knapsack.java)
+    - [LongestCommonSubsequence.java](https://github.com/Kushal997-das/Competitive-programming-library/blob/master/DynamicProgramming/LongestCommonSubsequence.java)
+    - [SubsetSum.java](https://github.com/Kushal997-das/Competitive-programming-library/blob/master/DynamicProgramming/SubsetSum.java)
+
+
 - Other Algorithms
 
 ### Related Material
diff --git a/add del link list.cpp b/add del link list.cpp
new file mode 100644
index 0000000..53790c9
--- /dev/null
+++ b/add del link list.cpp	
@@ -0,0 +1,108 @@
+#include<bits/stdc++.h>
+using namespace std;
+#define ll long long
+
+class node  
+{  
+    public: 
+    int data;  
+    node *next;  
+};
+
+void add_node(node ** head,int n)  //inserts at the front
+{
+	node *temp=new node;
+	temp->data=n;
+	temp->next=*head;
+	*head=temp;
+}
+void add(node ** head,int n)
+{
+	node *temp=new node();
+	node *l=*head;
+	temp->data=n;
+	temp->next=NULL;
+	if(*head==NULL)
+	{
+		*head=temp;
+	}
+	else
+	{
+		while(l->next!=NULL)
+      {
+	   l=l->next;
+      }	
+      l->next=temp;
+	}
+}
+void display(node ** k)
+{
+	while((*k)!=NULL)
+	{
+		cout<<(*k)->data<<" ";
+		(*k)=(*k)->next;
+	}
+}
+void delfront(node **head)
+{
+	if(*head==NULL)
+		cout<<"Nothing to delete \n";
+	else
+		(*head) = (*head)->next;
+}
+void delend(node **head)
+{
+	if(*head==NULL)
+		cout<<"Nothing to delete\n";
+	else
+	{
+		if((*head)->next==NULL)
+			delete(*head);
+		node *second = *head;
+		while(second->next->next!=NULL)
+		{
+			second = second->next;
+		}
+		delete(second->next);
+		second->next = NULL;
+	}
+}
+int main()
+{
+	node *head=NULL;
+	int i,n;
+	cin>>n;	
+	for(i=0;i<n;i++)
+	{
+		int x,y;
+		cout<<"Enter the option"<<endl;
+		cin>>y;
+		if(y==1 || y==2)
+		{
+			cout<<"Enter the number to be inserted"<<endl;
+			cin>>x;
+			if(y==1)
+			{
+				add_node(&head,x); //insertion from front
+			}
+			
+			else if(y==2) //insertion from end
+			{
+				add(&head, x);      
+			}
+		}
+		else
+		{
+			if(y==3)  //deletion from front
+			{
+				delfront(&head);
+			}
+			else if(y==4)  //deletion from end
+			{
+				delend(&head);
+			}
+		}
+	}
+	cout<<"The final linked list is"<<endl;
+	display(&head);
+}
diff --git a/adjacency matrix.cpp b/adjacency matrix.cpp
new file mode 100644
index 0000000..50e8127
--- /dev/null
+++ b/adjacency matrix.cpp	
@@ -0,0 +1,37 @@
+#include<bits/stdc++.h>
+using namespace std;
+#define ll long long
+int adj[5][5];
+void add(int u,int v)
+{
+	adj[u][v]=1;
+	adj[v][u]=1;
+}
+void display(int n)
+{
+	for(int i=0;i<n;i++)
+	{
+		for(int j=0;j<n;j++)
+		{
+			cout<<adj[i][j]<<" ";
+		}
+		cout<<endl;
+	}
+}
+int main(){
+	#ifndef ONLINE_JUDGE
+	freopen("input.txt","r",stdin);
+	freopen("output.txt","w",stdout);
+	#endif
+	int n=5;
+	add(1,2);
+	add(0,2);
+	add(0,1);
+	add(2,4);
+	add(1,3);
+	add(4,3);
+	add(2,3);
+	display(5);
+	
+	return 0;
+}
\ No newline at end of file
diff --git a/adjlist.cpp b/adjlist.cpp
new file mode 100644
index 0000000..979001f
--- /dev/null
+++ b/adjlist.cpp
@@ -0,0 +1,41 @@
+#include<bits/stdc++.h>
+using namespace std;
+#define ll long long
+void add(vector<ll> l[],int u,int v)
+{
+	l[u].push_back(v);
+	l[v].push_back(u);
+}
+void printgraph(vector<ll> l[],int n)
+{
+	for(int i=0;i<n;i++)
+	{
+		cout<<i<<endl;
+		for(auto x:l[i])
+		{
+			cout<<"->"<<x;
+		}
+		cout<<endl;
+	}
+}
+
+
+int main(){
+	#ifndef ONLINE_JUDGE
+	freopen("input.txt","r",stdin);
+	freopen("output.txt","w",stdout);
+	#endif
+	int V = 5; 
+    vector<ll> l[V]; 
+    add(l,0,1); 
+    add(l,0,4); 
+    add(l,1,2); 
+    add(l,1,3); 
+    add(l,1,4); 
+    add(l,2,3); 
+    add(l,3,4); 
+    printgraph(l, V); 
+	
+
+	return 0;
+}
\ No newline at end of file
diff --git a/alter 1.cpp b/alter 1.cpp
new file mode 100644
index 0000000..3873731
--- /dev/null
+++ b/alter 1.cpp	
@@ -0,0 +1,49 @@
+#include<bits/stdc++.h>
+using namespace std;
+#define ll long long
+int main(){
+	#ifndef ONLINE_JUDGE
+	freopen("input.txt","r",stdin);
+	freopen("output.txt","w",stdout);
+	#endif
+	ll n;
+	cin>>n;
+	ll a[n];
+	for(ll i=0;i<n;i++)
+	{
+		cin>>a[i];
+	}
+	for(ll i=0;i<n;i++) //setting the flag bit
+	{
+		if(a[i]>=0)
+		{
+			a[i]=1;
+		}
+		else
+		{
+			a[i]=-1;
+		}
+	}
+	bool flag=0;
+	ll sum=0;
+	for(ll i=0;i<n-1;i++)
+	{
+		if(a[i]==a[i+1])
+		{
+			flag=1;
+			break;
+		}
+
+
+	}
+	if(flag==0)
+	{
+		cout<<"ALTER ARRAY";
+	}
+	else{
+		cout<<"NOT AN ALTER ARRAY";
+	}
+
+
+	return 0;
+}
\ No newline at end of file
diff --git a/bfs.cpp b/bfs.cpp
new file mode 100644
index 0000000..33a8428
--- /dev/null
+++ b/bfs.cpp
@@ -0,0 +1,76 @@
+#include<bits/stdc++.h>
+using namespace std;
+#define ll long long
+class graph
+{
+	int V;
+	list<int> *adj;
+public:
+	graph(int V);
+	void add(int u,int v);
+	void BFS(int v);
+};
+
+graph::graph(int V)
+{
+	this->V=V;
+	adj=new list<int>[V];
+}
+
+void graph::add(int u,int v)
+{
+	adj[u].push_back(v);
+}
+void graph::BFS(int s)
+{
+	bool *visited=new bool[V];
+	for(int i=0;i<V;i++)
+	{
+		visited[i]=false;
+	}
+	list<int> queue;
+
+	visited[s]=true;
+	queue.push_back(s);
+
+
+	list<int>::iterator i;
+
+
+	while(!queue.empty())
+	{
+		s=queue.front();
+		cout<<s<<" ";
+		queue.pop_front();
+
+
+		for(i=adj[s].begin();i!=adj[s].end();i++)
+		{
+			if(!visited[*i])
+			{
+				visited[*i]=true;
+				queue.push_back(*i);
+			}
+		}
+	}
+}
+
+int main(){
+	#ifndef ONLINE_JUDGE
+	freopen("input.txt","r",stdin);
+	freopen("output.txt","w",stdout);
+	#endif
+	 graph g(4); 
+    g.add(0, 1); 
+    g.add(0, 2); 
+    g.add(1, 2); 
+    g.add(2, 0); 
+    g.add(2, 3); 
+    g.add(3, 3); 
+  
+    cout << "Following is Breadth First Traversal "
+         << "(starting from vertex 2) \n"; 
+    g.BFS(2); 
+
+	return 0;
+}
\ No newline at end of file
diff --git a/check tree is BST or not.cpp b/check tree is BST or not.cpp
new file mode 100644
index 0000000..db19ba3
--- /dev/null
+++ b/check tree is BST or not.cpp	
@@ -0,0 +1,52 @@
+#include<bits/stdc++.h>
+
+#define ll long long int
+#define llu unsigned long long int
+#define f(n) for(ll i=0;i<n;i++)
+#define fr(n) for(ll i=n-1;i>=0;i--)
+#define endl "\n"
+#define mod 1000000007
+
+using namespace std;
+
+class node 
+{ 
+public: 
+	ll data; 
+	node* left; 
+	node* right; 
+	
+	node(ll data) 
+	{ 
+		this->data = data; 
+		this->left = NULL; 
+		this->right = NULL; 
+	} 
+}; 
+
+ll isThisBST(node* node, ll min, ll max) 
+{ 
+	if (node==NULL) 
+		return 1; 
+
+	if (node->data < min || node->data > max) 
+		return 0; 
+
+	return isThisBST(node->left, min, node->data-1) && isThisBST(node->right, node->data+1, max);
+} 
+
+int main()
+{
+	node *root = new node(4); 
+	root->left = new node(2); 
+	root->right = new node(5); 
+	root->left->left = new node(1); 
+	root->left->right = new node(3); 
+	
+	if(isThisBST(root,INT_MIN,INT_MAX)) 
+		cout<<"Is BST"; 
+	else
+		cout<<"Not a BST"; 
+	
+	return 0;
+}
diff --git a/circular linked list.cpp b/circular linked list.cpp
new file mode 100644
index 0000000..0b7724f
--- /dev/null
+++ b/circular linked list.cpp	
@@ -0,0 +1,160 @@
+#include<bits/stdc++.h>
+using namespace std;
+struct Node {
+  int data;
+  Node* next;
+};
+Node* last;
+
+//Node* create(Node* last , int d); 
+void insertBeg( int d)
+{
+  if(last==NULL)
+  {
+    Node* temp = new Node();
+    temp->data = d;
+    last = temp;
+    temp->next = last;
+    
+  }
+  else
+  {
+    Node* temp = new Node();
+    temp->data = d;
+    temp->next = last->next;
+    last->next = temp;
+    
+  }
+}
+Node* append(Node* last , int d)
+{
+  if(last ==NULL)
+  {
+    Node*temp = new Node();
+    temp->data = d;
+    last = temp;
+    temp->next = last;
+    return last;
+  }
+  else
+  {
+    Node* temp = new Node();
+    temp->data = d;
+    temp->next = last->next;
+    last->next = temp;
+    last = temp;
+    return last;
+  }
+  
+}
+//Node* between(Node* last , int d , int item);
+void del(int d)
+{
+  if(last == NULL)
+  {
+    cout<<"List is empty "<<endl;
+    return;
+  }
+  Node* p = last->next;
+  Node* temp;
+    if(last-> next == last && last->data == d)
+    {
+      //only node
+      temp = last;
+      last = NULL;
+      delete(temp);
+      return;
+    }
+    if(last->next->data == d)
+    {
+      //first node
+      temp = last->next;
+      last->next = temp->next;
+      delete(temp);
+      return;
+    }
+    while(p->next != last)
+    {
+      //nth node
+      if(p->next->data == d)
+      {
+        temp = p->next;
+        p->next = temp->next;
+        delete(temp);
+
+      }
+      p = p->next;
+    }
+    if(last->data == d)
+    {
+      //last node
+      temp = last;
+    }
+  
+}
+void display()
+{
+  Node* temp = last;
+  if(temp == NULL)
+  {
+    cout<<"List is empty "<<endl;
+    return;
+  }
+  Node* p;
+  p = temp->next;
+  do
+  {
+    cout<<p->data<<" ";
+    p = p->next;
+  }
+  while(p != temp->next);
+  cout<<endl;
+}
+
+int main()
+{
+  last = NULL;
+  int i,d,n;
+  while(1)
+  {
+    cout<<"1.Enter the element in beginning "<<endl;
+    cout<<"2.Enter the element at last "<<endl;
+    cout<<"3.Exit "<<endl;
+  
+  int z;
+  cin>>z;
+  switch(z)
+  {
+    case 1:
+      cout<<"Enter the no of elements to be entered "<<endl;
+      cin>>n;
+      cout<<"Enter the element of list "<<endl;
+      for(i=0;i<n;i++)
+    {
+      cin>>d;
+      insertBeg(d);
+    }
+      display();
+      break;
+
+  case 2:
+      cout<<"Enter the no of elements to be entered "<<endl;
+      cin>>n;
+      cout<<"Enter the element of list "<<endl;
+      for(i=0;i<n;i++)
+    {
+      cin>>d;
+      last = append(last,d);
+    }
+      display();
+      break;
+
+  case 3:
+      return 0;
+      
+  default:
+      cout<<"Wrong choice";
+  }
+  }
+  return 0;
+}
diff --git a/contigous sum kadane's.cpp b/contigous sum kadane's.cpp
new file mode 100644
index 0000000..9afbe05
--- /dev/null
+++ b/contigous sum kadane's.cpp	
@@ -0,0 +1,34 @@
+#include<bits/stdc++.h>
+using namespace std;
+#define ll long long
+int main(){
+	#ifndef ONLINE_JUDGE
+	freopen("input.txt","r",stdin);
+	freopen("output.txt","w",stdout);
+	#endif
+	
+	//using KADANE'S ALGO
+	//Initialise two variable.
+	ll overall_max=INT_MIN;
+	ll current_max=0;
+	ll n; cin>>n;
+	ll a[n];
+	for(ll i=0;i<n;i++)
+	{
+		cin>>a[i];
+	}
+	for(ll i=0;i<n;i++)
+	{
+		current_max+=a[i];
+		if(current_max>overall_max)
+		{
+			overall_max=current_max;
+		}
+		if(current_max<0)
+		{
+			current_max=0;
+		}
+	}
+	cout<<overall_max;
+	return 0;
+}
\ No newline at end of file
diff --git a/contigous sum naive.cpp b/contigous sum naive.cpp
new file mode 100644
index 0000000..68b5c07
--- /dev/null
+++ b/contigous sum naive.cpp	
@@ -0,0 +1,34 @@
+#include<bits/stdc++.h>
+using namespace std;
+#define ll long long
+int main(){
+	#ifndef ONLINE_JUDGE
+	freopen("input.txt","r",stdin);
+	freopen("output.txt","w",stdout);
+	#endif
+	
+	ll n;
+	cin>>n;
+	ll a[n];
+	
+	for(ll i=0;i<n;i++)
+	{
+		cin>>a[i];
+	}
+	ll max=INT_MIN;
+	for(ll i=0;i<n;i++)
+	{
+		ll temp=0;
+		for(ll j=i;j<n;j++)
+		{
+			temp+=a[j];
+			if(max<temp)
+			{
+				max=temp;
+			}
+		}
+	}
+cout<<"max="<<max;
+
+	return 0;
+}
\ No newline at end of file