回顾经典问题算法：LIS, LCS-（DP类别）

LIS,最长递增子序列
说明见：http://blog.csdn.net/sdjzping/article/details/8759870

#include <iostream>
#include <cstdlib>

using namespace std;

int LIS(int* arr, int len) {
    if (arr == NULL || len < 1) return 0;
    int LIS[len] = {0};
    int mlen = 0;
    for (int i=0; i<len; i++) {
        LIS[i] = 1;
        for (int j = 0; j < i; j++) {
            if (arr[j] < arr[i] && LIS[i] < LIS[j] + 1) {
                LIS[i] = LIS[j] + 1;
            }
        }
        if (LIS[i] > mlen) {
            mlen = LIS[i];
        }
    }
    return mlen;
}


int main() {
    int arr[] = {1, -1, 2, -3, 4, -5, 6, -7};
    int len = sizeof(arr) / sizeof(arr[0]);
    cout<<LIS(arr, len)<<endl;
    system("pause");
    return 0;
}

 再给出nlogn的解法，其中len2val数组就是记录当前LIS长度时结尾的数字（可能情况下的最小值，如1,3和1,2同样可以构成长度为2的LIS但是取len2val[2]=2），关于这个数组的详细说明，可以参考第一个给出的连接，相对于第一个算法的改进就是该数组是有序的，可以使用二分搜索，即在数组中找到第一个比待处理值V大或相等的index设为I（就是序列长度），那么这个V必然可以插入到以len2val[I-1]结尾的长度为I-1的序列后部，形成新序列的长度为I，因而更新数组len2val[I] = V（更新是因为当前值肯定是大于等于V的，因为一开始就是根据这个条件进行搜索的）。这个查找的过程可以用STL中的lower_bound来做，这里自己按照源码写了一个直接返回索引的版本，STL中返回的是迭代器（数组迭代器就是元素指针，比较时还需减掉数组起始位置，才能得到索引）。

int idx_lower_bound(int a[], int begin, int end, int target) {
    int count = end - begin;
    int first = begin;
    while (count > 0) {
        int step = count/2;
        int idx = first + step;
        if (a[idx] < target) {
            first = ++idx;
            count = count - step - 1;
        } else {
            count = step;
        }
    }

    return first;
}

int LIS_NLOGN(int arr[], int len) {
    if (arr == NULL || len < 1) {
        return 0;
    }
    int* len2idx = new int[len+1];

    len2idx[1] = arr[0];
    int maxlen = 1;
    for (int i=1; i<len; i++) {
        char ch = arr[i];
        int upper = idx_lower_bound(len2idx, 0, maxlen + 1, ch);
        len2idx[upper] = ch;
        if (upper > maxlen) {
            maxlen = upper;
        }
    }
    return maxlen;
}

 

LCS,最长公共子序列

#include <iostream>
#include <cstdlib>
#include <cstring>

using namespace std;

int max(int a, int b) {
    return a > b ? a : b;
}

int LCS(const char* s1, int len1, const char* s2, int len2) {
    if (s1 == NULL || s2 == NULL || len1 < 1 || len2 < 1) return 0;
    
    int dp[len1 + 1][len2 + 1];
    
    for (int i=0; i<=len1; i++) {
        for (int j=0; j<=len2; j++) {
            dp[i][j] = 0;
        }
    }
    
    for (int i=1; i<= len1; i++) {
        for (int j=1; j<=len2; j++) {
            if (s1[i-1] == s2[j-1]) {
                dp[i][j] = dp[i-1][j-1] + 1;
            } else {
                dp[i][j] = max(dp[i-1][j], dp[i][j-1]);
            }
        }
    }
    for (int i=0; i<=len1; i++) {
        for (int j=0; j<=len2; j++) {
            cout<<" "<<dp[i][j];
        }
        cout<<endl;
    }
    return dp[len1][len2];
};

int main() {
    const char* s1 = "helloyyc";
    const char* s2 = "xellxddc";
    
    cout<<LCS(s1, strlen(s1), s2, strlen(s2))<<endl;

    system("pause");
    return 0;
}