贪婪LCS Java代码实现

我试图从这本日记中编写java代码：

这段代码是关于afroza begum计算最长公共子序列的贪婪方法

这是我的[编辑]代码：

public class LCS_Greedy {

public static void main(String[] args) {
//        String X_awal = "ABCBDABE";
//        String Y = "BDCABA";

//        String X_awal = "XMJYAUZ";
//        String Y = "MZJAWXU";
    
//        String X_awal ="AGGTAB";
//        String Y="GXTXAYB";
    
//        String X_awal = "ABCDGH";
//        String Y = "AEDFHR";
    
//        String X_awal = "AHBCDG";
//        String Y = "AEDFHR";       
    
    //greedy not always optimum
    String X_awal = "bcaaaade";
    String Y = "deaaaabc";
    String X = match(X_awal, Y);
    int[] Penanda_Y = new int[Y.length()];
    int y_length = Y.length();
    for (int k = 0; k < y_length; k++) {
        Penanda_Y[k] = 0;
    }
    int m = X.length();
    int n = Y.length();
    String L = "";
    String LSym = "";
    int R = 0;
    int i = 1;
    int[] P = new int[100];
    P[i] = posisi(X, Y, i, Penanda_Y, R);
    i = 1;
    while (i <= m) {
        if (i != m) {
            P[i + 1] = posisi(X, Y, (i + 1), Penanda_Y, R);
        }
        if (P[i + 1] == 0) {
            if (P[i] > R) {
                L = L + " " + Integer.toString(P[i]);
                LSym = LSym + " " + X.charAt(i - 1);
            }
            break;
        }

        if (P[i + 1] < R || P[i] < R) {
            R = 0;
        }
        if (P[i] > P[i + 1]) {
            if (R == 0 && i > 1) {
                L = L + " " + Integer.toString(P[i]);
                LSym = LSym + " " + X.charAt(i - 1);
                Penanda_Y[P[i] - 1] = 1;
                R = P[i];
                i = i + 1;
                if (R == Y.length() || i > X.length()) {
                    break;
                }
                P[i] = posisi(X, Y, i, Penanda_Y, R);
            } else {
                L = L + " " + Integer.toString(P[i + 1]);
                LSym = LSym + " " + X.charAt(i + 1 - 1);
                Penanda_Y[P[i + 1] - 1] = 1;
                R = P[i + 1];
                i = (i + 1) + 1;
                if (R == Y.length() || i > X.length()) {
                    break;
                }
                P[i] = posisi(X, Y, i, Penanda_Y, R);
            }

        } else {

            if (R == 0 && i > 1) {
                L = L + " " + Integer.toString(P[i + 1]);
                LSym = LSym + " " + X.charAt(i + 1 - 1);
                Penanda_Y[P[i + 1] - 1] = 1;
                R = P[i + 1];
                i = (i + 1) + 1;
                if (R == Y.length() || i > X.length()) {
                    break;
                }
                P[i] = posisi(X, Y, i, Penanda_Y, R);
            } else {
                L = L + " " + Integer.toString(P[i]);
                LSym = LSym + " " + X.charAt(i - 1);
                Penanda_Y[P[i] - 1] = 1;
                R = P[i];
                i = i + 1;
                if (R == Y.length() || i > X.length()) {
                    break;
                }
                P[i] = posisi(X, Y, i, Penanda_Y, R);
            }
        }
    }
    System.out.println("X = " + X_awal);
    System.out.println("X = " + Y);
    System.out.println("L = " + L);
    System.out.println("LSym = " + LSym);
    System.out.println("Length = " + LSym.length() / 2);
}

public static String match(String X, String Y) {
    String hasil = "";
    for (int i = 0; i < X.length(); i++) {
        for (int j = 0; j < Y.length(); j++) {
            if (X.charAt(i) == Y.charAt(j)) {
                hasil = hasil + X.charAt(i);
                break;
            }
        }
    }
    return hasil;
}

public static int posisi(String X, String Y, int i, int[] Penanda_Y, int R) {
    int n = Y.length();
    int k;
    int kr = 0;
    i = i - 1;
    for (k = 0; k < n; k++) {
        if ((X.charAt(i) == Y.charAt(k)) && Penanda_Y[k] == 0) {
            kr = k + 1;
            break;
        }
    }
    for (k = R; k < n; k++) {
        if ((X.charAt(i) == Y.charAt(k)) && Penanda_Y[k] == 0) {
            kr = k + 1;
            break;
        }
    }
    return kr;
}
}

