Question

我试图找到一个有效算法（一个函数），它取一个整数数组A [1..2N]，如果A中表示的序列可以分成两个相同的长度为N的子序列，则返回true。 - 否则就是假。

我真的不知道从哪里开始。我在考虑递归 - 这样的序列必须从A [1]开始，以A [2N]结束，但下一步并非如此明显。

我很感激一些帮助

Answer 1

如果你真的期待这个，CHECK（）函数会尽职尽责。

希望它会有所帮助

int A[]={1,2,1,3,4,2,3,4};
int vis[10];

bool CHECK()
{
    vis[10]={0};
    int j=1;

    for(int i=0; i<10; i++)
    {
        if(vis[i]==1) continue;
        bool find = false;

        for(; j<10; j++)
        {
            if(A[i]==A[j])
            {
                find=true;
                vis[i]=1;
                vis[j]=1;
                j++;
                break;
            }
        }
       if(!find)
       {
           return false;
       }
   }
   return true;
}

Answer 2

可能它不是完美的代码，但想法是这个伪代码

function sameSubsequences(A:array[1..2n] of integer):boolean;

begin
memory:array[1..2n] of boolean; 
for i:=1 to 2n do memory[i]:=false;
i:=1; j:=2;
while i<=2n AND j<=2n do
    begin
    memory[i]:=true;
    while j<=2n and A[j]!=A[i] and (not memory[j]) do j:=j+1;
    if j<=2n then memory[j]:=true;
    while i<=2n or memory[i] do i:=i+1;
    end;

sameSubsequences:=(i>2n);
end;

两个相同的子序列

2 个答案: