Given a string **S**, the task is to find the length of the longest increasing subsequence present in the given string.

A sequence of characters placed in increasing order of their ASCII values is called an increasing sequence.

**Examples:**

Input:S = “abcfgffs”Output:6Explanation:Subsequence “abcfgs” is the longest increasing subsequence present in the string. Therefore, the length of the longest increasing subsequence is6.

Input:S = “aaabac”Output:3

**Approach: **The idea is to use Dynamic Programming. Follow the steps given below to solve the problem:

- Initialize an array, say
**dp[]**of size**26**, to store at every**i**^{th}index, the length of the longest increasing subsequence having**(‘a’ + i)**^{th}character as the last character in the subsequence. - Initialize variable, say
**lis**, to store the length of the required subsequence. - Iterate over each character of the string
**S**.- For every character encountered, i.e.
**S[i] – ‘a’**, check for all characters, say**j**, with ASCII values smaller than that of the current character. - Initialize a variable, say
**curr**, to store the length of LIS ending with current character. - Update
**curr**with**max(curr, dp[j]).** - Update length of the LIS, say
**lis,**with**max(lis, curr + 1).** - Update
**dp[S[i] – ‘a’]**with max of**d[S[i] – ‘a’]**and**curr.**

- For every character encountered, i.e.
- Finally, print the value of
**lis**as the required length of LIS.

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to find length of longest` `// increasing subsequence in a string` `int` `lisOtimised(string s)` `{` ` ` `// Stores at every i-th index, the` ` ` `// length of the longest increasing` ` ` `// subsequence ending with character i` ` ` `int` `dp[30] = { 0 };` ` ` `// Size of string` ` ` `int` `N = s.size();` ` ` `// Stores the length of LIS` ` ` `int` `lis = INT_MIN;` ` ` `// Iterate over each` ` ` `// character of the string` ` ` `for` `(` `int` `i = 0; i < N; i++) {` ` ` `// Store position of the` ` ` `// current character` ` ` `int` `val = s[i] - ` `'a'` `;` ` ` `// Stores the length of LIS` ` ` `// ending with current character` ` ` `int` `curr = 0;` ` ` `// Check for all characters` ` ` `// less then current character` ` ` `for` `(` `int` `j = 0; j < val; j++) {` ` ` `curr = max(curr, dp[j]);` ` ` `}` ` ` `// Include current character` ` ` `curr++;` ` ` `// Update length of longest` ` ` `// increasing subsequence` ` ` `lis = max(lis, curr);` ` ` `// Updating LIS for current character` ` ` `dp[val] = max(dp[val], curr);` ` ` `}` ` ` `// Return the length of LIS` ` ` `return` `lis;` `}` `// Driver Code` `int` `main()` `{` ` ` `string s = ` `"fdryutiaghfse"` `;` ` ` `cout << lisOtimised(s);` ` ` `return` `0;` `}` |

## Java

`// Java program for the above approach` `import` `java.util.*;` `class` `GFG{` ` ` `static` `int` `mn = -` `2147483648` `;` ` ` `// Function to find length of longest` `// increasing subsequence in a string` `static` `int` `lisOtimised(String s)` `{` ` ` ` ` `// Stores at every i-th index, the` ` ` `// length of the longest increasing` ` ` `// subsequence ending with character i` ` ` `int` `[]dp = ` `new` `int` `[` `30` `];` ` ` `Arrays.fill(dp, ` `0` `);` ` ` `// Size of string` ` ` `int` `N = s.length();` ` ` `// Stores the length of LIS` ` ` `int` `lis = mn;` ` ` `// Iterate over each` ` ` `// character of the string` ` ` `for` `(` `int` `i = ` `0` `; i < N; i++)` ` ` `{` ` ` ` ` `// Store position of the` ` ` `// current character` ` ` `int` `val = (` `int` `)s.charAt(i) - ` `97` `;` ` ` `// Stores the length of LIS` ` ` `// ending with current character` ` ` `int` `curr = ` `0` `;` ` ` `// Check for all characters` ` ` `// less then current character` ` ` `for` `(` `int` `j = ` `0` `; j < val; j++)` ` ` `{` ` ` `curr = Math.max(curr, dp[j]);` ` ` `}` ` ` `// Include current character` ` ` `curr++;` ` ` `// Update length of longest` ` ` `// increasing subsequence` ` ` `lis = Math.max(lis, curr);` ` ` `// Updating LIS for current character` ` ` `dp[val] = Math.max(dp[val], curr);` ` ` `}` ` ` `// Return the length of LIS` ` ` `return` `lis;` `}` `// Driver Code` `public` `static` `void` `main(String[] args)` `{` ` ` `String s = ` `"fdryutiaghfse"` `;` ` ` ` ` `System.out.print(lisOtimised(s));` `}` `}` `// This code is contributed by sanjoy_62` |