公共类LCS\u{
公共静态void main（字符串[]args）{
//字符串X_awal=“ABCBDABE”；
//字符串Y=“BDCABA”；
//字符串X_awal=“XMJYAUZ”；
//字符串Y=“MZJAWXU”；
//字符串X_awal=“AGGTAB”；
//字符串Y=“GXTXAYB”；
//字符串X_awal=“ABCDGH”；
//字符串Y=“AEDFHR”；
//字符串X_awal=“AHBCDG”；
//字符串Y=“AEDFHR”；
//贪婪并不总是最优的
字符串X_awal=“bcaaade”；
字符串Y=“deaaabc”；
字符串X=匹配（X_awal，Y）；
int[]Penanda_Y=新int[Y.length（）]；
int y_length=y.length（）；
对于（int k=0；kP[i+1]）{
如果（R==0&&i>1）{
L=L+“”+Integer.toString（P[i]）；
LSym=LSym+“”+X.charAt（i-1）；
Penanda_Y[P[i]-1]=1；
R=P[i]；
i=i+1；
如果（R==Y.length（）| i>X.length（））{
打破
}
P[i]=posisi（X，Y，i，Penanda_，Y，R）；
}否则{
L=L+“”+Integer.toString（P[i+1]）；
LSym=LSym+“”+X.charAt（i+1-1）；
Penanda_Y[P[i+1]-1]=1；
R=P[i+1]；
i=（i+1）+1；
如果（R==Y.length（）| i>X.length（））{
打破
}
P[i]=posisi（X，Y，i，Penanda_，Y，R）；
}
}否则{
如果（R==0&&i>1）{
L=L+“”+Integer.toString（P[i+1]）；
LSym=LSym+“”+X.charAt（i+1-1）；
Penanda_Y[P[i+1]-1]=1；
R=P[i+1]；
i=（i+1）+1；
如果（R==Y.length（）| i>X.length（））{
打破
}
P[i]=posisi（X，Y，i，Penanda_，Y，R）；
}否则{
L=L+“”+Integer.toString（P[i]）；
LSym=LSym+“”+X.charAt（i-1）；
Penanda_Y[P[i]-1]=1；
R=P[i]；
i=i+1；
如果（R==Y.length（）| i>X.length（））{
打破
}
P[i]=posisi（X，Y，i，Penanda_，Y，R）；
}
}
}
System.out.println（“X=“+X_awal”）；
System.out.println（“X=”+Y）；
System.out.println（“L=”+L）；
System.out.println（“LSym=“+LSym”）；
System.out.println（“Length=“+LSym.Length（）/2”）；
}
公共静态字符串匹配（字符串X、字符串Y）{
字符串hasil=“”；
对于（int i=0；i

但当我运行这个程序时，在某些情况下，它的输出为真，但在另一种情况下，它的输出为假。那个代码有什么问题？谁能给我解释一下吗？谢谢

编辑：

---

我的代码现在可以完美地运行，但它似乎离那个日志中的伪代码很远。有人能解释一下吗？为什么我不能准确地从日志中生成代码？当我根据那个日志中给出的伪代码进行修改时，总是会出错。谢谢。

该算法不会导致LCS。贪婪的猜测是错误的。它假设早期比赛将保证形成LCS。即使伪码采用X中前两个的早期匹配，这可能会跳过Y开头的许多公共子字符串。另一个简单的测试是将X中最后一个“E”更改为“a”，该算法肯定无法找到最后一个匹配的“a”。事实上，早期比赛可能会锁定位置，禁止更长时间的比赛。换句话说，我们可能需要跳过一些早期匹配，以便找到更长的匹配。动态规划方法在数学上被证明是正确的，但该算法没有

不要试图直接翻译附加的伪代码。缺少预处理阶段。@Banthar谢谢，我将尝试进行预处理阶段，并将很快编辑我的问题