Question

Let me first apologise for the crude manner in which I am about to phrase my question. I have been refered here by a member on another site who tells me that i am looking for a dynamic programming algorithm....my question is as follows.

I am trying to sort through some data and need to find a possible sequence in the numbers Both sets of data include the same numbers listed in different orders as in the example below.

54 47 33 58 46 38 48 37 56 52 61 25 ………………first set
54 52 33 61 38 58 37 25 48 56 47 46 ………………second set

In this example Reading from left to right the numbers 54 52 61 and 25 occur in both sets in the same order.
So other possible solutions would be…

54 52 61 25
54 33 58 46
54 33 46
54 33 38 48 56
54 48 56…. Etc.

Although this can be done by hand, I have tons of this to get through and I keep making mistakes. Does anyone know of an existing program or script that would output all of the possible solutions?

我理解了C++和虚拟基本方案的基本结构,并且应当能够把一些东西合在一起,但坦率地说,自Cx谱日以来,我没有做过任何严肃的方案,因此,我很容易听。然而,我的主要问题不是方案语言本身,而是由于某种原因,我发现不可能按英文,更不用说其他语言,列出完成这项任务所需的步骤。

达累斯萨拉姆

Answer 1

你们这样的声音正在寻找所有共同的代谢物,这是(更为常见的)。

http://www.aaai.org/Papers/IJCAI/2007/IJCAI07-101.pdf (尽管它们侧重于仅仅计数后数,而不是列举)。

To come up with an algorithm you should define the desired output more precisely. For the sake of argument, say you want the set of subsequences not contained in any longer subsequence. Then one algorithm would be:

(1) 采用DP算法(LCS),编制配对/回轨矩阵

2) 绕过所有可能的地雷控制系统,标明所访问的对等位置。

3) 选择尚未标明的矩阵中最大部分(长期剩余部分)

4) Backtrack, recording the sequence and marking visited alignment positions.

5) While there exists an unmarked alignment positions, goto (3)

Backtracking in your case is complicated because you will have to visit all possible paths (called "all longest common subsequences"). You can find example implementations of LCS here, which may help to get you started.

Answer 2

我撰写了该守则,它产生了最长的共同顺序。该法令并不优化,但命令是O(n*m)n->阵列1大小、m->阵列2尺寸:

private void start() {
    int []a = {54, 47, 33, 58, 46, 38, 48, 37, 56, 52, 61, 25};
    int []b = {54, 52, 33, 61, 38, 58, 37, 25, 48, 56, 47, 46};

    System.out.println(search(a,b));
}

private String search(int[] a, int[] b)
{
    return search(a, b, 0, 0).toString();       
}

private Vector<Integer> search(int[] a, int[] b, int s1, int s2) {

    Vector<Vector<Integer>> v = new Vector<Vector<Integer>>(); 

    for ( int i = s1; i < a.length; i++ )
    {
        int newS2 = find(b, a[i], s2);
        if ( newS2 != -1 )
        {
            Vector<Integer> temp = new Vector<Integer>();
            temp.add(a[i]);
            Vector<Integer> others = search(a, b, i+1, newS2 + 1); 
            for ( int k = 0; k < others.size(); k++)
                temp.add( others.get(k));
            v.add(temp);
        }
    }

    int maxSize = 0;
    Vector<Integer> ret = new Vector<Integer>();
    for ( int i = 0; i < v.size(); i++)
        if ( v.get(i).size() > maxSize )
        {
            maxSize = v.get(i).size(); 
            ret = v.get(i);
        }

    return ret;
}

private int find(int[] b, int elemToFind, int s2) {
    for ( int j = s2; j < b.length; j++)
        if ( b[j] == elemToFind)
            return j;
    return -1;
}

友情链接