动态规划的时间复杂度优化之二分查找

前言

动态规划是面对最值问题的比较通用的解法，当然并不是所有的最值问题都能通过动态规划去解决，动态规划解决的基本上是具有最优子结构的，并且能够通过备忘录或者动态规划表继进行优化的。
那么有的动态规划题目由于时间复杂度的限制，在对于有较高的时间复杂度的要求下，我们需要优化动态规划的算法，使得其时间复杂度降低。

最长递增子序列

这道题按理来说是动态规划中的开胃菜，但是其一般的做法时间复杂度高达$O(n^2)$

class Solution {
    public int lengthOfLIS(int[] nums) {
        int n=nums.length;
        int []dp=new int[nums.length];
        Arrays.fill(dp,1);
        for(int i=1;i<n;i++)
        {
            for(int j=0;j<i;j++)
            {
                if(nums[j]<nums[i])
                {
                    dp[i]=Math.max(dp[i],dp[j]+1);
                }
            }
        }
        int ret=0;
        for(int i=0;i<n;i++)
        {
            if(ret<dp[i])
            {
                ret=dp[i];
            }
        }
        return ret;
    }
}

我们利用二分查找去优化，想要用二分查找就必须有有序的容器，所以，我们必须自己构建一个有序数组，这个数组中放那些值也很好想到，放本次遍历之前的递增子序列。重点的设计在于让有序数组的长度是动态变化的。

class Solution{
    public int lengthOfLIS(int[] nums) {
    	int n=nums.length;
    	int [] tails=new int[n];
    	int tailsLength=0;
    	for(int i=0;i<n;i++)
    	{
    		left=0;
    		right=tailsLength;
    		while(left<right)
    		{
    			int mid=(right-left)/2+left;
    			if(tails[mid]<nums[i])
    			{
    				left=mid+1;
    			}
    			else
    			{
    				right=mid;
    			}
    		}
    		  tails[left] = nums[i];
    		  if(tailsLength == right) tailsLength++;
    	}
    	return tailsLength;
    }
}

无重叠子区间

这道题是最长递增子序列的变体，也可以用二分法进行动态规划优化，但是这一题比较复杂，因为我们有两头，因为是二维数组，作为最一般的做法，我们需要固定一头，来考虑另一头，

这里有两种的方法，第一种，自己构建递增子序列的容器

class Solution {
    public int eraseOverlapIntervals(int[][] intervals) {
    Arrays.sort(intervals,new Comparator<int []>(){
    	public int compare(int []o1,int []o2)
    	{
    		return o1[1]-o2[1];
    	}	
    });
    int [] tails=new int[intervals.length];
    int tailsLength=0;
    for(int i=0;i<intervals.length;i++)
    {
    	int left=0;
    	int right=tailsLength;
    	while(left<right)
    	{
    		int mid=(right-left)/2+left;
    		if(tails[mid]<=intervals[i][0] )
    		{
    			left=mid+1;
    		}
    		else
    		{
    			right=mid;
    		}
    	}
        if(left==tailsLength) 
        {
            tails[tailsLength]=intervals[i][1];
            tailsLength++;
        }
        else if(tails[left]>intervals[i][1])
        {
            tails[left]=intervals[i][1];
        }

        // if(tails[left]>intervals[i][1] || )
        // {
    	//  tails[right]=intervals[i][1];
        // }
        // if(right==tailsLength)tailsLength++;
    }
    return intervals.length-tailsLength;
	    }
	}

这道题如果想要用动态规划+二分法的方式去做还是有难度的，我们不能直接从上面最长子序列的直接推导过来，因为这个是个区间问题，我们第一次通过

if(tails[mid]<=intervals[i][0])

去判断从而拿到最右侧边界后还需要做额外的事情，我们在上面判断的只是intervals[i][0]，我们真正能将一个区间嫁接到tails表后面，还需要后面一个条件

if(tails[left]>intervals[i][1])
{
	tails[left]=intervals[i][1];
}

当然left要在tails区间内部，如果已经出现在边界，那么是肯定可以嫁接的。
所以最后的判断条件，相对于最长子序列这道题有所差别。

俄罗斯套娃信封问题

class Solution {
    public int maxEnvelopes(int[][] envelopes) {
        Arrays.sort(envelopes,new Comparator<int []>(){
            public int compare(int []e1,int []e2)
            {
                if(e1[0]!=e2[0])
                {
                    return e1[0]-e2[0];
                }
                else
                {
          //这里降序的前提是对于第一个维度相同的情况，第一个维度相同的情况下是不满足条件的
          //因为我们两种排序过后，是按照第二个维度进行
                    return e2[1]-e1[1];
                }
            }  
        });
        int [] tails=new int[envelopes.length];
        int tailsLength=0;
        for(int i=0;i<envelopes.length;i++)
        {
            int left=0;
            int right=tailsLength;
            while(left<right)
            {
                int mid=(right-left)/2+left;
                if(tails[mid]<envelopes[i][1])
                {
                    left=mid+1;
                }
                else
                {
                    right=mid;
                }
            }
            tails[right]=envelopes[i][1];
            if(right==tailsLength) tailsLength++;
        }
        return tailsLength;
    }
}

有了上面题目的铺垫，这道题的难点就在于你怎么排序到最后可以用一个维度解决问题。本题的排序方式是先按照维度1升序排序，再按照维度2降序排序。