力扣 227 场周赛第四题 双向 dfs 解决问题

题目描述：

题目分析与解答：

方法一 ： 双向 dfs 

    因为直接进行 dfs 时间复杂度为 : 2^40 -> 10^9 会STL

 

    所以采用 双向 dfs （把数组分成两段来进行考虑）:

    对最大的情况进行考虑分析(即 length = 40 时)

    

    (1) 对前一半的元素(20个)进行 dfs1 来得到每一种可能的组合答案(最多2^20 = 10^6 个)，并进行排序

 

    (2) 然后对于剩下的20个进行 dfs2 来得到每一种可能的组合答案 n ，然后在原数组中二分找到小于等于 goal - n 的最后一个数的位置 p

        则 :

        res = min(abs(goal - n - A[p]),abs(goal - n - A[p+1]));（考虑边界条件，具体看代码实现即可）

 

    时间复杂度分析:

        二分:log N = 20

        可能总数 : 2^20 = 10^6

        则 : O(10^7)

===> 对于时间复杂度的优化：可以采用 2^22 和 2^18 或者其他方法来 ： 22 * 2^18 < 20 * 2^20

代码如下：

class Solution {
public:
    vector<int> st;
    int res;
    int goal;
    void dfs1(vector<int>& nums,int n) {
        int S = 0;
        for(int i = 0;i < n;i++) S |= (1<<i);
        int l = 1;
        for(int sub = S;sub;sub = (sub-1)&S) {
            int x = 0;
            for(int j = 0;j < n;j++) {
                if(sub&(1 << j)) x += nums[j];
            }
            st[l++] = x;
        }
        return ;
    }
    int get_lower(int x) {
        // 找到小于等于 x 的最后一个数的坐标
        int l = 0;
        int r = st.size()-1;
        while(l <= r) {
            int mid = (l+r) / 2;
            if(st[mid] > x) r = mid -1;
            else l = mid + 1;
        }
        return l -1;
    }
    void dfs2(vector<int>& nums,int l) {
        int len = nums.size() - l;
        int S = 0;
        for(int i = 0;i < len;i++) S |= (1<<i);
        for(int sub = S;sub>=0;sub = (sub-1)&S) {
            int x = 0;
            for(int j = 0;j < len;j++) {
                if(sub&(1 << j)) x += nums[l+j];
            }
            auto it = get_lower(goal - x);
            if(it != 0)
                res = min(res,abs(goal - st[it] - x));
            if(it + 1 < st.size())
                res = min(res,abs(goal - st[it+1] - x));
            if(res == 0 || sub == 0) break;
        }
    }
    int minAbsDifference(vector<int>& nums, int goal_) {
        res = abs(goal_);
        goal = goal_;
        if(nums.size() == 1) return abs(goal - nums[0]);
        st.resize(pow(2,nums.size()/2)+1);
        st[0] = INT_MIN;
        dfs1(nums,nums.size()/2);
        sort(st.begin(),st.end());
        dfs2(nums,nums.size()/2);
        return res;
    }
};

方法二：双指针

参考题解：https://leetcode-cn.com/problems/closest-subsequence-sum/solution/zhuang-ya-dp-zhi-cong-kan-shu-ju-fan-wei-kve3/

 

和双向 dfs 的思路相同，同样是分成两段来进行分析，枚举每一段的元素组合，并排序

然后 left 指向第一段的的开头，right 指向第二段的结尾，x = A1[left] + A2[right] ，若x > goal 则,right--，否则 right++，并在过程中更新 res 即可

代码如下：

class Solution {
public:
    int minAbsDifference(vector<int>& nums, int goal) {
        int n = nums.size();
        int half = n / 2;
        int ls = half, rs = n - half;
        
        vector<int> lsum(1 << ls, 0);
        for (int i = 1; i < (1 << ls); i++) {
            for (int j = 0; j < ls; j++) {
                if ((i & (1 << j)) == 0) continue;
                lsum[i] = lsum[i-(1<<j)] + nums[j];
                break;
            }
        }
        vector<int> rsum(1 << rs, 0);
        for (int i = 1; i < (1 << rs); i++) {
            for (int j = 0; j < rs; j++) {
                if ((i & (1 << j)) == 0) continue;
                rsum[i] = rsum[i-(1<<j)] + nums[ls+j];
                break;
            }
        }
        sort(lsum.begin(), lsum.end());
        sort(rsum.begin(), rsum.end());
        
        int ret = INT_MAX;
        for (int x: lsum) {
            ret = min(ret, abs(goal - x));
        }
        for (int x: rsum) {
            ret = min(ret, abs(goal - x));
        }
        
        int i = 0, j = rsum.size() - 1;
        while (i < lsum.size() && j >= 0) {
            int s = lsum[i] + rsum[j];
            ret = min(ret, abs(goal - s));
            if (s > goal) {
                j--;
            } else {
                i++;
            }
        }
        return ret;
    }
};