C++博客-杰 & C++-文章分类-ACM/ICPC

最长递增子序列(LIS)解法详述

jaysoon — Thu, 09 Jun 2011 15:44:00 GMT

求数组中最长递增子序列（Longest Increasing Subsequence, LIS）

LIS问题是算法中的经典题目，传统的解法是使用动态规划，时间复杂度是O(n^2)；改进的方法时间复杂度是O(nlogn)。但是关于改进的算法的介绍尽管网上有很多资源，但是有许多看起来没问题，但是经不起推敲，我看的时候感觉有点看不明白，查阅半天弄懂后再回去看，发现他们的表述有问题，因此总结一下。

这篇总结使用从传统解法逐步改进的演绎方法，并给出一些推理。

如果读者不喜欢这种演绎思考方法，推荐Slyar的方法，他从另一个角度看待这个问题，写得十分简洁，但是没有接触过的话，可能不易理解。

本文仍有许多不足，欢迎指正。

传统的解法是使用动态规划。原理如下：

data[i]表示数组中的第i个元素；

lis[i]表示以元素i结尾的最长递增子序列长度；

那么lis[i] = max(lis[j]) + 1, j ∈{k | data[k] < data[i], k < i}

时间复杂度是O(n^2)，它的主要优点是算法简单，可以构造最长递增子序列。

int lis[N];
int LIS_DP(int* data, int n)
{
    memset(lis, 1, n * sizeof(lis[0]));
    for(int i=1; i != n; ++i)
    {
        for(int j=0; j != i; ++j)
        {
            if(data[i] > data[j] && lis[i] < lis[j]+1)
                lis[i] = lis[j] + 1;
        }
    }

    int max = 0;
    for(int i=0; i != n; ++i)
        if(max < lis[i])
            max = lis[i];
    return max;
}

另一种方法稍微有些复杂，它是针对上面方法的一种改进，时间复杂度是O(nlogn)。下面使用渐近的方法来分析获得。

首先我们来分析一下上面算法的不足，在上面的求解中，每个lis[i]求解的时间复杂度是O(n)，但这不是必需的

0 1 2 3 4 5 6 7

data[]: 2 5 6 2 3 4 7 4

lis[]: 1 2 3 1 2 3 4 3

例如，当求lis[6]时，是不用和data[3]、data[4]比较的，因为已经知道它们所在的最大递增子序列的最后一个元素data[5] < data[6]；也就是说，当我们考察第i个元素时，对前面i-1个元素的任何一个递增子序列，如果这个子序列的最后一个元素比data[i]小，那么就可以将data[i]加在这个子序列后面，构成一个新的更长的递增子序列，而不用比较这个子序列前面的元素和data[i]的关系。

由此我们得出第一个启发式方法，当计算lis[i]时，我们只关心每个前i-1元素中递增子序列的最后一个元素的值。

针对第一种方法引入的观点，提出第二个启发式方法，同样求lis[6]，对前i-1个元素，获得两个长度为3的递增子序列2、5、6和2、3、4，此时已知data[6] > 6且data[6]大于4，所以data[6]可以接在任何一个子序列后面，构成长度为4的新递增序列。这个时候，会发现一个启发方法，data[6]不用和6比较，因为只需data[6]大于4就可以得出一个长度为4的递增序列。

所以得出第二个启发式方法，当计算lis[i]时，对同样长度的子序列，我们只关心它们最后元素的值最小的一个的值。

由此，由一个数组last_min记录上面的值，即当计算lis[i]时，last_min[k]表示前i-1个元素中长度为k的所有递增子序列的最后一个元素的最小值。

设max_len表示当前已获得的最长的递增子序列。

当考察data[i]时，如果data[i] > last_min[max_len]，那么将data[i]接在这个序列后面，便构成一个新的长度为max_len+1的序列，该序列的最后一个元素是data[i]；否则，找到一个最大的j，使last_min[j]（由于查找方式，也说明data[i]<=last_min[j+1]），那么把data[i]接在这个序列后面，便构成一个长度为j+1的新序列，更新last_min[j+1]。

int lis[N];                // lis[i]表示以元素i结尾的最长递增子序列长度
int last_min[N];        // last_min[i]表示长度为i的所有递增子序列的
                        // 最后一个元素的最小值
int max_len;
int LIS_DP(int* data, int n)
{
    memset(lis, 1, n * sizeof(lis[0]));
    last_min[1] = data[0];
    max_len = 1;
    for(int i=1; i != n; ++i)
    {
        // 如果data[i]比最长递增序列的最后一个元素大，
        // 那么直接加在它后面便可
        if (data[i] > last_min[max_len])
        {
            ++max_len;
            last_min[max_len] = data[i];
            lis[i] = max_len;
        }
        else
        {
            // 否则查找历史最长递增序列
            for(int j=max_len-1; j != 0; --j)
            {
                if (data[i] > last_min[j])  // 也就是说，data[i] <= last_min[j+1]
                {
                    lis[i] = j + 1;
                    last_min[j+1] = data[i]; //更新
                    break;
                }
            }
        }
    }
    return max_len;
}

如上所示，虽然已经进行了很大的优化，但是当前的时间复杂度仍是O(n^2)，当然基本可以确定的是，现在的算法比原来的效率提高了很多。

下面我们分析一下last_min数组的性质，

由定义last_min[i]表示长度为i的序列A的最后一个元素的值，last_min[i-1]表示长度为i-1的序列B的最后一个元素的值，那么last_min[i-1]；否则序列A的前i-1个元素构成的序列便可替代序列B。所以last_min是有序的。

因此在上面的查找中可以使用二分查找，效率为O(logn)，使得总的复杂度为O(nlogn)。

// 返回arr中等于或第一个大于val的位置
int BinarySearch(int* arr, int left, int right, int val)
{
    int mid = 0;
    int l = left;
    int r = right;

    while (l <= r)
    {
        mid = (l + r) >> 1;
        if (arr[mid] > val) r = mid - 1;
        else if (arr[mid] < val) l = mid + 1;
        else return mid;
    }
    return l;
}

int last_min[N];        // last_min[i]表示长度为i的所有递增子序列的
                        // 最后一个元素的最小值
int max_len;
int LIS_DP(int* data, int n)
{
    last_min[1] = data[0];
    max_len = 1;
    for(int i=1; i != n; ++i)
    {
        // 如果data[i]比最长递增序列的最后一个元素大，
        // 那么直接加在它后面便可
        if (data[i] > last_min[max_len])
        {
            ++max_len;
            last_min[max_len] = data[i];
        }
        else
        {
            // 否则查找历史最长递增序列
            int j = BinarySearch(last_min, 1, max_len, data[i]);
            last_min[j] = data[i];
        }
    }
    return max_len;
}

在程序二中，lis数组完全没有作用，所以在程序三中没有使用。

与程序一相比，程序三在效率上有明显的提升，但是不能根据last_min构造出最长递增子序列。

参考文献

编程之美—微软技术面试心得.2.16节

jaysoon 2011-06-09 23:44 发表评论

POJ 2115 C Looooops解题报告

jaysoon — Sun, 11 Apr 2010 08:41:00 GMT

     题目链接：http://acm.pku.edu.cn/JudgeOnline/problem?id=2115
     本题是一道数论的入门题，模型为求 ax = b (mod n)，本题中，a = C, b = B-A, n = 2^k

     因此使用求解模线性方程算法modular_linear。关于算法的详细原理可参见欧几里德_扩展欧几里德_模线性方程，这篇blog对相关的算法给出了详细的证明，推荐。

     下面给出本题的代码，本题有几点需要注意：
     1.需要使用64位整数计算，因为2^32对普通整数会溢出；
     2.第48行，在求n时，因为在C++中，默认0x01为int型，如果不加强制转换，那么移位后会溢出；所以强制类型转换是必须的。

1 #include <cstdio>
2 typedef long long Int64;
3
4 // ax + by = d   其中d = gcd(a,b)
5 Int64 extend_euclid(Int64 a, Int64 b, Int64& x, Int64& y)
6 {
7     if(b == 0)
8     {
9         x = 1;
10         y = 0;
11         return a;
12     }
13     else
14     {
15         Int64 gcd, t;
16         gcd = extend_euclid(b, a%b, x, y);
17
18         t = x;
19         x = y;
20         y = t - a / b * y;
21         return gcd;
22     }
23 }
24
25 // ax = b mod n
26 Int64 modular_linear(Int64 a, Int64 b, Int64 n)
27 {
28     Int64 x = 0;
29     Int64 y = 0;
30     Int64 d = 0;
31
32     d = extend_euclid(a,n,x,y);
33
34     if(b % d == 0)
35     {
36         x = (x * (b / d)) % n + n;
37         return x % (n/d);
38     }
39     return -1;
40 }
41
42 int main()
43 {
44     Int64 A,B,C,k;
45
46     while(scanf("%lld%lld%lld%lld",&A,&B,&C,&k),k)
47     {
48         Int64 n = (Int64)0x01 << k;
49
50         Int64 res = modular_linear(C, B-A, n);
51         if(res == -1)
52         {
53             printf("FOREVER\n");
54         }
55         else
56         {
57             printf("%lld\n",res);
58         }
59     }
60
61     return 0;
62 }
63

jaysoon 2010-04-11 16:41 发表评论

POJ 3349 Snowflake Snow Snowflakes 解题报告

jaysoon — Tue, 02 Mar 2010 13:57:00 GMT

    世界上没有两片完全相同的雪花，本题要判断是否有两片雪花完全相同。
    题中对雪花进行了简化，只是简单的将雪花的六个臂长作为数据，如果进一步根据分形学抽象雪花的话，那么题目的难度会有所增加。
    由于数据的规模很大，所以如何比较两片雪花是关键。很自然的选择提取雪花的特征，所以应该根据六个臂长设计它的特征，该特征量设计的好坏是程序效率的主要因素。
    本解法先简单的将各个臂长乘以一个系数并相加作为雪花的特征值，然后将该特征值作为散列值加入到表中，最后查找是否有相同的雪花存在。

#include <cstdio>

const int SNOWNUM = 100005;
const int HASHSIZE = 1000000;

struct staticList{
    int data[6];
    int next;
};

staticList sList[SNOWNUM];
int newNode;
int nHashIndex[HASHSIZE+5];

int main()
{
    int i,j;
    int num;
    bool suc;
    int tmp[6],data[6];

    scanf("%d",&num);

    for(i=0; i<num; ++i)
        sList[i].next = -1;

    for(i=0; i<HASHSIZE; ++i)
        nHashIndex[i] = -1;
    newNode = 0;
    suc = false;

    for(i=0; i<num; ++i)
    {

        int nClockSt = 0, nClockVa = 0, nClockVaTemp = 0;
        int nCountSt = 0, nCountVa = 0, nCountVaTemp = 0;


        for(j=0; j<6; ++j)
            scanf("%d",&tmp[j]);

        for(j=0; j<6; ++j)
        {
            nClockVaTemp = tmp[j] * 6 + tmp[(j+1)%6] * 5 + tmp[(j+2)%6] * 4 + tmp[(j+3)%6] * 3 + tmp[(j+4)%6] * 2 + tmp[(j+5)%6];
            if(nClockVa < nClockVaTemp) {nClockVa = nClockVaTemp; nClockSt = j;}

            nCountVaTemp = tmp[j] * 6 + tmp[(j+5)%6] * 5 + tmp[(j+4)%6] * 4 + tmp[(j+3)%6] * 3 + tmp[(j+2)%6] * 2 + tmp[(j+1)%6];
            if(nCountVa < nCountVaTemp) {nCountVa = nCountVaTemp; nCountSt = j;}
        }

        if(nClockVa > nCountVa)
        {
            for(j=0; j<6; ++j)
                data[j] = tmp[(nClockSt+j)%6];
        }
        else
        {
            for(j=0; j<6; ++j)
                data[j] = tmp[(nCountSt+6-j)%6];
        }

        int nValue = nClockVa > nCountVa ? nClockVa : nCountVa;
        nValue %= HASHSIZE;

        if(nHashIndex[nValue] != -1)
        {
            int next = nHashIndex[nValue];

            while(next != -1)
            {
                for(j=0; j<6; ++j)
                    if(data[j] != sList[next].data[j]) break;
                if(j==6)
                {
                    suc = true;
                    goto en;
                }
                next = sList[next].next;
            }

            for(j=0; j<6; ++j)
                sList[newNode].data[j] = data[j];

            sList[newNode].next = nHashIndex[nValue];
            nHashIndex[nValue] = newNode;
            ++newNode;
        }
        else
        {
            for(j=0; j<6; ++j)
                sList[newNode].data[j] = data[j];
            nHashIndex[nValue] = newNode;

            ++newNode;
        }
    }
en: if(suc)
    {
        for(++i; i<num; ++i)
        {
            for(j=0; j<6; ++j)
                scanf("%d",&tmp[j]);
        }
    }

    if(suc)
        printf("Twin snowflakes found.\n");
    else
        printf("No two snowflakes are alike.\n");

    return 0;
}

jaysoon 2010-03-02 21:57 发表评论

POJ Scout YYF I 解题报告

jaysoon — Sat, 12 Sep 2009 13:36:00 GMT

/*
*   Pro(i)表示不遇到雷的情况下，到达i步的几率，那么
*       Pro(n) = Pro(n-1) * p + Pro(n-2) * (1-p)
*   首先求递推公式，由特征方程 x^2 - p*x -(1-p) = 0 求得特征根: p-1 和 1
*   所以Pro(n) = C1 + C2*(p-1)^n
*   将Pro(1)=1 Pro(2)=p代入，求得待定系数C1 = -1/(p-2), C2 = 1/(p-2)
*   故Pro(n) = -1/(p-2) + 1/(p-2)^n
*
*   假设在位置k首次遇到雷，那么到达位置k-1的几率是 Pro(k-1)
*   经过雷后存活的几率是 Pro(k-1) * (1-p)
*   将这个值即为a
*
*   假设又经过t步第二次遇到雷，那么到达t-1步的几率是 a*Pro(t-1)
*   经过雷后存活的几率是 a * Pro(t-1) * (1-p)
*
*   以此类推
*/

#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;

int main()
{
    const int SIZE = 15;
    int iMineNum;
    double p;
    int pMinePos[SIZE];     //记录雷的位置
    double pRes[SIZE];      //pRes[i]表示经过雷i后存活下来的几率

    while(scanf("%d%lf",&iMineNum,&p) != EOF)
    {
        *(pMinePos+0) = 0;              //  为了统一后面的计算
        for(int i=1; i<=iMineNum; ++i)
            scanf("%d", (pMinePos+i));

        sort(pMinePos,pMinePos + iMineNum + 1);     //对雷的位置进行排序

        pRes[0] = 1;                    //  为了统一后面的计算

        for(int i=1; i<=iMineNum; ++i)
        {
            /*计算遇到雷之前，存活的几率*/
            pRes[i] =  -1/(p-2) + 1/(p-2) * pow((p-1),pMinePos[i]-pMinePos[i-1]-1);

            /**/
            pRes[i] *= (1-p) * pRes[i-1];
        }
        printf("%.7lf\n",pRes[iMineNum]);
    }
    return 0;
}

jaysoon 2009-09-12 21:36 发表评论

图论最大网络流（一） POJ 1273 解题报告

jaysoon — Sun, 26 Apr 2009 11:18:00 GMT

        题目链接http://acm.pku.edu.cn/JudgeOnline/problem?id=1273
        本题是最大流算法的简单应用。
        最大网络流的基本思想很简单——从某个初始流开始，反复的增加流的流量知道不能再改进为止。最后得到的流将是一个最大流。
        定理设 P 是网络 G 中从起点到终点满足一下条件的一条路径：
                  (a) 对P中的每条正向边(i,j)， F_ij < C_ij

                (b)对P中的每条反向边(i,j)， Fij    > 0
                 设 D是由P中所有正向边(i,j)对应的数和P中所有反向边(i,j)对应的数组成。
                          Δ =min D

                                               F_ij                   如果(i,j)不在P中
                     F^*_ij={  F_ij+ Δ 如果(i,j)在P中且是正向的
               F_ij-Δ   如果(i,j)在P中且不是正向的

   根据上述定理，如果找不到路径满足上述定理，那么得到的流便是最大的。我们可以构造一个算法：
   1.从一个流开始；
   2.寻找一个满足上述定理的路径，如果这样的路径不存在，则停止，流是最大的；
   3.将流过这条路径的流量增加△，转到第2行。
   Ford-Fulkerson方法是按照上述定理构造，解决最大流问题的有效方法，一般采用深搜策略；而Edmonds-Karp算法是Ford-Fulkerson方法的广搜的实现；相对而言，后者的效率稍微高一些。

      下面是POJ 1273的代码，采用的是Edmonds-Karp算法。

1#include <cstdio>
2#include <queue>
3const int INF=0x0fffffff;
4const int SIZE=202;
5
6int bfs(int (*mat)[SIZE],int start,int end,int* path)
7{
8    int flow[SIZE];//存储一次BFS遍历之后流的可改进量；
9    std::queue<int> q;
10    int i;
11
12    for(i=0;i<SIZE;++i)
13        path[i]=-1;
14    path[start]=0,flow[start]=INF;
15
16    q.push(start);
17    while(!q.empty())
18    {
19        int top=q.front();
20        q.pop();
21        if(top==end) break;
22        for(i=1;i<=end;++i)
23        {
24            if(i != start && path[i]==-1 && mat[top][i])
25            {
26                flow[i]=flow[top]<mat[top][i] ? flow[top] : mat[top][i];
27                q.push(i);
28                path[i]=top;
29            }
30        }
31    }
32    if(path[end]==-1) return -1;
33    return flow[end];
34
35
36}
37int Edmonds_Karp(int (*mat)[SIZE],int start,int end)
38{
39    int maxflow=0,step,cur,pre;
40    int path[SIZE];    ////存储当前已访问过的节点的增广路径；
41    while((step=bfs(mat,start,end,path)) != -1)//找不到增广路径时退出
42    {
43        maxflow += step;
44        cur=end;
45        while(cur != start)
46        {
47            pre=path[cur];
48            mat[pre][cur] -= step;    //更新正向边的实际容量
49            mat[cur][pre] += step;    //添加反向边
50            cur=pre;
51        }
52    }
53    return maxflow;
54}
55
56int main()
57{
58    int mat[SIZE][SIZE];
59    int vecNum,edgeNum;
60    int i;
61    int a,b,c;
62
63    while(scanf("%d%d",&edgeNum,&vecNum)!=EOF)
64    {
65        memset(mat,0,sizeof(mat));
66        for(i=0;i<edgeNum;++i)
67        {
68            scanf("%d%d%d",&a,&b,&c);
69            mat[a][b]+=c;
70        }
71
72        int re=Edmonds_Karp(mat,1,vecNum);
73        printf("%d\n",re);
74
75    }
76    return 0;
77}
78

jaysoon 2009-04-26 19:18 发表评论