hdu1423||hdu4512--LCIS--try

要学的 太多了.

学到的 都是有用的 即便你不会在比赛中遇到这个类型的 但是开拓了你的思维

这2题 都是LCIS-Longest Common Increase Subsequence

我是在这边学习的   传送

这篇写的很好.

我觉得对于4512要好好理解下啊  我想了好久 太白痴了....注意下 数组的对称性

1423:

 1 #include <iostream>
 2 #include <cstring>
 3 #include <algorithm>
 4 using namespace std;
 5
 6 const int size = 520;
 7 int dp[size];
 8 int ss[size] , tt[size];
 9 int n , m;
10
11 void LCIS( )
12 {
13     int max_len;
14     for( int i = 1 ; i<=n ; i++ )
15     {
16         max_len = 0;
17         for( int j = 1 ; j<=m ; j++ )
18         {
19             if( ss[i] > tt[j] )
20             {
21                 max_len = max( max_len , dp[j] );
22             }
23             else if( ss[i] == tt[j] )
24             {
25                 dp[j] = max_len + 1;
26             }
27         }
28     }
29 }
30
31 int main()
32 {
33     cin.sync_with_stdio(false);
34     int t , ans;
35     cin >> t;
36     while( t-- )
37     {
38         memset( dp , 0 , sizeof(dp) );
39         cin >> n;
40         for( int i = 1 ; i<=n ; i++ )
41         {
42             cin >> ss[i];
43         }
44         cin >> m;
45         for( int i = 1 ; i<=m ; i++ )
46         {
47             cin >> tt[i];
48         }
49         LCIS( );
50         ans = 0;
51         for( int i = 1 ; i<=m ; i++ )
52         {
53             ans = max( ans , dp[i] );
54         }
55         cout << ans << endl;
56         if(t)
57             cout << endl;
58     }
59     return 0;
60 }

4512:

 1 #include <iostream>
 2 #include <cstring>
 3 #include <algorithm>
 4 using namespace std;
 5
 6 const int size = 210;
 7 int dp[size];
 8 int ss[size] , tt[size];
 9 int n;
10
11 int LCIS( )
12 {
13     int max_len , ans = 1;
14     for( int i = 1 ; i<=n ; i++ )
15     {
16         max_len = 0;
17         for( int j = 1 ; j<=n-i+1 ; j++ )
18         {
19             if( ss[i] > tt[j] )
20             {
21                 max_len = max( max_len , dp[j] );
22             }
23             else if( ss[i] == tt[j] )
24             {
25                 dp[j] = max_len + 1;
26             }
27             if( i!=n-j+1 )
28             {
29                 ans = max( ans , dp[j]*2 );
30             }
31             else
32             {
33                 ans = max( ans , dp[j]*2-1 );
34             }
35         }
36     }
37     return ans;
38 }
39
40 int main()
41 {
42     cin.sync_with_stdio(false);
43     int t , ans;
44     cin >> t;
45     while( t-- )
46     {
47         memset( dp , 0 , sizeof(dp) );
48         cin >> n;
49         for( int i = 1 ; i<=n ; i++ )
50         {
51             cin >> ss[i];
52             tt[n+1-i] = ss[i];
53         }
54         cout << LCIS( ) << endl;
55     }
56     return 0;
57 }

today:

  不知不觉就长到了要爱要哀愁要纠结要迟疑要理性要偷渡要分别的年龄

时间: 2024-10-03 03:55:50

hdu1423||hdu4512--LCIS--try的相关文章

DP总结 ——QPH

常见优化 单调队列 形式 dp[i]=min{f(k)} dp[i]=max{f(k)} 要求 f(k)是关于k的函数 k的范围和i有关 转移方法 维护一个单调递增(减)的队列,可以在两头弹出元素,一头压入元素. 队列中维护的是两个值.一个是位置,这和k的范围有关系,另外一个是f(k)的值,这个用来维护单调性,当然如果f(k)的值可以利用dp值在O(1)的时间内计算出来的话队列中可以只维护一个表示位置的变量. 枚举到一个i的时候,首先判断队首元素的位置是否已经不满足k的范围了,如果不满足就将队首

HDU1423 最长公共上升子序列LCIS

Problem Description This is a problem from ZOJ 2432.To make it easyer,you just need output the length of the subsequence. Input Each sequence is described with M - its length (1 <= M <= 500) and M integer numbers Ai (-2^31 <= Ai < 2^31) - the

HDU-1423 最长公共上升子序列(LCIS)

问题描述: 给定两个字符串x, y, 求它们公共子序列s, 满足si < sj ( 0 <= i < j < |s|).要求S的长度是所有条件序列中长度最长的. 做过最长公共子序列应该更容易明白了. 定义状态d[i][j]表示以a数组的前i个元素,b数组的前j个元素并且以b[j]为结尾的LCIS的长度. 首先:a[i] != b[j]时, d[i][j] = d[i-1][j]; 因为 d[i][j] 是以 b[j] 为结尾的LCIS,如果 d[i][j] > 0 那么就说明

hdu1423 LCIS

题意:求最长公共上升子序列的长度 代码: #include <algorithm> #include <iostream> #include <sstream> #include <cstdlib> #include <cstring> #include <iomanip> #include <cstdio> #include <string> #include <bitset> #include

hdu--3308 LCIS(线段树+区间合并)

Description Given n integers. You have two operations: U A B: replace the Ath number by B. (index counting from 0) Q A B: output the length of the longest consecutive increasing subsequence (LCIS) in [a, b]. Input T in the first line, indicating the

HDU3308 LCIS

Time Limit: 2000MS   Memory Limit: 32768KB   64bit IO Format: %I64d & %I64u Description Given n integers. You have two operations: U A B: replace the Ath number by B. (index counting from 0) Q A B: output the length of the longest consecutive increas

hdu 3308 LCIS(线段树)

pid=3308" target="_blank" style="">题目链接:hdu 3308 LCIS 题目大意:给定一个序列,两种操作: Q l r:查询区间l,r中的最长连续递增序列长度 U p x:将位置p上的数改成x 解题思路:线段树上的区间合并,这是在左右子树合并的时候要推断一下是否满足递增就可以. #include <cstdio> #include <cstring> #include <algorit

hdu 3308 LCIS(线段树区间合并)

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=3308 LCIS Time Limit: 6000/2000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 5792    Accepted Submission(s): 2513 Problem Description Given n integers. You have two

HDU 3308 LCIS(线段树区间合并)

Problem Description Given n integers. You have two operations: U A B: replace the Ath number by B. (index counting from 0) Q A B: output the length of the longest consecutive increasing subsequence (LCIS) in [a, b]. Input T in the first line, indicat

线段树 [HDU 3308] LCIS

LCIS Time Limit: 6000/2000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)Total Submission(s): 4437    Accepted Submission(s): 2006 Problem Description Given n integers.You have two operations:U A B: replace the Ath number by B. (index