Longest common subarray in the given two arrays

Given two arrays A[] and B[] of N and M integers respectively, the task is to find the maximum length of equal subarray or the longest common subarray between the two given array.

Examples: 

Input: A[] = {1, 2, 8, 2, 1}, B[] = {8, 2, 1, 4, 7} 
Output: 3 
Explanation: 
The subarray that is common to both arrays are {8, 2, 1} and the length of the subarray is 3.
Input: A[] = {1, 2, 3, 2, 1}, B[] = {8, 7, 6, 4, 7} 
Output: 0 
Explanation: 
There is no such subarrays which are equal in the array A[] and B[]. 

public class LongestCommonSubArray {
    public static void main(String[] args) {
        System.out.println(lcs(new int[]{1,2,8,2,1,5},new int[]{4}));
    }
    private static int lcs(int[] num1,int[] num2){
        int[][] mem = new int[num1.length+1][num2.length+1];
        int max = 0;
        for(int i=1;i<=num1.length;i++){
            for(int j=1;j<=num2.length;j++){
                if(num1[i-1]==num2[j-1]){
                    mem[i][j]=mem[i-1][j-1]+1;
                    max = Math.max(max,mem[i][j]);
                }
            }
        }
        return max;
    }
}

Given two strings text1 and text2, return the length of their longest common subsequence. If there is no common subsequence, return 0.

A subsequence of a string is a new string generated from the original string with some characters (can be none) deleted without changing the relative order of the remaining characters.

• For example, "ace" is a subsequence of "abcde".

A common subsequence of two strings is a subsequence that is common to both strings.

Example 1:

Input: text1 = "abcde", text2 = "ace" 
Output: 3  
Explanation: The longest common subsequence is "ace" and its length is 3.

Example 2:

Input: text1 = "abc", text2 = "abc"
Output: 3
Explanation: The longest common subsequence is "abc" and its length is 3.

Example 3:

Input: text1 = "abc", text2 = "def"
Output: 0
Explanation: There is no such common subsequence, so the result is 0.

Constraints:

• 1 <= text1.length, text2.length <= 1000
• text1 and text2 consist of only lowercase English characters.

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        int[][] mem = new int[text1.length()+1][text2.length()+1];
        for(int i=1;i<=text1.length();i++){
            for(int j=1;j<=text2.length();j++){
                if(text1.charAt(i-1)==text2.charAt(j-1)){
                    mem[i][j]=mem[i-1][j-1]+1;
                }
                else{
                    mem[i][j] = Math.max(mem[i][j-1],mem[i-1][j]);
                }
            }
        }
        return mem[text1.length()][text2.length()];
    }
}