每日編程——最長子序列系列問題的求解

1.最長遞增子序列

該問題旨在求解序列中最長子序列，子序列不同於子串，沒有連續性要求，顯然最長子序列具備最優子結構性質。
如何獲取遞推表達式呢？
（1）狀態是什麼？
	序列的長度，在序列長度由1~(1~len)變化過程中，最長子序列的長度怎麼隨之變化呢？
（2）如何表示第i個狀態和第i-1個狀態之間的關係？
	opt(i)表示下標爲0~i的序列的最長子序列，那麼opt(i-1)表示下標爲0~i-1的序列的最長子序列.
	opt(i)的大小取決於nums[i]與nums[0~i-1]的大小關係，可以寫出遞推表達式：
opt[i] = max（opt[j] +1） 	if j  for any one j satisfy nums[i] > nums[j] 
opt[i] = 1 					if j  for all j statisfy nums[i] < nums[j]

// O(n^2)
  int findLengthLIS(vector<int> &nums)
    {
        int len = nums.size();
        if (len == 0)
        {
            return 0;
        }
        vector<int> opt(len);
        opt[0] = 1;
        for (int i = 1; i < len; i++)
        {
            int re = 1;
            for (int j = 0; j < i; j++)
            {
                if( nums[i] > nums[j])
                {
                    re = max(re,opt[j] + 1);
                }
            }
            opt[i] = re;
        }

        int max_len = 0;
        for (auto e: opt)
        {   
            max_len = max(max_len,e);
        }
        return max_len;
    }
    

如何進階？換種思路：紙牌遊戲，圖片很形象，相信小時候玩過的一看就懂。

//O(nlogn)
int lengthOfLIS(vector<int>& nums) 
    {
        int len = nums.size();
        vector<int> heap(len);
        int piles = 0;
        // 對每個num進行操作：替換掉原有堆，還是成爲新的堆首
        for (int i = 0; i < len; i++) 
        {
            //對所有堆進行二分查找
            int left = 0,right = piles;
            while (left < right)
            {
                int mid = (left + right) /2;
                if (heap[mid] >= nums[i]) //往左邊查
                {
                    right = mid;
                }
                else if(heap[mid] < nums[i]) //往右邊查
                {
                    left = mid +1;
                }
            }

            if(left == piles) //當前牌是heap中最大的
            {
                piles ++;
            }
            heap[left] = nums[i];   
        }
        return piles;
    }

2.最長連續遞增子序列（最長遞增子串）

leecode

//relax 超easy的，有木有，然鵝，LeetCode上排名很low，想不到優化的tricks了（help me？私我）
int findLengthOfLCIS(vector<int>& nums) {
        int n= nums.size();
        if (n ==0) return 0;
        int cnt = 1, re = 1;
        for (int i = 0;i< n-1; i++)
        {
            if (nums[i+1] > nums[i])
            {
                cnt++;
            }else {
                re = max(cnt,re);
                cnt = 1;
            }
        }
        re = max (cnt,re);
        return re;
    }

3.最長遞增子序列的個數

LeetCode

int findNumberOfLIS(vector<int>& nums) {
        int n = nums.size();
        if (n == 0) return 0;
        vector <int> count(n,1);
        vector<int> len(n,1);
        int maxLen = 1;
        for (int i = 1; i< n;i++)
        {
            for (int j = 0; j < i;j++)
            {
                if (nums[i] > nums[j])
                { 
                    if (len[j] + 1 > len[i]) // nums[i]並沒有安排在nums[j]的後面
                    {
                        len[i] = len[j] +1;
                        count[i] = count[j];
                    }
                    else if (len[j] +1 == len[i])
                    {

                        count[i] += count[j];
                    }
                }
            }
            maxLen = max(maxLen,len[i]);
        }
        int re = 0;
        for (int i = 0; i< n; i++)
        {
            if (len[i] == maxLen)
            {
                re += count[i];
            }
        }
        return re;
        
    }