Java 我的分割序列代码并不能解决它遇到的所有问题
这个问题是关于正整数序列a1，a2，…，aN。序列的子序列是通过删除某些元素而获得的任何结果。例如，3,7,11,3是6的子序列，3，11,5，7，4,3，11，5，3，但3,3,7不是6,3,11,5,7,4,3,11,5,3的子序列 全分割序列是序列a1，a2，…，其中ai在iJava 我的分割序列代码并不能解决它遇到的所有问题,java,arrays,sequence,dynamic-programming,Java,Arrays,Sequence,Dynamic Programming,这个问题是关于正整数序列a1，a2，…，aN。序列的子序列是通过删除某些元素而获得的任何结果。例如，3,7,11,3是6的子序列，3，11,5，7，4,3，11，5，3，但3,3,7不是6,3,11,5,7,4,3,11,5,3的子序列 全分割序列是序列a1，a2，…，其中ai在i0&¤t>0&&……我已经将您的代码的结果与上次更新后的代码进行了比较。对于我定义的11个测试，这两种解决方案都给出了相同的结果。这是一个不错的答案，但我不相信它在大型阵列上会表现得那么好，因为它是O（n！
protected static int[] subsequence(int[] seq) {
int[] longestSub = new int[0];
for (int i = 0; i < seq.length; i++) {
int[] subAtI = subseq(subarray(seq, i));
if (longestSub.length < subAtI.length) {
longestSub = subAtI;
}
}
return longestSub;
}
private static int[] subseq(int[] seq) {
if (seq.length == 1) {
return seq;
}
int[] longestSub = new int[0];
int current = seq[0];
for (int i = 1; i < seq.length; i++) {
int number = seq[i];
if (number > 0 && current > 0 && number % current == 0) {
int[] subAtI = subseq(subarray(seq, i));
if (longestSub.length < subAtI.length) {
longestSub = subAtI;
}
}
}
return concat(current, longestSub);
}
private static int[] concat(int current, int[] sub) {
int[] result = new int[sub.length + 1];
result[0] = current;
System.arraycopy(sub, 0, result, 1, sub.length);
return result;
}
private static int[] subarray(int[] seq, int i) {
int length = seq.length - i;
int[] result = new int[length];
System.arraycopy(seq, i, result, 0, length);
return result;
}
protected static int[] subsequence(int[] seq) {
int[] longestSub = new int[0];
for (int i = 0; i < seq.length; i++) {
int[] subAtI = subseq(subarray(seq, i));
if (longestSub.length < subAtI.length) {
longestSub = subAtI;
}
}
return longestSub;
}
private static int[] subseq(int[] seq) {
if (seq.length == 1) {
return seq;
}
int[] longestSub = new int[0];
int current = seq[0];
for (int i = 1; i < seq.length; i++) {
int number = seq[i];
if (number > 0 && current > 0 && number % current == 0) {
int[] subAtI = subseq(subarray(seq, i));
if (longestSub.length < subAtI.length) {
longestSub = subAtI;
}
}
}
return concat(current, longestSub);
}
private static int[] concat(int current, int[] sub) {
int[] result = new int[sub.length + 1];
result[0] = current;
System.arraycopy(sub, 0, result, 1, sub.length);
return result;
}
private static int[] subarray(int[] seq, int i) {
int length = seq.length - i;
int[] result = new int[length];
System.arraycopy(seq, i, result, 0, length);
return result;
}
import java.util.Scanner;
class DivSeq {
private int n, input[];
void accept() {
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
input = new int[n];
for(int i = 0; i<n; i++)
input[i] = sc.nextInt();
sc.close();
}
int size(int a[]) {
//this function returns the number of non zero entries in an array
int ctr = 0;
for(int i = 0; i<a.length; i++) {
if(a[i]==0)
break;
else
ctr++;
}
return ctr;
}
int sequence() {
int subseq[], pvrseq[], seq[], j, a = 1, q, k = 1, f = 0;
subseq = new int [n];
pvrseq = new int [n];
seq = new int [n];
for(int i = 0; i<n-1; i++) {
k = 1;
for(int c = 0; c<seq.length; c++)
seq[c] = 0;
//seq has been initialized, now inserting 1st value
seq[0] = input[i];
//creating the sequence
for(j = i+1; j<n; j++) {
if(input[j]%input[i]==0)
seq[k++] = input[j];
}
//if size of sequence is 1, then there is no use of checking it
if(size(seq)<2)
continue;
subseq[0] = seq[0];
a = 1;
while(a<size(seq)-1) {
k = 2;
for(int p = a; p<size(seq)-1; p++) {
//initial value of subsequence
if(subseq[1] == 0)
subseq[1] = seq[p];
//creating the subsequence
for(q = p+1; q<size(seq); q++) {
if(seq[q]%seq[p]==0) {
subseq[k++] = seq[q];
p = q-1;
f = 1;
break;
}
}
if(f==1 && q==size(seq)-1)
break;
}
//checking the size of subsequence and previous sequence
if(size(pvrseq)<size(subseq)) {
for(int y = 0; y<subseq.length; y++)
pvrseq[y] = subseq[y];
for(int y = 1; y<subseq.length; y++)
subseq[y] = 0;
}
a++;
}
}
return size(pvrseq);
}
public static void main(String [] args) {
DivSeq obj = new DivSeq();
obj.accept();
System.out.println(obj.sequence());
}
}
import java.util.Scanner；
类DivSeq{
私有整数n，输入[]；
无效接受（）{
扫描仪sc=新的扫描仪（System.in）；
n=sc.nextInt（）；
输入=新整数[n]；
对于（int i=0；i我将采用递归方法来确定序列的最长子序列
protected static int[] subsequence(int[] seq) {
int[] longestSub = new int[0];
for (int i = 0; i < seq.length; i++) {
int[] subAtI = subseq(subarray(seq, i));
if (longestSub.length < subAtI.length) {
longestSub = subAtI;
}
}
return longestSub;
}
private static int[] subseq(int[] seq) {
if (seq.length == 1) {
return seq;
}
int[] longestSub = new int[0];
int current = seq[0];
for (int i = 1; i < seq.length; i++) {
int number = seq[i];
if (number > 0 && current > 0 && number % current == 0) {
int[] subAtI = subseq(subarray(seq, i));
if (longestSub.length < subAtI.length) {
longestSub = subAtI;
}
}
}
return concat(current, longestSub);
}
private static int[] concat(int current, int[] sub) {
int[] result = new int[sub.length + 1];
result[0] = current;
System.arraycopy(sub, 0, result, 1, sub.length);
return result;
}
private static int[] subarray(int[] seq, int i) {
int length = seq.length - i;
int[] result = new int[length];
System.arraycopy(seq, i, result, 0, length);
return result;
}
@LuCio和@Aldert我找到了另一种解决问题的方法。下面是代码：
import java.util.Scanner;
class DivSeqUpdated {
private int n, input[], weight[];
void accept() {
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
input = new int[n];
weight = new int[n];
for(int i = 0; i<n; i++)
input[i] = sc.nextInt();
sc.close();
}
int max(int x, int y) {
return x<y?y:x;
}
int sequence(int src, int a[], int n) {
if(weight[src]==-1) {
int i, tmp = 0;
for(i = src+1; i<n; i++) {
if(a[i]%a[src]==0)
tmp = max(tmp, sequence(i,a,n));
}
weight[src] = tmp+1;
}
return weight[src];
}
public static void main(String [] args) {
DivSeqUpdated obj = new DivSeqUpdated();
obj.accept();
for(int i = 0; i<obj.n; i++)
obj.weight[i] = -1;
int tmp = 0;
for(int i = 0; i<obj.n; i++)
tmp = obj.max(tmp, obj.sequence(i,obj.input,obj.n));
System.out.println(tmp);
}
}
import java.util.Scanner；
类divseq已更新{
私有整数n，输入[]，权重[]；
无效接受（）{
扫描仪sc=新的扫描仪（System.in）；
n=sc.nextInt（）；
输入=新整数[n]；
权重=新整数[n]；
对于（int i=0；如果您编辑问题以包含测试用例的预期输出和实际输出，这将非常有用。您好dave，我已编辑它以包含测试用例。@c2yCharlie您的代码在以下情况下给出了错误的o/p。*************************************1 46***************6 2 4 232 8 464感谢您的帮助。但是，它给出了一个答案3/11测试的结果通过了。所以有一些不足之处。我希望你能调查一下。@c2yCharlie 3/11是一个糟糕的结果：）你能给我看看这些测试序列吗？没有mate:（那些案例被平台隐藏了。即使我也看不到这些案例是什么。只有两个可见的测试案例（上面提到的案例1和案例2）并且您的代码通过了它们。我的代码似乎通过了4/11：（@c2charlie我添加了一个条件：number>0&¤t>0&&……
我已经将您的代码的结果与上次更新后的代码进行了比较。对于我定义的11个测试，这两种解决方案都给出了相同的结果。这是一个不错的答案，但我不相信它在大型阵列上会表现得那么好，因为它是O（n！）我相信我甚至可以进一步优化我的答案，我喜欢谜题。@Aldert我希望看到上面更优化的代码。@Aldert当然可以，伙计……等待你的答案！