Review of your code

The code is written clearly, I have only a few remarks.

The LeetCode problem description states that both str1 and str2 are non-empty strings, so that this

if (string.IsNullOrEmpty(str1) || string.IsNullOrEmpty(str2))
{
    return string.Empty;
}

is not necessary. On the other hand, if you want to handle empty strings then the above is not correct: The shortest common supersequence of the empty string and "abc" is "abc", not the empty string. So that should be

if (string.IsNullOrEmpty(str1))
{
    return str2;
}
if (string.IsNullOrEmpty(str2))
{
    return str1;
}

Here

int i = 0;
int j = 0;
string lcs = FindLCS(str1, str2);
StringBuilder res = new StringBuilder();
foreach (var letter in lcs) 
{ // ...

I would move the declarations of i and j down to where the variables are needed, i.e. directly before the foreach loop.

The attentive reader of your code will of course quickly figure out that

private static string FindLCS(string str1, string str2)

determines the “longest common subsequence” but I would use a more verbose function name (or add an explaining comment).

Explaining the used algorithm shortly would also be helpful to understand the code, something like

/*
 The longest common subsequence (LCS) of str1 and str2 is computed with 
 dynamic programming. 

 dp[i, j] is determined as the LCS of the initial i characters of str1
 and the initial j characters of str2.

 dp[str1.Length, str2.Length] is then the final result.
 */

On the other hand, this comment is mysterious to me:

//remember 0 is 0 always
if (str1[i] == str2[j])

Performance improvements

str1.Length * str2.Length strings are computed in FindLCS(), and that can be avoided. As explained in Wikipedia: Longest common subsequence problem, is is sufficient to store in dp[i, j] the length of the corresponding longest common subsequence, and not the subsequence itself. When the dp array is filled then the longest common subsequence can be determined by deducing the characters in a “traceback” procedure, starting at dp[str1.Length, str2.Length].

This saves both memory and the time for the string operations.

And this approach can easily be modified to collect the shortest common supersequence instead of the longest common subsequence. That makes your “post processing” in your ShortestCommonSupersequence() function obsolete.

The maximum possible length of the shortest common supersequence is known. Therefore the characters can be collected in an array first, so that string operations and a final string reversing is avoided.

Putting it all together, an implementation could look like this:

public static string ShortestCommonSupersequence(string str1, string str2)
{
    // Handle empty strings:
    if (string.IsNullOrEmpty(str1))
    {
        return str2;
    }
    if (string.IsNullOrEmpty(str2))
    {
        return str1;
    }

    // Dynamic programming: dp[i, j] is computed as the length of the
    // longest common subsequence of str1.Substring(0, i) and
    // str2.SubString(0, j).

    int[,] dp = new int[str1.Length + 1, str2.Length + 1];
    for (int i = 0; i < str1.Length; i++)
    {
        for (int j = 0; j < str2.Length; j++)
        {
            if (str1[i] == str2[j])
            {
                dp[i+1, j+1] = dp[i, j] + 1;
            }
            else
            {
                dp[i + 1, j + 1] = Math.Max(dp[i + 1, j], dp[i, j + 1]);
            }
        }
    }

    // Traceback: Collect shortest common supersequence. Since the
    // characters are found in reverse order we put them into an array
    // first.

    char [] resultBuffer = new char[str1.Length + str2.Length];
    int resultIndex = resultBuffer.Length;
    {
        int i = str1.Length;
        int j = str2.Length;
        while (i > 0 && j > 0)
        {
            if (str1[i - 1] == str2[j - 1])
            {
                // Common character:
                resultBuffer[--resultIndex] = str1[i - 1];
                i--;
                j--;
            }
            else if (dp[i - 1, j] > dp[i, j - 1])
            {
                // Character from str1:
                resultBuffer[--resultIndex] = str1[i - 1];
                i--;
            }
            else
            {
                // Character from str2:
                resultBuffer[--resultIndex] = str2[j - 1];
                j--;
            }
        }
        // Prepend remaining characters from str1:
        while (i > 0)
        {
            resultBuffer[--resultIndex] = str1[i - 1];
            i--;
        }
        // Prepend remaining characters from str2:
        while (j > 0)
        {
            resultBuffer[--resultIndex] = str2[j - 1];
            j--;
        }
    }

    // Create and return result string from buffer.
    return new string(resultBuffer, resultIndex, resultBuffer.Length - resultIndex);
}

Comparison: I ran both implementations on LeetCode

• Original code: Runtime 372 ms, Memory 48.9 MB.
• Improved code: Runtime 92 ms, Memory 26.1 MB.