欧美日韩一区高清,国产精品主播,国产精品多人

最镉K��增子序�?LIS)解法详述

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

求数�l�中最镉K��增子序列（Longest Increasing Subsequence, LIS�Q?/span>

LIS问题是算法中的经兔R��目，传统的解法是使用动态规划，旉��复杂度是O(n^2)�Q�改�q�的�Ҏ��旉��复杂度是O(nlogn)。但是关于改�q�的��法的介�l�尽��网上有很多资源�Q�但是有许多看�v来没问题�Q�但是经不�v推敲�Q�我看的时候感觉有点看不明白，查阅半天弄懂后再回去看，发现他们的表�q�有问题�Q�因此�ȝ��一下�?/em>

�q�篇�ȝ��使用从传�l�解法逐步改进的演�l�方法，�q�给��Z��些推理�?/em>

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

本文仍有许多不��Q�欢�q�指正�?/strong>

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

data[i]表示数组中的�W?/span>i个元素；

lis[i]表示以元�?/span>i�l�尾的最镉K��增子序列长度；

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

旉��复杂度是O(n^2)�Q�它的主要优�Ҏ��法��单，可以构造最镉K��增子序列�?/span>
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;
}

另一�U�方法稍微有些复杂，它是针对上面�Ҏ��的一�U�改�q�，旉��复杂度是O(nlogn)。下面��用渐�q�的�Ҏ��来分析获得�?/span>

首先我们来分析一下上面算法的不��Q�在上面的求解中�Q�每�?/span>lis[i]求解的时间复杂度�?/span>O(n)�Q�但�q�不是必需�?/span>

             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

例如�Q�当�?/span>lis[6]�Ӟ��是不用和data[3]�?/span>data[4]比较的，因�ؓ已经知道它们所在的最大递增子序列的最后一个元�?/span>data[5] < data[6]�Q�也��是��_��当我们考察�W?/span>i个元素时�Q�对前面i-1个元素的��M��一个递增子序列，如果�q�个子序列的最后一个元素比data[i]��，那么��可以将data[i]加在�q�个子序列后面，构成一个新的更长的递增子序列，而不用比较这个子序列前面的元素和data[i]的关�p�R�?/span>

由此我们得出�W�一个启发式�Ҏ��Q�当计算lis[i]�Ӟ��我们只关心每个前i-1元素中递增子序列的最后一个元素的倹{�?/span>

针对�W�一�U�方法引入的观点�Q�提出第二个启发式方法，同样�?/span>lis[6]�Q�对�?/span>i-1个元素，获得两个长度�?/span>3的递增子序�?/span>2�?/span>5�?/span>6�?/span>2�?/span>3�?/span>4�Q�此时已�?/span>data[6] > 6�?/span>data[6]大于4�Q�所�?/span>data[6]可以接在��M��一个子序列后面�Q�构成长度�ؓ4的新递增序列。这个时候，会发��C��个启发方法，data[6]不用�?/span>6比较�Q�因为只需data[6]大于4��可以得��Z��个长度�ؓ4的递增序列�?/span>

所以得出第二个启发式方法，当计��?/span>lis[i]�Ӟ��对同样长度的子序列，我们只关心它们最后元素的值最��的一个的倹{�?/span>

由此�Q�由一个数�l?/span>last_min记录上面的��|��卛_��计算lis[i]�Ӟ��last_min[k]表示�?/span>i-1个元素中长度�?/span>k的所有递增子序列的最后一个元素的最��倹{�?/span>

�?/span>max_len表示当前已获得的最长的递增子序列�?/span>

当考察data[i]�Ӟ��如果data[i] > last_min[max_len]�Q�那么将data[i]接在�q�个序列后面�Q�便构成一个新的长度�ؓmax_len+1的序列，该序列的最后一个元素是data[i]�Q�否则，扑ֈ�一个最大的j�Q��last_min[j]�Q�由于查找方式，也说�?/span>data[i]<=last_min[j+1]�Q�，那么�?/span>data[i]接在�q�个序列后面�Q�便构成一个长度�ؓj+1的新序列�Q�更�?/span>last_min[j+1]�?/span>

int lis[N];                // lis[i]表示以元素i�l�尾的最镉K��增子序列长�?/span>
int last_min[N];        // last_min[i]表示长度为i的所有递增子序列的
                        // 最后一个元素的最��?/span>
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]比最镉K��增序列的最后一个元素大�Q?br />        // 那么直接加在它后面便�?/span>
        if (data[i] > last_min[max_len])
        {
            ++max_len;
            last_min[max_len] = data[i];
            lis[i] = max_len;
        }
        else
        {
            // 否则查找历史最镉K��增序列
            for(int j=max_len-1; j != 0; --j)
            {
                if (data[i] > last_min[j])  // 也就是说�Q�data[i] <= last_min[j+1]
                {
                    lis[i] = j + 1;
                    last_min[j+1] = data[i]; //更新
                    break;
                }
            }
        }
    }
    return max_len;
}

如上所�C�，虽然已经�q�行了很大的优化�Q�但是当前的旉��复杂度仍�?/span>O(n^2)�Q�当然基本可以确定的是，现在的算法比原来的效率提高了很多�?/span>

下面我们分析一�?/span>last_min数组的性质�Q?/span>

由定�?/span>last_min[i]表示长度�?/span>i的序�?/span>A的最后一个元素的��|��last_min[i-1]表示长度�?/span>i-1的序�?/span>B的最后一个元素的��|��那么last_min[i-1]�Q�否则序�?/span>A的前i-1个元素构成的序列便可替代序列B。所�?/span>last_min是有序的�?/span>

因此在上面的查找中可以��用二分查找，效率�?/span>O(logn)�Q��得�ȝ��复杂度�ؓO(nlogn)�?/span>

// �q�回arr中等于或�W�一个大于val的位�|?/span>
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的所有递增子序列的
                        // 最后一个元素的最��?/span>
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]比最镉K��增序列的最后一个元素大�Q?br />        // 那么直接加在它后面便�?/span>
        if (data[i] > last_min[max_len])
        {
            ++max_len;
            last_min[max_len] = data[i];
        }
        else
        {
            // 否则查找历史最镉K��增序列
            int j = BinarySearch(last_min, 1, max_len, data[i]);
            last_min[j] = data[i];
        }
    }
    return max_len;
}

在程序二中，lis数组完全没有作用�Q�所以在�E�序三中没有使用�?/span>

与程序一相比�Q�程序三在效率上有明昄��提升�Q�但是不能根�?/span>last_min构造出最镉K��增子序列�?/span>

参考文�?/span>

   �~�程之美—微��Y技术面试心�?2.16�?/span>

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

POJ 2115 C Looooops解题报告

