A

```
package com.thealgorithms.dynamicprogramming;
/**
* Class that provides methods to calculate the length of the shortest
* supersequence of two given strings. The shortest supersequence is the smallest string
* that contains both given strings as subsequences.
*/
final class ShortestCommonSupersequenceLength {
private ShortestCommonSupersequenceLength() {
}
/**
* Finds the length of the shortest supersequence of two given strings.
* The shortest supersequence is defined as the smallest string that contains both
* given strings as subsequences.
*
* @param x The first input string.
* @param y The second input string.
* @return The length of the shortest supersequence of the two strings.
*/
static int shortestSuperSequence(String x, String y) {
int m = x.length();
int n = y.length();
// find lcs
int l = lcs(x, y, m, n);
// Result is sum of input string
// lengths - length of lcs
return m + n - l;
}
/**
* Calculates the length of the longest common subsequence (LCS) between two strings.
* The LCS is the longest sequence that can be derived from both strings by deleting some
* (or none) of the characters without changing the order of the remaining characters.
*
* @param x The first input string.
* @param y The second input string.
* @param m The length of the first input string.
* @param n The length of the second input string.
* @return The length of the longest common subsequence of the two strings.
*/
static int lcs(String x, String y, int m, int n) {
int[][] lN = new int[m + 1][n + 1];
int i;
int j;
// Following steps build lN[m + 1][n + 1]
// in bottom up fashion. Note that
// lN[i][j] contains length of lNCS
// of x[0..i - 1]and y[0..j - 1]
for (i = 0; i <= m; i++) {
for (j = 0; j <= n; j++) {
if (i == 0 || j == 0) {
lN[i][j] = 0;
} else if (x.charAt(i - 1) == y.charAt(j - 1)) {
lN[i][j] = lN[i - 1][j - 1] + 1;
} else {
lN[i][j] = Math.max(lN[i - 1][j], lN[i][j - 1]);
}
}
}
// lN[m][n] contains length of LCS
// for x[0..n - 1] and y[0..m - 1]
return lN[m][n];
}
}
```