【LeetCode每日一题:982. 按位与为零的三元组+从递归超时到记忆化搜索】

题目描述

给你一个整数数组 nums ，返回其中 按位与三元组 的数目。

按位与三元组 是由下标 (i, j, k) 组成的三元组，并满足下述全部条件：

0 <= i < nums.length
0 <= j < nums.length
0 <= k < nums.length
nums[i] & nums[j] & nums[k] == 0 ，其中 & 表示按位与运算符。

示例 1：

输入：nums = [2,1,3]
输出：12
解释：可以选出如下 i, j, k 三元组：
(i=0, j=0, k=1) : 2 & 2 & 1
(i=0, j=1, k=0) : 2 & 1 & 2
(i=0, j=1, k=1) : 2 & 1 & 1
(i=0, j=1, k=2) : 2 & 1 & 3
(i=0, j=2, k=1) : 2 & 3 & 1
(i=1, j=0, k=0) : 1 & 2 & 2
(i=1, j=0, k=1) : 1 & 2 & 1
(i=1, j=0, k=2) : 1 & 2 & 3
(i=1, j=1, k=0) : 1 & 1 & 2
(i=1, j=2, k=0) : 1 & 3 & 2
(i=2, j=0, k=1) : 3 & 2 & 1
(i=2, j=1, k=0) : 3 & 1 & 2
示例 2：

输入：nums = [0,0,0]
输出：27

提示：

1 <= nums.length <= 1000
0 <= nums[i] < 216

求解思路

1. 看到该题目，再看数据量，很容易确定题目的大致求解方法。
2. 通过分析，我们可以确定该题目可以通过递归求解，该题递归的过程就是求全排列的过程，只不过需要我们注意的是，题目中会有条件限制，比如说三元数组，要求我们只能求解三个数，判断&运算最后的结果是否为0。
3. 需要注意的一点是，我们在进行递归的时候，当还没有数的时候， 此时第一个数是必须进行选择的，
   这点需要注意一下。
4. 递归肯定是超时的，我们可以继续进行改进，改成记忆化搜索求解该题。

实现代码

递归版本1

class Solution {
    private int res=0;

    public int countTriplets(int[] nums) {
        int n=nums.length;
        if(n==0) return res;
        dfs(nums,0,0);
        return res;
    }

    public void dfs(int[] nums,int cnt,int sum){
        if(cnt>3) return;
        if(cnt==3&&sum==0){
            res++;
            return;
        }
        for(int i=0;i<nums.length;i++){
            if(cnt==0) dfs(nums,cnt+1,nums[i]);
            else dfs(nums,cnt+1,sum&nums[i]);
        }
    }
}

递归版本2

class Solution {
    

    public int countTriplets(int[] nums) {
        int n=nums.length;
        if(n==0) return 0;
        return dfs(nums,0,0);
    }

    public int dfs(int[] nums,int cnt,int sum){
        if(cnt>3) return 0;
        if(cnt==3&&sum==0){
            return 1;
        }
        int ans=0;
        for(int i=0;i<nums.length;i++){
            if(cnt==0) ans+=dfs(nums,cnt+1,nums[i]);
            else ans+=dfs(nums,cnt+1,sum&nums[i]);
        }
        return ans;
    }
}

记忆化搜索

class Solution {

    public int countTriplets(int[] nums) {
        int n=nums.length;
        if(n==0) return 0;
        int max=0;
        for(int i=0;i<n;i++) max=Math.max(max,nums[i]);
        int[][] dp=new int[4][max+1];
        for(int i=0;i<4;i++) Arrays.fill(dp[i],-1);
        return dfs(dp,nums,0,0);
    }

    public int dfs(int[][] dp,int[] nums,int cnt,int sum){
        if(cnt>=4) return 0;
        if(cnt==3&&sum==0){
            return dp[cnt][sum]=1;
        }
        if(dp[cnt][sum]!=-1) return dp[cnt][sum];
        int ans=0;
        for(int i=0;i<nums.length;i++){
            if(cnt==0) ans+=dfs(dp,nums,cnt+1,nums[i]);
            else ans+=dfs(dp,nums,cnt+1,sum&nums[i]);
        }
        dp[cnt][sum]=ans;
        return ans;
    }
}

运行结果

想说的话

算法很难，我们可以不聪明，但是我们不能不努力，不能说放弃就放弃！