DP #416 Partition Equal Subset Sum

class Solution {
    public boolean canPartition(int[] nums) {
        int tg=0;
        for(int i:nums)tg+=i;
        if(tg%2!=0)return false;
        tg=tg/2;
        // int[][] dp=new int[nums.length][tg+1];
        // for(int[] i:dp)Arrays.fill(i,-1);
        // recur(nums.length-1,nums,tg,dp);   
        // return (dp[nums.length-1][tg]==1)?true:false;
        return tabOpt(nums,tg);
    }

    // Space optimised Tabulation solution
    boolean tabOpt(int[] nums,int tg){
        boolean[] dp=new boolean[tg+1];
        for(int i=0;i<nums.length;i++)dp[0]=true;
        if((tg==nums[0]))dp[tg]=true;

        for(int i=1;i<nums.length;i++){
            boolean[] cur=new boolean[tg+1];
            cur[0]=true;
            for(int j=1;j<=tg;j++){
                boolean tk= (j-nums[i]>=0) ? (dp[j-nums[i]]):false;
                boolean ntk= dp[j];
                cur[j] = tk||ntk;
            }
            dp=cur;
        }
        return dp[tg];
    }

    // Tabulation solution
    boolean tab(int[] nums,int tg){
        boolean[][] dp=new boolean[nums.length][tg+1];
        for(int i=0;i<nums.length;i++)dp[i][0]=true;
        if((tg==nums[0]))dp[0][tg]=true;

        for(int i=1;i<nums.length;i++){
            for(int j=1;j<=tg;j++){
                boolean tk= (j-nums[i]>=0) ? (dp[i-1][j-nums[i]]):false;
                boolean ntk= dp[i-1][j];
                dp[i][j] = tk||ntk;
            }
        }
        return dp[nums.length-1][tg];
    }

    // Recursive memoization solution
    boolean recur(int n,int[] nums,int tg,int[][] dp){
        if(tg<0)return false;
        if(tg==0)return true;
        if(n==0){
            boolean res = (tg==nums[0]);
            return res;
        }

        if(dp[n][tg] !=-1) return (dp[n][tg]==1)?true:false;
        boolean tk=recur(n-1,nums,tg-nums[n],dp);
        boolean ntk=recur(n-1,nums,tg,dp);
        boolean res = tk||ntk;
        dp[n][tg] = (res)?1:0;
        return res;
    }
}