如何求一个（正数）无序数组中最长有序子数组的长度？
答案:2 悬赏:0
解决时间 2021-01-19 09:26
- 提问者网友：放下
- 2021-01-19 00:24
如何求一个（正数）无序数组中最长有序子数组的长度？
最佳答案
- 二级知识专家网友：妄饮晩冬酒
- 2021-01-19 01:43
据题目的要求，求一维数组中的最长递增子序列，也就是找一个标号的序列b[0],b[1],…,b[m](0 <= b[0] < b[1] < … < b[m] < N)，使得array[b[0]]
根据无后效性的定义我们知道，将各阶段按照一定的次序排列好之后，对于某个给定的阶段状态来说，它以前各阶段的状态无法直接影响它未来的决策，而只能间接地通过当前的这个状态来影响。换句话说，每个状态都是历史的一个完整总结。
同样的，仍以序列1，-1，2，-3，4，-5，6，-7为例，我们在找到4之后，并不关心4之前的两个值具体是怎样，因为它对找到6没有直接影响。因此，这个问题满足无后效性，可以通过使用动态规划来解决。
可以通过数字的规律来分析目标串：1，-1，2，-3，4，-5，6，-7。
使用i来表示当前遍历的位置
当i=1时，显然，最长的递增序列为（1），序列长度为1.
当i=2是，由于-1<1。因此，必须丢弃第一个值后重新建立串。当前的递增序列为（-1），长度为1。
当i=3时，由于2>1,2>-1。因此，最长的递增序列为（1,2）,(-1,2),长度为2。在这里，2前面是1还是-1对求出后面的递增序列没有直接影响。（但是在其它情况下可能有影响）
依此类推之后，我们得出如下的结论。
假设在目标数组array[]的前i个元素中，最长递增子序列的长度为LIS[i]。那么，
LIS[i+1]=max{1,LIS[k]+1}, array[i+1]>array[k], for any k <= i
即如果array[i+1]大于array[k],那么第i+1个元素可以接在LIS[k]长的子序列后面构成一个更长的子序列。于此同时array[i+1]本身至少可以构成一个长度为1的子序列。
根据上面的分析，就可以得到代码清单：
C++代码：
代码如下:
int Max(int *a, int n)
{
int max = a[0];
for(int i = 1; i < n; i++)
if(max < a[i])
max = a[i];
return max;
}
int LIS(vector &array)
{
int *a = new int[array.size()];
for(int i = 0; i < array.size(); i++)
{
a[i] = 1;//初始化默认的长度
for(int j = 0; j < i; j++) //前面最长的序列
{
if(array [i] > array [j] && a[j] + 1 > a[i]) //当前数字比第j个大，且标记数组需要更新
{
a[i] = a[j] + 1;
}
}
}
return Max(a, array.size());
}
这种方法的时间复杂度为O(N2 + N) = O(N2)
根据无后效性的定义我们知道，将各阶段按照一定的次序排列好之后，对于某个给定的阶段状态来说，它以前各阶段的状态无法直接影响它未来的决策，而只能间接地通过当前的这个状态来影响。换句话说，每个状态都是历史的一个完整总结。
同样的，仍以序列1，-1，2，-3，4，-5，6，-7为例，我们在找到4之后，并不关心4之前的两个值具体是怎样，因为它对找到6没有直接影响。因此，这个问题满足无后效性，可以通过使用动态规划来解决。
可以通过数字的规律来分析目标串：1，-1，2，-3，4，-5，6，-7。
使用i来表示当前遍历的位置
当i=1时，显然，最长的递增序列为（1），序列长度为1.
当i=2是，由于-1<1。因此，必须丢弃第一个值后重新建立串。当前的递增序列为（-1），长度为1。
当i=3时，由于2>1,2>-1。因此，最长的递增序列为（1,2）,(-1,2),长度为2。在这里，2前面是1还是-1对求出后面的递增序列没有直接影响。（但是在其它情况下可能有影响）
依此类推之后，我们得出如下的结论。
假设在目标数组array[]的前i个元素中，最长递增子序列的长度为LIS[i]。那么，
LIS[i+1]=max{1,LIS[k]+1}, array[i+1]>array[k], for any k <= i
即如果array[i+1]大于array[k],那么第i+1个元素可以接在LIS[k]长的子序列后面构成一个更长的子序列。于此同时array[i+1]本身至少可以构成一个长度为1的子序列。
根据上面的分析，就可以得到代码清单：
C++代码：
代码如下:
int Max(int *a, int n)
{
int max = a[0];
for(int i = 1; i < n; i++)
if(max < a[i])
max = a[i];
return max;
}
int LIS(vector
{
int *a = new int[array.size()];
for(int i = 0; i < array.size(); i++)
{
a[i] = 1;//初始化默认的长度
for(int j = 0; j < i; j++) //前面最长的序列
{
if(array [i] > array [j] && a[j] + 1 > a[i]) //当前数字比第j个大，且标记数组需要更新
{
a[i] = a[j] + 1;
}
}
}
return Max(a, array.size());
}
这种方法的时间复杂度为O(N2 + N) = O(N2)
全部回答
- 1楼网友：旧脸谱
- 2021-01-19 02:10
据题目的要求，求一维数组中的最长递增子序列，也就是找一个标号的序列b[0],b[1],…,b[m](0 <= b[0] < b[1] < … < b[m] < N)，使得array[b[0]]根据无后效性的定义我们知道，将各阶段按照一定的次序排列好之后，对于某个给定的阶段状态来说，它以前各阶段的状态无法直接影响它未来的决策，而只能间接地通过当前的这个状态来影响。换句话说，每个状态都是历史的一个完整总结。
同样的，仍以序列1，-1，2，-3，4，-5，6，-7为例，我们在找到4之后，并不关心4之前的两个值具体是怎样，因为它对找到6没有直接影响。因此，这个问题满足无后效性，可以通过使用动态规划来解决。
可以通过数字的规律来分析目标串：1，-1，2，-3，4，-5，6，-7。
使用i来表示当前遍历的位置
当i=1时，显然，最长的递增序列为（1），序列长度为1.
当i=2是，由于-1<1。因此，必须丢弃第一个值后重新建立串。当前的递增序列为（-1），长度为1。
当i=3时，由于2>1,2>-1。因此，最长的递增序列为（1,2）,(-1,2),长度为2。在这里，2前面是1还是-1对求出后面的递增序列没有直接影响。（但是在其它情况下可能有影响）
依此类推之后，我们得出如下的结论。
假设在目标数组array[]的前i个元素中，最长递增子序列的长度为LIS[i]。那么，
LIS[i+1]=max{1,LIS[k]+1}, array[i+1]>array[k], for any k <= i
即如果array[i+1]大于array[k],那么第i+1个元素可以接在LIS[k]长的子序列后面构成一个更长的子序列。于此同时array[i+1]本身至少可以构成一个长度为1的子序列。
根据上面的分析，就可以得到代码清单：
C++代码：
代码如下:
int Max(int *a, int n)
{
int max = a[0];
for(int i = 1; i < n; i++)
if(max < a[i])
max = a[i];
return max;
}
int LIS(vector &array)
{
int *a = new int[array.size()];
for(int i = 0; i < array.size(); i++)
{
a[i] = 1;//初始化默认的长度
for(int j = 0; j < i; j++) //前面最长的序列
{
if(array [i] > array [j] && a[j] + 1 > a[i]) //当前数字比第j个大，且标记数组需要更新
{
a[i] = a[j] + 1;
}
}
}
return Max(a, array.size());
}
这种方法的时间复杂度为O(N2 + N) = O(N2)追问谢谢大神，感觉确实应该是dp问题，我试了下代码，可以运行，就是复杂度太高，超时了，能不能将复杂度降低点?算法导论（第三版）P226的15.4-6提到有O(nlgn)的方法，不知大神能否研究下这种可能？追答复杂度为O(nlogn)的算法，其思想是设一个辅助数组temp,temp[i]表示长度为i+1（也就是程序中的len）的最长递增子序列的最小末尾，则显然temp是有序的。遍历原数组中的每一个元素，对于每个元素key，若比temp数组中当前最后一个元素大，则直接插入temp数组，表示最长递增子序列长度可以增加一，新的LIS以这个元素结尾；否则要么temp中已包含key这个元素，则不做任何操作，要么temp中的数全部大于这个元素，则key取代temp[0]成为长度为1的LIS的结尾元素，要么必然存在temp[j]
同样的，仍以序列1，-1，2，-3，4，-5，6，-7为例，我们在找到4之后，并不关心4之前的两个值具体是怎样，因为它对找到6没有直接影响。因此，这个问题满足无后效性，可以通过使用动态规划来解决。
可以通过数字的规律来分析目标串：1，-1，2，-3，4，-5，6，-7。
使用i来表示当前遍历的位置
当i=1时，显然，最长的递增序列为（1），序列长度为1.
当i=2是，由于-1<1。因此，必须丢弃第一个值后重新建立串。当前的递增序列为（-1），长度为1。
当i=3时，由于2>1,2>-1。因此，最长的递增序列为（1,2）,(-1,2),长度为2。在这里，2前面是1还是-1对求出后面的递增序列没有直接影响。（但是在其它情况下可能有影响）
依此类推之后，我们得出如下的结论。
假设在目标数组array[]的前i个元素中，最长递增子序列的长度为LIS[i]。那么，
LIS[i+1]=max{1,LIS[k]+1}, array[i+1]>array[k], for any k <= i
即如果array[i+1]大于array[k],那么第i+1个元素可以接在LIS[k]长的子序列后面构成一个更长的子序列。于此同时array[i+1]本身至少可以构成一个长度为1的子序列。
根据上面的分析，就可以得到代码清单：
C++代码：
代码如下:
int Max(int *a, int n)
{
int max = a[0];
for(int i = 1; i < n; i++)
if(max < a[i])
max = a[i];
return max;
}
int LIS(vector
{
int *a = new int[array.size()];
for(int i = 0; i < array.size(); i++)
{
a[i] = 1;//初始化默认的长度
for(int j = 0; j < i; j++) //前面最长的序列
{
if(array [i] > array [j] && a[j] + 1 > a[i]) //当前数字比第j个大，且标记数组需要更新
{
a[i] = a[j] + 1;
}
}
}
return Max(a, array.size());
}
这种方法的时间复杂度为O(N2 + N) = O(N2)追问谢谢大神，感觉确实应该是dp问题，我试了下代码，可以运行，就是复杂度太高，超时了，能不能将复杂度降低点?算法导论（第三版）P226的15.4-6提到有O(nlgn)的方法，不知大神能否研究下这种可能？追答复杂度为O(nlogn)的算法，其思想是设一个辅助数组temp,temp[i]表示长度为i+1（也就是程序中的len）的最长递增子序列的最小末尾，则显然temp是有序的。遍历原数组中的每一个元素，对于每个元素key，若比temp数组中当前最后一个元素大，则直接插入temp数组，表示最长递增子序列长度可以增加一，新的LIS以这个元素结尾；否则要么temp中已包含key这个元素，则不做任何操作，要么temp中的数全部大于这个元素，则key取代temp[0]成为长度为1的LIS的结尾元素，要么必然存在temp[j]
我要举报
如以上问答内容为低俗、色情、不良、暴力、侵权、涉及违法等信息，可以点下面链接进行举报！
大家都在看
推荐资讯