300. Longest Increasing subsequence Leetcode Solution

class Solution {
    public int lengthOfLIS(int[] nums) {
        //longest increasing subsequence = longest common subsequence (given array and sorted array-the sorted array will have all the duplicates written only once)
        
        int n = nums.length;
        int[]sort = new int[n];
        for (int i=0; i < n; i++)
        {
            sort[i] = nums[i];
        }
        

        
        Arrays.sort(sort);
        
        ArrayList< Integer > list = new ArrayList< Integer>();
        
        for (int i=0; i< n; i++)
        {
            if (!list.contains(sort[i]))
            {
                list.add(sort[i]);
            }
        }
        
        int size = list.size();
        
        int[]sorty = new int[size];
        for (int i=0; i< size; i++)
        {
            sorty[i] = list.get(i);
        }
        
        return lcs (nums, sorty, n, size);
    }
    
    public int lcs (int[] nums1, int[] nums2, int n, int m)
    {
        int[][]matrix = new int[n+1][m+1];
        
        for (int i=0; i< n+1; i++)
        {
            for (int j=0; j< m+1; j++)
            {
                if (i == 0 || j == 0)
                {
                    matrix[i][j] = 0;
                }
                
                else if (nums1[i-1] == nums2[j-1])
                {
                    matrix[i][j] = 1 + matrix[i-1][j-1];
                }
                
                else if (nums1[i-1] != nums2[j-1])
                {
                    matrix[i][j] = Math.max (matrix[i-1][j] , matrix[i][j-1]);
                }
            }
        }
        
        return matrix[n][m];
    }
}

public int lengthOfLIS(int[] nums) {
    int[] tails = new int[nums.length];
    int size = 0;
    for (int x : nums) {
        int i = 0, j = size;
        while (i != j) {
            int m = (i + j) / 2;
            if (tails[m] < x)
                i = m + 1;
            else
                j = m;
        }
        tails[i] = x;
        if (i == size) ++size;
    }
    return size;
}
// Runtime: 2 ms

def lengthOfLIS(self, nums):
    tails = [0] * len(nums)
    size = 0
    for x in nums:
        i, j = 0, size
        while i != j:
            m = (i + j) / 2
            if tails[m] < x:
                i = m + 1
            else:
                j = m
        tails[i] = x
        size = max(i + 1, size)
    return size