## Python3

`# Python3 program for the above approach` `# Function to find length of longest` `# increasing subsequence in a string` `def` `lisOtimised(s):` ` ` ` ` `# Stores at every i-th index, the` ` ` `# length of the longest increasing` ` ` `# subsequence ending with character i` ` ` `dp ` `=` `[` `0` `]` `*` `30` ` ` `# Size of string` ` ` `N ` `=` `len` `(s)` ` ` `# Stores the length of LIS` ` ` `lis ` `=` `-` `10` `*` `*` `9` ` ` `# Iterate over each` ` ` `# character of the string` ` ` `for` `i ` `in` `range` `(N):` ` ` `# Store position of the` ` ` `# current character` ` ` `val ` `=` `ord` `(s[i]) ` `-` `ord` `(` `'a'` `)` ` ` `# Stores the length of LIS` ` ` `# ending with current character` ` ` `curr ` `=` `0` ` ` `# Check for all characters` ` ` `# less then current character` ` ` `for` `j ` `in` `range` `(val):` ` ` `curr ` `=` `max` `(curr, dp[j])` ` ` `# Include current character` ` ` `curr ` `+` `=` `1` ` ` `# Update length of longest` ` ` `# increasing subsequence` ` ` `lis ` `=` `max` `(lis, curr)` ` ` `# Updating LIS for current character` ` ` `dp[val] ` `=` `max` `(dp[val], curr)` ` ` `# Return the length of LIS` ` ` `return` `lis` `# Driver Code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` `s ` `=` `"fdryutiaghfse"` ` ` `print` `(lisOtimised(s))` `# This code is contributed by mohit kumar 29.` |

## C#

`// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG` `{` ` ` `static` `int` `mn = -2147483648;` ` ` ` ` `// Function to find length of longest` `// increasing subsequence in a string` `static` `int` `lisOtimised(` `string` `s)` `{` ` ` ` ` `// Stores at every i-th index, the` ` ` `// length of the longest increasing` ` ` `// subsequence ending with character i` ` ` `int` `[]dp = ` `new` `int` `[30];` ` ` `Array.Clear(dp, 0, 30);` ` ` `// Size of string` ` ` `int` `N = s.Length;` ` ` `// Stores the length of LIS` ` ` `int` `lis = mn;` ` ` `// Iterate over each` ` ` `// character of the string` ` ` `for` `(` `int` `i = 0; i < N; i++) {` ` ` `// Store position of the` ` ` `// current character` ` ` `int` `val = (` `int` `)s[i] - 97;` ` ` `// Stores the length of LIS` ` ` `// ending with current character` ` ` `int` `curr = 0;` ` ` `// Check for all characters` ` ` `// less then current character` ` ` `for` `(` `int` `j = 0; j < val; j++) {` ` ` `curr = Math.Max(curr, dp[j]);` ` ` `}` ` ` `// Include current character` ` ` `curr++;` ` ` `// Update length of longest` ` ` `// increasing subsequence` ` ` `lis = Math.Max(lis, curr);` ` ` `// Updating LIS for current character` ` ` `dp[val] = Math.Max(dp[val], curr);` ` ` `}` ` ` `// Return the length of LIS` ` ` `return` `lis;` `}` `// Driver Code` `public` `static` `void` `Main()` `{` ` ` `string` `s = ` `"fdryutiaghfse"` `;` ` ` `Console.Write(lisOtimised(s));` `}` `}` `// This code is contributed by SURENDRA_GAANGWAR.` |

**Output:**

4

**Time Complexity:** O(N)**Auxiliary Space: **O(1)

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the **Essential Maths for CP Course** at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**