Algorithm 求最大和的最长递增子序列
给定一个可以是正的和负的数字序列,有几种算法可以找到最长的递增子序列。但是,如果有多个最长的递增子序列,有人能给我一个算法来找到具有最大和的最长递增子序列吗 例如:对于20,1,4,3,10,答案是1,4,10,而不是1,3,10Algorithm 求最大和的最长递增子序列,algorithm,Algorithm,给定一个可以是正的和负的数字序列,有几种算法可以找到最长的递增子序列。但是,如果有多个最长的递增子序列,有人能给我一个算法来找到具有最大和的最长递增子序列吗 例如:对于20,1,4,3,10,答案是1,4,10,而不是1,3,10dpLen[i]=最大和以i结尾的LIS的最大长度 dpLen[i] = maximum length of a LIS with maximum sum ending at i dpSum[i] = maximum sum of a LIS with maximum
dpLen[i]=最大和以i结尾的LIS的最大长度
dpLen[i] = maximum length of a LIS with maximum sum ending at i
dpSum[i] = maximum sum of a LIS with maximum sum ending at i
for i = 0 to n do
dpLen[i] = 1
dpSum[i] = input[i]
maxLen = 0
for j = 0 to i do
if dpLen[j] > maxLen and input[j] < input[i]
maxLen = dpLen[j]
for j = 0 to i do
if dpLen[j] == maxLen and input[j] < input[i] and dpSum[j] + input[i] > dpSum[i]
dpSum[i] = dpSum[j] + input[i]
dpLen[i] = maxLen + 1
dpSum[i]=最大和以i结尾的LIS的最大和
对于i=0到n do
dpLen[i]=1
dpSum[i]=输入[i]
maxLen=0
对于j=0,我会这样做
如果dpLen[j]>maxLen并输入[j]dpSum[i]
dpSum[i]=dpSum[j]+输入[i]
dpLen[i]=maxLen+1
这是一个动态规划问题。下面是一个工作示例。我试着对代码进行注释。但是,如果您最近没有接触过动态编程概念,那么很难理解解决方案
解决方案可以被认为是
S(j)=最大值{
结束于j的最长和子序列的和(即包括a[j]),
S(j-1)
}
public class LongestSumSequence{
public static void printLongestSumSubsequence(int[] seq) {
int[] S = new int[seq.length];
//S[j] contains the longest sum of subsequence a1,a2,a3,....,aj
//So a sub sequence with length 1 will only contain first element.
//Hence we initialize it like this
S[0] = seq[0];
int min_index = 0;
int max_index = 0;
//Now like any dynamic problem we proceed by solving sub problems and
//using results of subproblems to calculate bigger problems
for(int i = 1; i < seq.length; i++) {
//Finding longest sum sub-sequence ending at j
int max = seq[i];
int idx = i;
int sum = seq[i];
for(int j = i-1; j >=0 ; j--) {
sum += seq[j];
if(max < sum) {
idx = j;
max = sum;
}
}
//Now we know the longest sum subsequence ending at j, lets see if its
//sum is bigger than S(i-1) or less
//This element is part of longest sum subsequence
if(max > S[i-1]) {
S[i] = max;
max_index = i;
min_index = idx;
} else {
//This element is not part of longest sum subsequence
S[i] = S[i-1];
}
}
System.out.println("Biggest Sum : "+S[seq.length - 1]);
//Print the sequence
for(int idx = min_index; idx <= max_index; idx++) {
System.out.println("Index " + idx + "Element " + seq[idx]);
}
}
public static void main(String[] args) {
int[] seq = {5,15,-30,10,-5,40,10};
printLongestSumSubsequence(seq);
}
}
公共类最长序列{
公共静态无效打印最长消费序列(int[]seq){
int[]S=新的int[序列长度];
//S[j]包含子序列a1、a2、a3、…、aj的最长和
//因此,长度为1的子序列将只包含第一个元素。
//因此我们像这样初始化它
S[0]=序列[0];
int min_指数=0;
int max_指数=0;
//现在就像任何动态问题一样,我们通过解决子问题和
//利用子问题的结果计算更大的问题
对于(int i=1;i=0;j--){
总和+=序号[j];
如果(maxS[i-1]){
S[i]=max;
最大指数=i;
最小指数=idx;
}否则{
//此元素不是最长和子序列的一部分
S[i]=S[i-1];
}
}
System.out.println(“最大和:+S[序列长度-1]);
//打印序列
对于(int idx=min_index;idx),如果最长和最大和之间存在冲突,您会怎么做?1,2,3,10,4,5=>sum(1,2,3,10)>sum(1,2,3,4,5),但第二个更长。