Question

上周我给了我的大学一个hackathon事件，如果给出一个字符串，我们需要删除第一次出现或最后一次出现的子串，

示例s =“acaaac”和t =“a” s是主字符串t是子字符串

s可以是“caaac”或“acaac”，我们需要找到给定s和t的最大移动次数

输入仅包含小写字母[a-z]

测试案例1： s =“aabb”和t =“ab”，删除“aabb”中t的出现变为“ab”接下来删除唯一出现的字符串得到s =“” 由于在t中没有更多的出现，我们返回2

测试案例2： s =“aabcd”t =“abc”---＆gt;只有一次发生，因此计数为1，

测试案例3： s =“aa”t =“b”count = 0

我尝试在java中使用伪代码

 count = 0   
 while(s.contains(t))
 {
 s=s.replacefirst(t,"")
 count++;
 }
 return count;

但是我没有得到我错过的测试用例，我在事件中传递了14个中的9个

我可以知道哪些测试用例丢失了吗？

Answer 1

以下是您的代码将给出错误答案的示例：

s = ababaa，t = aba

您将删除第一次出现的内容，结果将是：

（aba）baa - ＆gt; baa - ＆gt; 1

但是，如果先删除第二个匹配项，则可以删除另一个子字符串：

ab（aba）a - ＆gt; aba - ＆gt; '' - ＆gt; 2

您似乎必须遍历第一个/最后一个删除的所有可能组合并选择最佳结果。

更有趣的问题是，如果有更好的算法而不是蛮力？

Answer 2

使用 BFS 可以轻松解决此问题，我认为我们不能做得比蛮力好，也许我们可以添加一些优化措施来忽略移动少于maxMove的字符串同时将其添加到队列中。

以下代码为上述所有输入提供正确的输出。我用过JUnit.Assert.assertEquals()。

import java.util.Deque;
import java.util.LinkedList;
import static org.junit.Assert.assertEquals;

public class RemoveString {
    static class Moves {
        String str ;
        int moves ;
        public Moves(String str, int moves) {
            this.str = str ;
            this.moves = moves ;
        }
    }

    static
    public int maxMoves(String s, String t) {
        int max = 0 ;
        if (s == null || t == null || t.length() > s.length())
            return max ;
        Deque<Moves> q = new LinkedList<>() ;
        q.offer(new Moves(s, 0)) ;
        while (!q.isEmpty()) {
            for (int sz = q.size() ;  sz > 0 ; -- sz) {
                Moves curMove = q.poll() ;
                max = Math.max(max, curMove.moves) ;
                if (curMove.str.contains(t)) {
                    int nextStart = curMove.str.indexOf(t, 0) ;
                    if (nextStart != -1) {
                        q.offer(new Moves(curMove.str.substring(0, nextStart) + curMove.str.substring(nextStart+t.length()), curMove.moves+1)) ;
                    }
                    int lastStart = curMove.str.lastIndexOf(t, curMove.str.length()) ;
                    if (lastStart != -1) {
                        q.offer(new Moves(curMove.str.substring(0, lastStart) + curMove.str.substring(lastStart+t.length()), curMove.moves+1)) ;
                    }
                }
            }
        }
        return max ;
    }

    public static void main(String[] args) {
        assertEquals(3, maxMoves("babba", "b"));
        assertEquals(2, maxMoves("aabb", "ab"));
        assertEquals(2, maxMoves("ababaa", "aba"));
        assertEquals(1, maxMoves("abaer", "er")); // Should be 1
        assertEquals(1, maxMoves("erababa", "er")); // Should be 1
        assertEquals(1, maxMoves("zzzeraba", "er")); // Should be 1
        assertEquals(2, maxMoves("aerbabaer", "er")); // Should be 2
        assertEquals(2, maxMoves("aeerra", "er")); // Should be 2
        assertEquals(2, maxMoves("aerera", "er")); // Should be 2
        assertEquals(2, maxMoves("aerbera", "er")); //Should be 2
        assertEquals(1, maxMoves("aberebraba", "er")); // Should be 1
    }
}

用于删除子字符串

2 个答案: