Runtime9 msBeats96.66%
Memory117.2 MBBeats89.51%

class Solution {
    public boolean validPath(int n, int[][] edges, int source, int destination) {
        int[] parents=new int[n];
        for(int i=0; i<n; i++) parents[i]=i;

        for(int[] edge: edges){
            int p1=find(parents, edge[0]);
            int p2=find(parents, edge[1]);
            
            if(p1<p2) parents[p2]=p1;
            else parents[p1]=p2;
        }

        return find(parents, source) == find(parents, destination);
    }
    public int find(int[] parents, int x){
        while(x!=parents[x]){
            x=parents[x];
        }
        return x;
    }
}

Runtime9 msBeats90.97%
Memory42.1 MBBeats44.5%

class Solution {
    public int countQuadruplets(int[] nums) {
        int res=0, l=nums.length;
        Map<Integer, Integer> count = new HashMap<>();
        count.put(nums[l-1]-nums[l-2], 1);
        for(int b=l-3; b>=1; b--){
            for(int a=b-1; a>=0; a--){
                res+=count.getOrDefault(nums[b]+nums[a], 0);
            }
            for(int d=l-1; d>b; d--){
                count.put(nums[d]-nums[b], count.getOrDefault(nums[d]-nums[b], 0) +1);
            }
        }
        return res;
    }
}

class Solution {
    public boolean canPlaceFlowers(int[] f, int n) {
        int l = f.length;
        if(n==0) return true;
        if(l==1) return f[0]==0 && n == 1;

        for(int i=0; i<l; i++){
            if(i==0 && f[0] + f[1] == 0) {
                n--;
                i++;
            }
            else if(i==l-1 && f[l-1] + f[l-2]==0) {
                n--;
                i++;
            }
            else if(i>0 && i<l-1 && f[i]+f[i-1]+f[i+1]==0){
                n--;
                i++;
            }
        }
        return n<=0;
    }
}

class Solution {
    public String reverseVowels(String s) {
        String vowels = "aeiouAEIOU";
        char[] arr = s.toCharArray();
        for(int i=0, j=arr.length-1; i<j; ){
            if(vowels.contains(""+arr[i]) && vowels.contains(""+arr[j])){
                char temp=arr[i];
                arr[i]=arr[j];
                arr[j]=temp;
                i++;
                j--;
            }
            else if(vowels.contains(""+arr[i])) j--;
            else if(vowels.contains(""+arr[j])) i++;
            else{
                i++;
                j--;
            }
        }
        return new String(arr);
    }
}

class Solution {
    public String reverseWords(String s) {
        String[] arr = s.split("\\s+");
        for(int i = 0, j = arr.length-1; i<j; ){
            if(arr[i].equals("")){
                i++; continue;
            }
            if(arr[j].equals("")){
                j--; continue;
            }
            String temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
            i++; j--;
        }
        StringBuilder sb = new StringBuilder();
        for(String ss: arr) {
            if(!ss.equals("")) sb.append(ss).append(" ");
        }
        return sb.toString().trim();
    }
}

class Solution {
    public int[] productExceptSelf(int[] nums) {
        int n = nums.length;
        int arr[] = new int[n];
        int left[] = new int[n];
        arr[0] = left[n-1] = 1;
        for(int i=1; i<n; i++){
            arr[i] = arr[i-1]*nums[i-1];
        }
        for(int i=n-2; i>-1; i--){
            left[i] = left[i+1]*nums[i+1];
        }
        for(int i=0; i<n; i++){
            arr[i]*=left[i];
        }
        return arr;
    }
}

class Solution {
    public boolean increasingTriplet(int[] nums) {
        int small = Integer.MAX_VALUE, mid = Integer.MAX_VALUE;
        for(int n: nums){
            if(n<=small) small = n;
            else if(n<=mid) mid = n;
            else return true;
        }
        return false;
    }
}

class Solution {
    public int compress(char[] chars) {
        String s;
        StringBuilder sb = new StringBuilder();
        int count=1;
        for(int i=1; i<chars.length; i++){
            if(chars[i]==chars[i-1]){
                count++;
            }else{
                sb.append(chars[i-1]);
                if(count!=1) sb.append(count);
                count=1;
            }
        }
        
        sb.append(chars[chars.length-1]);
        if(count!=1) sb.append(count);
        s=sb.toString();
        for(int i=0; i<s.length(); i++){
            chars[i]=s.charAt(i);
        }
        return s.length();
    }
}

class Solution {
    public List<String> summaryRanges(int[] nums) {
        List<String> list = new ArrayList<>();
        if(nums.length==0) return list;
        int a=nums[0], b=nums[0];
        for(int i=1; i<nums.length; i++){
            if(nums[i]-nums[i-1]==1){
                b=nums[i];
            }else{
                if(a!=b) list.add(a+"->"+b);
                else list.add(""+a);
                a=nums[i];
                b=nums[i];
            }
        }
        if(a!=b) list.add(a+"->"+b);
        else list.add(""+a);
        return list;
    }
}

class Solution {
    public int maxOperations(int[] nums, int k) {
        int count = 0;
        Map<Integer, Integer> map = new HashMap<>();
        for(int n: nums){
            if(map.containsKey(n)){
                count++;
                map.put(n, map.get(n) -1);
                if(map.get(n)==0) map.remove(n);
            }else if(n<k){
                map.put(k-n, map.getOrDefault(k-n, 0) +1);
            }
        }
        return count;
    }
}