Monotonically incrementing and monotonic incrementing

Monotonically incrementing and monotonic incrementing
Monotonically incrementing longest son Sequence

Time Limit: 3000 MS | memory limit: 65535 KB

Difficulty: 4

Description

Returns the length of the longest incrementing sub-sequence of a string.
For example, the longest incremental sub-sequence of dabdbf is abdf and the length is 4.

Input

The first line has an integer of 0 <n <20, indicating that n strings are to be processed.
Next n rows, each line has a string, the length of the string will not exceed 10000

Output

Length of the longest incrementing sub-sequence of the output string

Sample Input

3 aaaababcabklmncdefg

Sample output

137

 

Program code:
# Include <stdio. h>

# Include <string. h>

# Include <stdlib. h>

 

Int leng1, leng2 = 26;

Int num [27] [10001];

Char errors [10001], ch2 [] = "abcdefghijklmnopqrstuvwxyz ";

 

Void LCSLength ()

{

Int I, j;

For (I = 1; I <= leng2; I ++)

For (j = 1; j <= leng1; j ++)

{

If (else [J-1] = ch2 [I-1])

Num [I] [j] = num [I-1] [J-1] + 1;

Else

{

If (num [I-1] [j]> num [I] [J-1])

Num [I] [j] = num [I-1] [j];

Else

Num [I] [j] = num [I] [J-1];

}

}

}

 

 

Int main ()

{

Int n;

Scanf ("% d", & n );

Getchar ();

While (n --)

{

Scanf ("% s", callback );

Leng1 = strlen (dependencies );

LCSLength ();

Printf ("% d \ n", num [leng2] [leng1]);

}

System ("pause ");

Return 0;

}

 

 

On which page is the introduction to algorithms?

Chapter 2: Dynamic Planning in the form of exercises

Design an O (n2) time algorithm to find the longest monotonic increasing subsequence of the series composed of n numbers

Just use the greedy algorithm.

Create a stack and scan the entire sequence sequentially.
The first element is first placed in the stack,
For each element scanned later, if it is larger than the top element of the stack, it will be pushed into the stack. If it is smaller than the top element of the stack, it will be played one by one until it is found that the top element of the stack is smaller than it.
Record the stack length at a time and its maximum value. After a sequence scan is completed, the maximum length of the stack is the longest sequence, and the element in the stack at the maximum length is the largest incremental sequence.
This algorithm is O (N ^ 2) level, but faster than dp.