Java 寻找DNA的超序列

我正在努力寻找“寻找超序列”算法

输入用于一组字符串

String A = "caagccacctacatca";
String B = "cgagccatccgtaaagttg";
String C = "agaacctgctaaatgctaga";

结果将是一组正确对齐的字符串（下一步应该是合并）

谢谢你的建议（我在这项任务上坐了一天多）

合并后的超弦将

cagagaccatgccgtaaatgcattacga

在“这种情况”中，超层序的定义类似于

当且仅当字符串R中的所有字符都按其在输入序列R中出现的顺序出现在超序列S中时，字符串R才包含在超序列S中

---

我尝试的“解决方案”（也是错误的做法）是：

公共类解决方案4
{
静态布尔[][]映射=null；
静态int size=0；
公共静态void main（字符串[]args）
{
字符串A=“caagccatca”；
字符串B=“cgaccatccgtaaagttg”；
字符串C=“agaacctgctaatgctaga”；
堆栈数据=新堆栈（）；
数据推送（A）；
数据推送（B）；
数据推送（C）；
Stack clone1=data.clone（）；
Stack clone2=data.clone（）；
整数长度=26；
尺寸=最大尺寸（数据）；
系统输出打印项次（大小+“”+长度）；
map=新布尔值[26][size]；
字符[]结果=新字符[大小]；
HashSet chunks=新HashSet（）；
而（！clone1.isEmpty（））
{
字符串a=clone1.pop（）；
char[]残留物=生成残留物（a）；
System.out.println（“--”）；
System.out.println（“旧：+a”）；
System.out.println（“剩余：+String.valueOf（剩余））；
String[]r=String.valueOf（residence）.split（“”）；
对于（int i=0；i，您可以尝试找到这样的最短组合

static final char[] CHARS = "acgt".toCharArray();

public static void main(String[] ignored) {
    String A = "caagccacctacatca";
    String B = "cgagccatccgtaaagttg";
    String C = "agaacctgctaaatgctaga";
    String expected = "cagagaccatgccgtaaatgcattacga";

    List<String> ABC = new Combination(A, B, C).findShortest();
    System.out.println("expected: " + expected.length());
    System.out.println("Merged: " + ABC.get(0).length() + " " + ABC);
}

static class Combination {
    int shortest = Integer.MAX_VALUE;
    List<String> shortestStr = new ArrayList<>();
    char[][] chars;
    int[] pos;
    int count = 0;

    Combination(String... strs) {
        chars = new char[strs.length][];
        pos = new int[strs.length];
        for (int i = 0; i < strs.length; i++) {
            chars[i] = strs[i].toCharArray();
        }
    }

    public List<String> findShortest() {
        findShortest0(new StringBuilder(), pos);
        return shortestStr;
    }

    private void findShortest0(StringBuilder sb, int[] pos) {
        if (allDone(pos)) {
            if (sb.length() < shortest) {
                shortestStr.clear();
                shortest = sb.length();
            }
            if (sb.length() <= shortest)
                shortestStr.add(sb.toString());
            count++;
            if (++count % 100 == 1)
            System.out.println("Searched " + count + " shortest " + shortest);
            return;
        }
        if (sb.length() + maxLeft(pos) > shortest)
            return;
        int[] pos2 = new int[pos.length];
        int i = sb.length();
        sb.append(' ');
        for (char c : CHARS) {
            if (!tryChar(pos, pos2, c)) continue;
            sb.setCharAt(i, c);
            findShortest0(sb, pos2);
        }
        sb.setLength(i);
    }

    private int maxLeft(int[] pos) {
        int maxLeft = 0;
        for (int i = 0; i < pos.length; i++) {
            int left = chars[i].length - pos[i];
            if (left > maxLeft)
                maxLeft = left;
        }
        return maxLeft;
    }

    private boolean allDone(int[] pos) {
        for (int i = 0; i < chars.length; i++)
            if (pos[i] < chars[i].length)
                return false;
        return true;
    }

    private boolean tryChar(int[] pos, int[] pos2, char c) {
        boolean matched = false;
        for (int i = 0; i < chars.length; i++) {
            pos2[i] = pos[i];
            if (pos[i] >= chars[i].length) continue;
            if (chars[i][pos[i]] == c) {
                pos2[i]++;
                matched = true;
            }

        }
        return matched;
    }
}

static final char[]CHARS=“acgt”.tocharray（）；
公共静态void main（忽略字符串[]）{
字符串A=“caagccatca”；
字符串B=“cgaccatccgtaaagttg”；
字符串C=“agaacctgctaatgctaga”；
字符串应为=“cagagaccatgcccgtaaatgcattacga”；
列表ABC=新的组合（A、B、C）；
System.out.println（“预期：+预期.length（））；
System.out.println（“合并：”+ABC.get（0.length（）+”+ABC）；
}
静态类组合{
int shortest=Integer.MAX_值；
List shortestStr=new ArrayList（）；
字符[][]字符；
int[]pos；
整数计数=0；
组合（字符串…字符串）{
chars=新字符[strs.length][]；
pos=新整数[标准长度]；
对于（int i=0；i最大左）
maxLeft=左；
}
返回maxLeft；
}
私有布尔allDone（int[]pos）{
for（int i=0；i=chars[i].length）继续；
如果（字符[i][pos[i]]==c）{
pos2[i]++；
匹配=真；
}
}
返回匹配；
}
}

打印许多比建议的解决方案短的解决方案

预期：28

合并：27[ACGAGCCATCCGCTAAATGCTAGA、ACGAGCCATCCGCTAAATGCTAGCA、ACGAGCCATCCGCTAACAGTGTAGA、ACGAGCCATCCGCTAACAGCTAGA、ACGAGCCATCCGCTAACAGCTAGA、ACGAGCCATCCGCTAACAGTCAGA、ACGAGCCATCCGCTACAAGTCAGTAGA、ACGAGCCATCCGCTACAAGTCATAGA、ACGAGCCATCCGCTACAATGCTACAATAGA、ACGAGCCATCCGCTAGCTACAATAGA、ACGAGCGAGCCAGCGCTAGCTAGCTACGA、ACGAGCCAGCTAGCTAGCTAGCTAGCA、，ACGAAGCCATCGTAACAGTGTAGA、ACGAAGCCATCGTAACATGCTA、ACGAAGCCATCGTAACATGCTAGA、ACGAAGCCATCGTAACATGCTAGA、ACGAAGCCATCGTACAAGTGTAGA、ACGAAGCCATCGTACAATGCTA、ACGAAGCCATCGTACAATGCTA、ACGAAGCAGCCATCGTACAATGCTATCTAGA、ACGAAGCCATCGTACAATGCTAACATGCTA、ACGAAGAGACGAGCCATCGTACGTACAATGCTAGCTA、ACGAAGAGATGCTACGTAGCA、ACGAAGAGATGCTAGCA、ACGAAGAGAGATGCTACGTACGTAGCA、ACGAAGATGCTAGCACGAAGCCATGCCGTAACATGCTAGA、ACGAGCCATGCCGTAACATGCTAGA、ACGAGCCATGCCGTACAAGGTGCTAGA、ACGAGCCATGCCGTACAATGCA、ACGAGCCATGCCGTACAATGCA、ACGAGCCATGCCGTACAATGCTATCTAGA、CAGAGCCATCCGCTAGCTATCATGCA、CAGAGCCATGCCAGCTAGCTATCATGCA、CAGAGCCAGAGCCATGCCAGCTAGCTATCATGCA、CAGAGCCAGCCAGCCAGCTAGCTATCTAGCA、CAGAGCCAGCCAGCATGCTAGCTAGCA、CAGAGCCAGCTATCTAGCTAGCACAGAGCCATCCGCTACAAGGTGCTAGA，CAGAGCCATCCGCTACAAGTCTAGA，CAGAGCCATCCGCTACAAGTCTAGA，CAGAGCCATCGTATGCTAGA，CAGAGCCATCGCGTATGCTAGA，CAGAGCCATCGTATGCTAGCA，CAGAGCCATCGTACGTAACAGTCTAGA，CAGAGCCATCGTACGTAACATGCTAGA，CAGAGCCATCGTACGTACGTAACATGCTAGA，CAGAGCCATCGTACGTACGTAGCTAGCTAGCTAGCTAGA，CAGAGCCAGAGCCATCGTACGTACGTAGCTAGCTAGCTAGA，CAGAGCCAGAGCTAGCTAGCTAGCTAGCAGAGCCATCGTACAATGCTACAATGCCTAGA，CAGAGCCATGCCGTAAATGCTAGA，CAGAGCCATGCCGTATGCTAGA，CAGAGCCATGCCGTAACAGTGTAGA，CAGAGCCATGCCGTAACAGTGTAGA，CAGAGCCATCGTAACATGCA，CAGAGCCATGCCGTAACATGCTA，CAGAGCCATGCCAGCTACGTATGTCAGA，CAGAGCCATGCCAGCTACGTACGTAGCTAGTAGA，CAGAGCATGCCAGCTACGTAGCTAGCA，CAGAGCTAGCTAGCTAGCA，CAGAGCTAGCTAGCTAGCA，CAGAGCTAGCTAGCTAGCA，CAGAGAGCTAGCTAGCTAGCA，CAGAGCA，CAGAGCTAGCTAGCTAGCTAGCA，CAGCTAGCTAGCTAG
public class Solution4
{
    static  boolean[][] map = null;
    static int size = 0;

    public static void main(String[] args)
    {
        String A = "caagccacctacatca";
        String B = "cgagccatccgtaaagttg";
        String C = "agaacctgctaaatgctaga";

        Stack data = new Stack();
        data.push(A);
        data.push(B);
        data.push(C);


        Stack clone1 = data.clone();
        Stack clone2 = data.clone();

        int length  =  26;
        size        =  max_size(data);

        System.out.println(size+" "+length);
        map = new boolean[26][size];

        char[] result = new char[size];

        HashSet<String> chunks = new HashSet<String>();
        while(!clone1.isEmpty())
        {
            String a = clone1.pop();

            char[] residue = make_residue(a);

            System.out.println("---");
            System.out.println("OLD     : "+a);
            System.out.println("RESIDUE : "+String.valueOf(residue));


            String[] r = String.valueOf(residue).split(" ");

            for(int i=0; i<r.length; i++)
            {
                if(r[i].equals(" ")) continue;
                //chunks.add(spaces.substring(0,i)+r[i]);
                chunks.add(r[i]);
            }
        }

        for(String chunk : chunks)
        {
            System.out.println("CHUNK   : "+chunk);
        }
    }

    static char[] make_residue(String candidate)
    {
        char[] result = new char[size];
        for(int i=0; i<candidate.length(); i++)
        {
            int pos = find_position_for(candidate.charAt(i),i);
            for(int j=i; j<pos; j++) result[j]=' ';
            if(pos==-1) result[candidate.length()-1] = candidate.charAt(i);
            else        result[pos] = candidate.charAt(i);
        }
        return result;
    }

    static int find_position_for(char character, int offset)
    {
        character-=((int)'a');

        for(int i=offset; i<size; i++)
        {
        //  System.out.println("checking "+String.valueOf((char)(character+((int)'a')))+" at "+i);
            if(!map[character][i])
            {
                map[character][i]=true;
                return i;
            }
        }
        return -1;
    }

    static String move_right(String a, int from)
    {
        return a.substring(0, from)+" "+a.substring(from);  
    }


    static boolean taken(int character, int position)
    { return map[character][position]; }

    static void take(char character, int position)
    {
        //System.out.println("taking "+String.valueOf(character)+" at "+position+" (char_index-"+(character-((int)'a'))+")");
        map[character-((int)'a')][position]=true;
    }

    static int max_size(Stack stack)
    {
        int max=0;
        while(!stack.isEmpty())
        {
            String s = stack.pop();
            if(s.length()>max) max=s.length();
        }

        return max;
    }

}

static final char[] CHARS = "acgt".toCharArray();

public static void main(String[] ignored) {
    String A = "caagccacctacatca";
    String B = "cgagccatccgtaaagttg";
    String C = "agaacctgctaaatgctaga";
    String expected = "cagagaccatgccgtaaatgcattacga";

    List<String> ABC = new Combination(A, B, C).findShortest();
    System.out.println("expected: " + expected.length());
    System.out.println("Merged: " + ABC.get(0).length() + " " + ABC);
}

static class Combination {
    int shortest = Integer.MAX_VALUE;
    List<String> shortestStr = new ArrayList<>();
    char[][] chars;
    int[] pos;
    int count = 0;

    Combination(String... strs) {
        chars = new char[strs.length][];
        pos = new int[strs.length];
        for (int i = 0; i < strs.length; i++) {
            chars[i] = strs[i].toCharArray();
        }
    }

    public List<String> findShortest() {
        findShortest0(new StringBuilder(), pos);
        return shortestStr;
    }

    private void findShortest0(StringBuilder sb, int[] pos) {
        if (allDone(pos)) {
            if (sb.length() < shortest) {
                shortestStr.clear();
                shortest = sb.length();
            }
            if (sb.length() <= shortest)
                shortestStr.add(sb.toString());
            count++;
            if (++count % 100 == 1)
            System.out.println("Searched " + count + " shortest " + shortest);
            return;
        }
        if (sb.length() + maxLeft(pos) > shortest)
            return;
        int[] pos2 = new int[pos.length];
        int i = sb.length();
        sb.append(' ');
        for (char c : CHARS) {
            if (!tryChar(pos, pos2, c)) continue;
            sb.setCharAt(i, c);
            findShortest0(sb, pos2);
        }
        sb.setLength(i);
    }

    private int maxLeft(int[] pos) {
        int maxLeft = 0;
        for (int i = 0; i < pos.length; i++) {
            int left = chars[i].length - pos[i];
            if (left > maxLeft)
                maxLeft = left;
        }
        return maxLeft;
    }

    private boolean allDone(int[] pos) {
        for (int i = 0; i < chars.length; i++)
            if (pos[i] < chars[i].length)
                return false;
        return true;
    }

    private boolean tryChar(int[] pos, int[] pos2, char c) {
        boolean matched = false;
        for (int i = 0; i < chars.length; i++) {
            pos2[i] = pos[i];
            if (pos[i] >= chars[i].length) continue;
            if (chars[i][pos[i]] == c) {
                pos2[i]++;
                matched = true;
            }

        }
        return matched;
    }
}

public static void main(String[] args) {
    String A = "caagccacctacatca";
    String B = "cgagccatccgtaaagttg";
    String C = "agaacctgctaaatgctaga";

    int iA = 0;
    int iB = 0;
    int iC = 0;

    char[] a = A.toCharArray();
    char[] b = B.toCharArray();
    char[] c = C.toCharArray();


    StringBuilder sb = new StringBuilder();

    while (iA < a.length || iB < b.length || iC < c.length) {
        if (iA < a.length && iB < b.length && iC < c.length && (a[iA] == b[iB]) && (a[iA] == c[iC])) {
            sb.append(a[iA]);
            iA++;
            iB++;
            iC++;
        }
        else if (iA < a.length && iB < b.length && a[iA] == b[iB]) {
            sb.append(a[iA]);
            iA++;
            iB++;
        }
        else if (iA < a.length && iC < c.length && a[iA] == c[iC]) {
            sb.append(a[iA]);
            iA++;
            iC++;
        }
        else if (iB < b.length && iC < c.length && b[iB] == c[iC]) {
            sb.append(b[iB]);
            iB++;
            iC++;
        } else {
            if (iC < c.length) {
                sb.append(c[iC]);
                iC++;
            }
            else if (iB < b.length) {
                sb.append(b[iB]);
                iB++;
            } else if (iA < a.length) {
                sb.append(a[iA]);
                iA++;
            }
        }
    }
    System.out.println("SUPERSEQUENCE " + sb.toString());
}