jaysoon — Sun, 11 Apr 2010 08:41:00 GMT
     题目链接�Q?a title="C looooops" >http://acm.pku.edu.cn/JudgeOnline/problem?id=2115
     本题是一道数论的入门题，模型为求 ax = b (mod n)�Q�本题中�Q�a = C, b = B-A, n = 2^k

     因此使用求解模线性方�E�算法modular_linear。关于算法的详细原理可参�?a title="�Ƨ几里�d_扩展�Ƨ几里�d_模线性方�E? href="http://www.shnenglu.com/RyanWang/archive/2009/07/19/90525.html">�Ƨ几里�d_扩展�Ƨ几里�d_模线性方�E?/a>�Q�这��blog对相关的��法�l�出了详�l�的证明�Q�推荐�?br>

     下面�l�出本题的代码，本题有几炚w��要注意：
     1.需要��?4位整数计��，因�ؓ2^32�Ҏ��通整��C��溢出�Q?br>     2.�W?8行，在求n�Ӟ��因�ؓ在C++中，默认0x01为int型，如果不加强制转换�Q�那么移位后会溢出；所以强制类型�{换是必须的�?br>

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

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

#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)表示不遇到雷的情况下�Q�到达i步的几率�Q�那�?
*       Pro(n) = Pro(n-1) * p + Pro(n-2) * (1-p)
*   首先求递推公式�Q�由特征方程 x^2 - p*x -(1-p) = 0 求得特征�? p-1 �?1
*   所以Pro(n) = C1 + C2*(p-1)^n
*   ��Pro(1)=1 Pro(2)=p代入�Q�求得待定系数C1 = -1/(p-2), C2 = 1/(p-2)
*   故Pro(n) = -1/(p-2) + 1/(p-2)^n
*
*   假设在位�|�k首次遇到��P��那么到达位置k-1的几率是 Pro(k-1)
*   �l�过雷后存活的几率是 Pro(k-1) * (1-p)
*   ��这个值即为a
*
*   假设又经�q�t步第二次遇到��P��那么到达t-1步的几率�?a*Pro(t-1)
*   �l�过雷后存活的几率是 a * Pro(t-1) * (1-p)
*
*   以此�c�L��
*/

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

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

    while(scanf("%d%lf",&iMineNum,&p) != EOF)
    {
        *(pMinePos+0) = 0;              //  ��Z��l�一后面的计��?nbsp;
        for(int i=1; i<=iMineNum; ++i)
            scanf("%d", (pMinePos+i));

        sort(pMinePos,pMinePos + iMineNum + 1);     //寚w��的位�|�进行排�?nbsp;

        pRes[0] = 1;                    //  ��Z��l�一后面的计��?nbsp;

        for(int i=1; i<=iMineNum; ++i)
        {
            /**//*计算遇到雷之前，存活的几�?/span>*/
            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 发表评论

图论最大网�l�流�Q�一�Q?POJ 1273 解题报告

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

        题目链接http://acm.pku.edu.cn/JudgeOnline/problem?id=1273
        本题是最大流��法的简单应用�?br>        最大网�l�流的基本思想很简单——从某个初始��开始，反复的增加流的流量知道不能再改进为止。最后得到的��将是一个最大流�?br>        定理 �?P 是网�l?G 中从��L��到终�Ҏ��一下条件的一条�\径：
                  (a) �?span style="FONT-FAMILY: Comic Sans MS">P中的每条正向�?span style="FONT-FAMILY: Comic Sans MS">(i,j)�Q?F_ij < C_ij

                (b)�?span style="FONT-FAMILY: Comic Sans MS">P中的每条反向�?span style="FONT-FAMILY: Comic Sans MS">(i,j)�Q?Fij    > 0
                 �?D是由P中所有正向边(i,j)对应的数�?span style="FONT-FAMILY: Comic Sans MS">P中所有反向边(i,j)对应的数�l�成�?br>                          Δ =min D

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

   �Ҏ��上述定理�Q�如果找不到路径满��上述定理�Q�那么得到的��便是最大的。我们可以构造一个算法：
   1.从一个流开始；
   2.��L��一个满��上�q�定理的路径�Q�如果这��L��路径不存在，则停止，��是最大的�Q?br>   3.��流�q�这条�\径的��量增加▻I��转到�W?行�?br>   Ford-Fulkerson�Ҏ��是按照上�q�定理构造，解决最大流问题的有效方法，一般采用深搜策略；而Edmonds-Karp��法是Ford-Fulkerson�Ҏ��的广搜的实现�Q�相对而言�Q�后者的效率�E�微高一些�?br>
      下面是POJ 1273的代码，采用的是Edmonds-Karp��法�?br>

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遍历之后��的可改�q�量�Q?/span>
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];    /**/////存储当前已访问过的节点的增广路径�Q?/span>
41    while((step=bfs(mat,start,end,path)) != -1)//找不到增�q��\径时退�?/span>
42    {
43        maxflow += step;
44        cur=end;
45        while(cur != start)
46        {
47            pre=path[cur];
48            mat[pre][cur] -= step;    //更新正向边的实际定w��
49            mat[cur][pre] += step;    //��d��反向�?/span>
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 发表评论