You win div2 and prepare for srm888

Arena has light mode?!

Does it even fit in memory?

$$$O(N^3)$$$ without using bitsets? It's better in a way. (The number of state transitions has a good constant since we delete pairs of characters, and cache friendliness is decent.)

Sure, I have quadratic solution. We can remove a segment of $$$A_0A_0A_1A_1 ... A_kA_k$$$ between B and C if either As, B and C include all colors or $$$B = A_0 = A_1 = ... = A_i$$$ and $$$C = A_k = ... = A_{i + 1}$$$. Now for each position in t we will go from left to right and store potentially suitable positions (s_j = t_i) in deque. If we then find some position for which we find it possible to match previous prefix of t, we check if we can delete everything between either end of deque and that position (if we can, remove corresponding end, set corresponding position as good and repeat). Of course we will empty our deque if we have to non-equal chars.

Brute-force every possible input

Divide the string into blocks of equal letters. You can never erase a block completely, but you can always erase it down to the last one or two characters (based on parity) by using one character from an adjacent block and three from your block.

Special case: if all letters are the same, you cannot erase anything.

No, determining whether all integers eventually appear in the sequence is an open problem, even for the case defaultValue = 0. See https://en.wikipedia.org/wiki/Van_Eck%27s_sequence

This is my solution during testing:

Let's get the run length encoding of both sequences, and call each of these parts a block. A block has a color and number. If there is only one block in T, then T and S must be the same.

It helps to look at things backwards as adding characters from T to S. Each block in T must correspond to a compatible block in S, where a block in T is "compatible" with a block in S if it has the same color, it has the same parity, and the number is equal or less.

If we look at the matched blocks of S, we must somehow generate everything else, and this is several independent problems between matched blocks. We can figure out when we can generate everything in between two already matched blocks in S. We can solve this with a little case work, and find out this is possible if the two blocks are already adjacent (nothing to generate), or all blocks in between have even size and the colors, including endpoints, don't alternate between only two colors (this can be proven with induction).

This leads to a dp solution, dp[i][j] -> true iff we can match first i blocks in T with first j blocks in S. For a fixed i, we sweep from lower j to higher j and keep track of some information to figure out if all previous blocks between the last possible matched position are even size and don't alternate. You can see the code for more details.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class StringTransformation {
    String x = "RGB";
    static class Block {
        int c;
        int n;

        public Block(int c, int n) {
            this.c = c;
            this.n = n;
        }
        public boolean inside(Block other) {
            return other.c == this.c && other.n >= this.n && (other.n % 2) == (this.n % 2);
        }
    }
    public List<Block> chunk(String s) {
        List<Block> ret = new ArrayList<>();
        char last = s.charAt(0);
        int count = 0;
        for (char c : s.toCharArray()) {
            if (c == last) count++;
            else {
                ret.add(new Block(x.indexOf(last), count));
                last = c;
                count = 1;
            }
        }
        ret.add(new Block(x.indexOf(last), count));
        return ret;
    }

    public String getResult(String s, String t) {
        return _getResult(s, t) ? "YES" : "NO";
    }
    public boolean _getResult(String s, String t) {
        List<Block> a1 = chunk(s), a2 = chunk(t);
        if (a2.size() == 1) {
            return a1.size() == 1 && a1.get(0).c == a2.get(0).c && a1.get(0).n == a2.get(0).n;
        }
        boolean[] dp = new boolean[a1.size()];
        dp[0] = a2.get(0).inside(a1.get(0));
        for (int i = 1; i < a2.size(); i++) {
            Block b2 = a2.get(i);
            boolean[] ndp = new boolean[a1.size()];
            int msk = 0;
            boolean first = false;
            for (int j = 0; j < a1.size(); j++) {
                Block b1 = a1.get(j);
                int c = b1.c;

                if (b2.inside(b1)) {
                    if (j > 0 && dp[j-1]) ndp[j] = true;
                    if (first) msk |= 1 << c;
                    ndp[j] |= msk == 7;
                }

                if (b1.n % 2 == 1) {
                    first = false;
                    msk = 0;
                }

                first |= dp[j];
		if (first) msk |= 1 << c;
            }
            dp = ndp;
        }
        return dp[a1.size()-1];
    }
}

You seem to return NO for "GRRBBR", "GR"

Problem is you make your removals always right to left

When you are a target and finish second in the world, but your big brother still beats you :(

Option 1 by aropan

Option 2 by me

The leaderboards are now working! Sorry for the glitch! https://tco20.topcoder.com/competition-overview/algorithm/leaderboard