C++博客-mysileng-随笔分类-数据结构与算法

Dijkstra算法（单源最短路径）

鑫龙 — Wed, 16 Oct 2013 12:31:00 GMT

Dijkstra算法（单源最短路径）

单源最短路径问题，即在图中求出给定顶点到其它任一顶点的最短路径。在弄清楚如何求算单源最短路径问题之前，必须弄清楚最短路径的最优子结构性质。

一.最短路径的最优子结构性质

该性质描述为：如果P(i,j)={Vi....Vk..Vs...Vj}是从顶点i到j的最短路径，k和s是这条路径上的一个中间顶点，那么P(k,s)必定是从k到s的最短路径。下面证明该性质的正确性。

假设P(i,j)={Vi....Vk..Vs...Vj}是从顶点i到j的最短路径，则有P(i,j)=P(i,k)+P(k,s)+P(s,j)。而P(k,s)不是从k到s的最短距离，那么必定存在另一条从k到s的最短路径P'(k,s)，那么P'(i,j)=P(i,k)+P'(k,s)+P(s,j)

二.Dijkstra算法

由上述性质可知，如果存在一条从i到j的最短路径(Vi.....Vk,Vj)，Vk是Vj前面的一顶点。那么(Vi...Vk)也必定是从i到k的最短路径。为了求出最短路径，Dijkstra就提出了以最短路径长度递增，逐次生成最短路径的算法。譬如对于源顶点V0，首先选择其直接相邻的顶点中长度最短的顶点Vi，那么当前已知可得从V0到达Vj顶点的最短距离dist[j]=min{dist[j],dist[i]+matrix[i][j]}。根据这种思路，

假设存在G=，源顶点为V0，U={V0},dist[i]记录V0到i的最短距离，path[i]记录从V0到i路径上的i前面的一个顶点。

1.从V-U中选择使dist[i]值最小的顶点i，将i加入到U中；

2.更新与i直接相邻顶点的dist值。(dist[j]=min{dist[j],dist[i]+matrix[i][j]})

3.知道U=V，停止。

代码实现:

/*Dijkstra求单源最短路径 2010.8.26*/

#include
#include
#define M 100
#define N 100
using namespace std;

typedef struct node
{
    int matrix[N][M];      //邻接矩阵
    int n;                 //顶点数
    int e;                 //边数
}MGraph;

void DijkstraPath(MGraph g,int *dist,int *path,int v0)   //v0表示源顶点
{
    int i,j,k;
    bool *visited=(bool *)malloc(sizeof(bool)*g.n);
    for(i=0;i//初始化
    {
        if(g.matrix[v0][i]>0&&i!=v0)
        {
            dist[i]=g.matrix[v0][i];
            path[i]=v0;     //path记录最短路径上从v0到i的前一个顶点
        }
        else
        {
            dist[i]=INT_MAX;    //若i不与v0直接相邻，则权值置为无穷大
            path[i]=-1;
        }
        visited[i]=false;
        path[v0]=v0;
        dist[v0]=0;
    }
    visited[v0]=true;
    for(i=1;i//循环扩展n-1次
    {
        int min=INT_MAX;
        int u;
        for(j=0;j//寻找未被扩展的权值最小的顶点
        {
            if(visited[j]==false&&dist[j]            {
                min=dist[j];
                u=j;
            }
        }
        visited[u]=true;
        for(k=0;k//更新dist数组的值和路径的值
        {
            if(visited[k]==false&&g.matrix[u][k]>0&&min+g.matrix[u][k]            {
                dist[k]=min+g.matrix[u][k];
                path[k]=u;
            }
        }
    }
}

void showPath(int *path,int v,int v0)   //打印最短路径上的各个顶点
{
    stack<int> s;
    int u=v;
    while(v!=v0)
    {
        s.push(v);
        v=path[v];
    }
    s.push(v);
    while(!s.empty())
    {
        cout<        s.pop();
    }
}

int main(int argc, char *argv[])
{
    int n,e;     //表示输入的顶点数和边数
    while(cin>>n>>e&&e!=0)
    {
        int i,j;
        int s,t,w;      //表示存在一条边s->t,权值为w
        MGraph g;
        int v0;
        int *dist=(int *)malloc(sizeof(int)*n);
        int *path=(int *)malloc(sizeof(int)*n);
        for(i=0;i            for(j=0;j                g.matrix[i][j]=0;
        g.n=n;
        g.e=e;
        for(i=0;i        {
            cin>>s>>t>>w;
            g.matrix[s][t]=w;
        }
        cin>>v0;        //输入源顶点
        DijkstraPath(g,dist,path,v0);
        for(i=0;i        {
            if(i!=v0)
            {
                showPath(path,i,v0);
                cout<            }
        }
    }
    return 0;
}

鑫龙 2013-10-16 20:31 发表评论

逆序数及其求法

鑫龙 — Fri, 20 Sep 2013 09:23:00 GMT

1. 逆序数

所谓逆序数，就是指一个序列S[i]，统计处于序列的每个数的比这个数大并且排在它前面的数的数目，然后对于所有数，把这个数目加起来求和就是了。
比如 4 3 1 2
4第一个，所以数目为0
3的前面是4，大于3的数目为1
1的前面是4 3 ，大于1的数目为2
2的前面是4 3 1，大于2的数目为2
所以逆序数为1+2+2 = 5

求逆序数的两种方法
常规方法是按照逆序数的规则做，结果复杂度是O(n*n)，一般来说，有两种快速的求逆序数的方法
分别是归并排序和树状数组法

2. 归并排序
归并排序是源于分而治之思想，详细的过程可以查阅其他资料，总体思想是划分一半，各自排好序后将两个有序序列合并起来。

如何修改归并排序求逆序数?
首先我们假设两个有序序列 a[i]和b[i]，当合并时：
由于a[i]已是有序，所以对于a[i]的各个元素来说，排在它前面且比它大的数目都是0
当b[i]中含有比a[i]小的元素时，我们必然将b[i]元素插到前面，那么就是说，在b[i]原先位置到该插的位置中，所有数都比b[i]大且排在它前面
所以这是b[i]的数目为新插入位置newPos - 原来位置oldPos

那么对于一半的序列又怎么做呢？我们知道，归并排序会继续向下递归，而递归完成返回后将是两组有序的序列，并且拿到局部的逆序数，
所以在Merge函数中添加这一计数操作即可

代码示例如下：

int L[M];
int R[M];

const int Max = 1 <<30;
__int64 change = 0;

void Merge(int *data,int left,int divide,int right)
{
    int lengthL = divide - left;
    int lengthR = right - divide;

    for(int i = 0; i < lengthL; ++i)
    {
        L[i] = data[left + i];
    }
    for(int i = 0; i < lengthR; ++i)
    {
        R[i] = data[divide + i];
    }
    L[lengthL] = R[lengthR] = Max;
    int i = 0;
    int j = 0;
    for(int k = left; k < right; ++k)
    {
        if(L[i] <= R[j])
        {
            data[k] = L[i];
            ++i;
        }
        else
        {
            change += divide - i - left ;
            data[k] = R[j];
            ++j;
        }
    }

}

void MergeSort(int *data,int left,int right)
{
    if(left < right -1)
    {
        int divide = (left + right)/2;
        MergeSort(data,left,divide);
        MergeSort(data,divide,right);
        Merge(data,left,divide,right);
    }
}

3. 树状数组
求逆序数的另外一种方法是使用树状数组
对于小数据，可以直接插入树状数组，对于大数据，则需要离散化，所谓离散化，就是将
100 200 300 400 500 ---> 1 2 3 4 5

这里主要利用树状数组解决计数问题。

首先按顺序把序列a[i]每个数插入到树状数组中，插入的内容是1，表示放了一个数到树状数组中。
然后使用sum操作获取当前比a[i]小的数，那么当前i - sum则表示当前比a[i]大的数，如此反复直到所有数都统计完，
比如
4 3 1 2
i = 1 : 插入 4 : update(4,1)，sum(4)返回1，那么当前比4大的为 i - 1 = 0;
i = 2 : 插入 3 : update(3,1)，sum(3)返回1，那么当前比3大的为 i - 1 = 1;
i = 3 : 插入 1 : update(1,1)，sum(1)返回1，那么当前比1大的为 i - 1 = 2;
i = 4 : 插入 2 : update(2,1)，sum(2)返回2，那么当前比2大的为 i - 2 = 2;

过程很明了，所以逆序数为1+2+2=5

代码示例如下：

//树状数组
__int64 sums[1005];
int len;

inline int lowbit(int t)
{
    return t & (t^(t-1));
}

void update(int _x,int _value)
{
    while(_x <= len)
    {
        sums[_x] += _value;
        _x += lowbit(_x);
    }
}

__int64 sum(int _end)//get sum[1_end]
{
    __int64 ret = 0;
    while(_end > 0)
    {
        ret += sums[_end];
        _end -= lowbit(_end);
    }
    return ret;
}

//求逆序数

__int64 ret = 0;
for (__int64 i = 0; i < k; ++i)
{
    update(a[i],1);
    ret += (i+1) - sum(a[i]);
}

鑫龙 2013-09-20 17:23 发表评论

m进制转换为n进制-任意进制转换算法

鑫龙 — Sat, 08 Jun 2013 08:16:00 GMT

转自:http://www.cnblogs.com/pkuoliver/archive/2010/10/27/Convert-m-number-to-n-number.html

园子里有很多深藏不漏的高手，在这里聊这种基本问题是有点小儿科。不过本人只是想分享下自己的新的，代码，算法有不足之处，还请大家指正，共同进步。

这种题也是一道经典的面试题，主要考察进制转换细想，Coding质量等。

当我们把十进制转成二进制的时候，我们通过辗转相除，取余，逆置余数序列的过程得到新的进制的数。因此我们可以借助这种思想把M进制转成N进制的数。

如下是C的详细的实现方法

void m2n(int m, char* mNum, int n, char* nNum)  
{ 
    int i = 0; 
    char c, *p = nNum; 
  
    //这是一个考察地方，是否能用最少乘法次数。 
    while (*mNum != '\0') 
        i = i*m + *mNum++ - '0'; 
      
    //辗转取余 
    while (i) { 
        *p++ = i % n + '0'; 
        i /= n; 
    } 
    *p-- = '\0'; 
  
    //逆置余数序列 
    while (p > nNum) { 
        c = *p; 
        *p-- = *nNum; 
        *nNum++ = c; 
    } 
}

观察上面的代码，存在着众多的不足。例如，要对输入参数做检查，数值的大小收到int值最大值的限制等。不过好在一点，该算法的时间复杂度是O(n)的。

我们霹雳无敌的赵大叔又提供了一种用Java实现的通用的进制转换方法，即使Windows的计算器也转不了的大数，这个算法也可以转。算和上面的算法相比，他的基本思想不变，还是辗转除，但是用了字符串做大数相除，很不错的创新点，赞一个。代码如下：

package test; 
  
/** 
 * 功能：将一个数从M进制转换成N进制 
 * MValue：M进制数的字符串表示方法 
 * Shang：保存中间运算结果 
 * M：M进制 
 * N：N进制 
 */
public class M2N { 
    // 在这里对输入赋值 
    public static String MValue = "1231412423534674574757"; 
    public static String Shang = null; 
    public static int M = 10; 
    public static int N = 8; 
  
    public static void main(String[] args) { 
        String nValue = ""; 
        Shang = MValue; 
        while(Shang.length() > 0) { 
            nValue = qiuyu(Shang) + nValue; 
        } 
        System.out.println(nValue); 
    } 
  
    /** 
     * 功能：对给定的M进制字符串对n求余。 
     *  
     * @param MTempValue 
     * @param m 
     * @param n 
     * @return 
     */
    public static String qiuyu(String MTempValue) { 
        Shang = ""; 
        int temp = 0; 
        while (MTempValue.length() > 0) { 
            int t = getIntFromStr(MTempValue.substring(0, 1)); 
            MTempValue = MTempValue.substring(1); 
            temp = temp * M + t; 
            Shang += getStrFromInt(temp / N); 
            temp = temp % N; 
        } 
        while(Shang.length() > 0 && Shang.charAt(0) == '0'){ 
            Shang = Shang.substring(1); 
        } 
        return getStrFromInt(temp); 
    } 
  
    public static int getIntFromStr(String str){ 
        return str.charAt(0) <= '9' && str.charAt(0) >= '0'?  
            str.charAt(0) - '0' : str.charAt(0) - 'a' + 10; 
    } 
  
    public static String getStrFromInt(int value){ 
        String result = null; 
        if(value>=0 && value<=9) 
            result = String.valueOf((char)('0' + value)); 
        else if(vlaue > 9 && value <36) 
        { 
            result = String.valueOf((char)('a' + value - 10)); 
        } 
        else
        { 
            result = "-1";// 出错误了 
        } 
        return result; 
    } 
}

赵大叔的算法好了不少，除了参数检查，大小写之外都很好。值得我们借鉴。

鑫龙 2013-06-08 16:16 发表评论

求图两点之间所有路径

鑫龙 — Fri, 07 Jun 2013 08:47:00 GMT

求两定点之间的全部路径，其根本是一个涉及到搜索和回溯的问题。我们设计算法时所关心的首要问题是：按照何种顺序搜索和回溯才能保证路径可以不重不漏地被全部找到。

图的存储结构：邻接矩阵。Arcs

工作结构：结点栈 mystack;

状态保存结构：

（1） VertexStatus[]={0,0,0,1,1,…}。当结点未进栈或者已经出栈，则其对应的状态为0，否则状态为1；

（2） ArcStatus[][]={0,0,1,0,1…..}当且仅当边的两个结点都在栈外时，边的状态才为0，否则为1。

注意我们只所以设计如上结点、边两个状态存储结构，就是依据于path的定义，结点不重复，边不重复。具有边状态存储结构，也是我的算法与其他算法根本上的不同。

不失一般性，我们假设原点的编号最小为0,目标点的编号最大N。我们的问题转换成了，求最小编号的节点与最大编号的节点之间的所有路径。

Paths={}//路径集合

VertexStatus[]={0};//全部置0

ArcStatus[][]={0};////全部置0

mystack.push(0);

VertexStatus[0]=1;

While(!mystack.empty()){

Int elem= mystack.top();//获得栈顶元素

if(elem==N){//找到了一条路径

path=Traverse(mystack);

Paths.add(path);

VertexStatus[elem]=0;

UpdateArcStatus();//更新ArcStatus[][]，使得所有两个端点都不在栈内的边的状态为0

mystack.pop();//移除栈顶元素
}else{

i=0;
For(;i{
if(VertexStatus[i]=0&&ArcStatus[elem][i]=0&&Arcs.contain(elem,i)){

VertexStatus[i]=1;

ArcStatus[elem][i]=1;

Mystack.push(i);//入栈
break;
}
}
if(i=N){//该节点没有符合要求的后续节点

VertexStatus[elem]=0;

UpdateArcStaus();////更新ArcStatus[][]，使得所有两个端点都不在栈内的边的状为0

Mystack.pop();//出栈
}
}
}

鑫龙 2013-06-07 16:47 发表评论

进制数模式

鑫龙 — Thu, 06 Jun 2013 13:57:00 GMT

考虑n位二进制数，有多少个数中不存在两个相邻的1。例如，3位数中有5个数符合这一要求：000、001、010、100、101。

1、试找出其中的规律

2、请给出完整代码实现（参数输入代码可略）

3、试证明你找到的规律是正确的

1、答：规律为2 n/2+2n-n/2-1。

2、代码如下

#include

using namespace std;

int Func(int n) {

if(n<0) { return -1; }

if(n==0) { return 0; }

return pow(2,(n/2))+pow(2,((n-(n/2)))-1;

}

3、证明（构造法）

答：

1列出n位由1组成的2进制数a，111。。。。111；

2奇数位都用0取代得到数b，010。。。。010；

3偶数位也用0取代得到数c，101。。。。101；

4数b和数c中的任何一个1都可以被0取代，或不被取代，而构造出满足要求的数，且每个1的取代具有独立性。

5数b可以构造出2n/2个满足要求的数，同时数c可以构造出2n-n/2个满足要求的数。

6数b和数a都可以构造出全由0组成二进制数，因此统计存在一个重复。

7规律为2 n/2+2n-n/2-1；

-------------------------------------------------------------------------------------------------
n位的二进制,比如3位:000 001 010 100 101
什么规律呢，假设n位二进制有f(n)种不相邻的组合，
从最左边的位置开始放，可以放0，也可以放1。
如果最左边放0，那么将不影响第二位的放置，从第二位放起，即有f(n-1)种。
如果最左边放1，那么第二位则只能放0，从第三位放起，即有f(n-2)种。
所以f(n)=f(n-1)+f(n-2)种。
另外f(1)=2(因为可以放0或者1),f(2)=3(因为可以是00,01,10)。

鑫龙 2013-06-06 21:57 发表评论

图的一个题

鑫龙 — Sun, 26 May 2013 02:40:00 GMT

题目：一个单入口单出口的有向无环图中，要求在某些地方插入一些节点使得任何一条由起点到终点所经历的节点数相同，类似于下面的图，要求给出算法描述并分析时间复杂度。

如上图所示，节点A到C有两条路径，ABC这条路径经过了一个节点，而AC路径经过了0个节点，我们的算法所要做的事就是要在AC路径中间加入一个节点，然后ABC路径和ADC路径都经过了一个节点。

算法是这样的：对于每个节点维护一组信息，包括节点的层数（起始节点到该节点的路径长度，起始节点设为0）以及生成该长度的父节点，相对于右图，节点6维护的不经处理的信息就是：层数2来自节点3和节点4；节点7维护的不经处理的信息就是：层数3来自节点5和节点6以及层数2来自节点4；节点8的不经处理的信息是：层数4来自节点7，层数3来自节点7，层数2来自节点4。我们算法所要做的事就是最终使每个节点需要维护的层信息变为一个，即无论从那条路径到该节点，该节点所处的层数都是固定的。算法如下：
1、初始化起始节点的层数信息
2、从起始节点开始遍历每条路径，遇到每个节点生成一个维护信息
（1）如果此节点不存在维护信息，创建之；
（2）如果该节点存在维护信息，有两种情况：
（a）如果生成的维护信息的层数和原来已有的维护信息的层数是相同的，则合并这两个维护信息，比如对于例子中的图，节点5原来的维护信息为“层数3来自节点2”，然后从节点3到节点5生成的维护信息为“层数3来自节点3”，由于层数相同，我们可以将其合并为“层数3来自节点2和节点3”；
（b）如果生成的维护信息的层数和原来节点的维护信息的层数不一致，我们需要比较那一个的层数较大：
a.如果原来维护信息的层数较大，此时，我们只需要在生成此维护信息的节点与此节点之间插入一个新的节点，然后生成新节点的维护信息，然后从新节点开始（2）过程
b.如果新生成的维护信息的层数较大，将新生成的节点信息存入此节点，然后我们需要在生成原来维护信息的所有节点和此节点之间插入新节点，并且需要从所有的新插入节点开始（2）过程

鑫龙 2013-05-26 10:40 发表评论

已知一个函数rand7()能够生成1-7的随机数，请给出一个函数rand10()，该函数能够生成1-10的随机数。

鑫龙 — Mon, 20 May 2013 14:55:00 GMT

题目：

已知一个函数rand7()能够生成1-7的随机数，请给出一个函数，该函数能够生成1-10的随机数。

思路：

假如已知一个函数能够生成1-49的随机数，那么如何以此生成1-10的随机数呢？

解法：

该解法基于一种叫做拒绝采样的方法。主要思想是只要产生一个目标范围内的随机数，则直接返回。如果产生的随机数不在目标范围内，则丢弃该值，重新取样。由于目标范围内的数字被选中的概率相等，这样一个均匀的分布生成了。

显然rand7至少需要执行2次，否则产生不了1-10的数字。通过运行rand7两次，可以生成1-49的整数，

   1  2  3  4  5  6  7 1  1  2  3  4  5  6  7 2  8  9 10  1  2  3  4 3  5  6  7  8  9 10  1 4  2  3  4  5  6  7  8 5  9 10  1  2  3  4  5 6  6  7  8  9 10  *  * 7  *  *  *  *  *  *  *

由于49不是10的倍数，所以我们需要丢弃一些值，我们想要的数字范围为1-40，不在此范围则丢弃并重新取样。

代码：

[cpp] view plain copy

int rand10() {
int row, col, idx;
do {
row = rand7();
col = rand7();
idx = col + (row-1)*7;
} while (idx > 40);
return 1 + (idx-1)%10;
}

由于row范围为1-7，col范围为1-7，这样idx值范围为1-49。大于40的值被丢弃，这样剩下1-40范围内的数字，通过取模返回。下面计算一下得到一个满足1-40范围的数需要进行取样的次数的期望值：

E(# calls to rand7) = 2 * (40/49) +                       4 * (9/49) * (40/49) +                       6 * (9/49)² * (40/49) +                       ...                        _∞                     = ∑ 2k * (9/49)^k-1 * (40/49)                       k=1                      = (80/49) / (1 - 9/49)²                     = 2.45

优化：

上面的方法大概需要2.45次调用rand7函数才能得到1个1-10范围的数，下面可以进行再度优化。

对于大于40的数，我们不必马上丢弃，可以对41-49的数减去40可得到1-9的随机数，而rand7可生成1-7的随机数，这样可以生成1-63的随机数。对于1-60我们可以直接返回，而61-63则丢弃，这样需要丢弃的数只有3个，相比前面的9个，效率有所提高。而对于61-63的数，减去60后为1-3，rand7产生1-7，这样可以再度利用产生1-21的数，对于1-20我们则直接返回，对于21则丢弃。这时，丢弃的数就只有1个了，优化又进一步。当然这里面对rand7的调用次数也是增加了的。代码如下：

[cpp] view plain copy

int rand10Imp() {
int a, b, idx;
while (true) {
a = rand7();
b = rand7();
idx = b + (a-1)*7;
if (idx <= 40)
return 1 + (idx-1)%10;
a = idx-40;
b = rand7();
// get uniform dist from 1 - 63
idx = b + (a-1)*7;
if (idx <= 60)
return 1 + (idx-1)%10;
a = idx-60;
b = rand7();
// get uniform dist from 1-21
idx = b + (a-1)*7;
if (idx <= 20)
return 1 + (idx-1)%10;
}
}

下面计算下优化后方法的调用rand7函数的期望次数：

E(# calls to rand7) = 2 * (40/49) +                       3 * (9/49) * (60/63) +                       4 * (9/49) * (3/63) * (20/21) +                         (9/49) * (3/63) * (1/21) *                       [ 6 * (40/49) +                         7 * (9/49) * (60/63) +                         8 * (9/49) * (3/63) * (20/21) ] +                        ((9/49) * (3/63) * (1/21))² *                       [ 10 * (40/49) +                         11 * (9/49) * (60/63) +                         12 * (9/49) * (3/63) * (20/21) ] +                       ...                      = 2.2123

这里期望次数为2.21，比起未优化的2.45次减少了大概10%。

鑫龙 2013-05-20 22:55 发表评论

二叉树的非递归遍历

鑫龙 — Fri, 03 May 2013 11:51:00 GMT

摘要: 转自：http://www.cnblogs.com/dolphin0520/archive/2011/08/25/2153720.html ... 阅读全文

鑫龙 2013-05-03 19:51 发表评论

Skip List（跳跃表）原理详解与实现

鑫龙 — Sat, 06 Apr 2013 11:55:00 GMT

摘要: 本文内容框架： §1 Skip List 介绍 §2 Skip List 定义以及构造步骤 §3 Skip List 完整实现 §4 Skip List 概率分析 §5 小结 §1 Skip List 介绍 Skip List是一种随机化的数据结构，基于并联的链表，其效率可... 阅读全文

鑫龙 2013-04-06 19:55 发表评论

最长上升子序列 O(nlogn)解法 (转)

鑫龙 — Fri, 30 Nov 2012 09:44:00 GMT

最近在做单调队列，发现了最长上升子序列O(nlogn)的求法也有利用单调队列的思想。

最长递增子序列问题：在一列数中寻找一些数，这些数满足：任意两个数a[i]和a[j]，若i

设dp[i]表示以i为结尾的最长递增子序列的长度，则状态转移方程为：

dp[i] = max{dp[j]+1}, 1<=j

这样简单的复杂度为O(n^2)，其实还有更好的方法。

考虑两个数a[x]和a[y]，x

按dp[t]=k来分类，只需保留dp[t]=k的所有a[t]中的最小值，设d[k]记录这个值，d[k]=min{a[t],dp[t]=k}。

这时注意到d的两个特点（重要）：

1. d[k]在计算过程中单调不升；

2. d数组是有序的，d[1]

利用这两个性质，可以很方便的求解：

1. 设当前已求出的最长上升子序列的长度为len（初始时为1），每次读入一个新元素x：

2. 若x>d[len]，则直接加入到d的末尾，且len++；（利用性质2）

否则，在d中二分查找，找到第一个比x小的数d[k]，并d[k+1]=x，在这里x<=d[k+1]一定成立（性质1,2）。

/** 
最长递增子序列O(nlogn)算法： 
状态转移方程：f[i] = max{f[i],f[j]+1},1<=j 
分析：加入x=f[y],则x相对于y更有潜力。 
首先根据f[]值分类，记录满足f[t]=k的最小的值a[t],记d[k]=min{a[t]},f[t]=k. 
    1.发现d[k]在计算过程中单调不上升 
    2.d[1] 
解法： 
1. 设当前最长递增子序列为len,考虑元素a[i]; 
2. 若d[len] 
   否则,在d[0-len]中二分查找,找到第一个比它小的元素d[k],并d[k+1]=a[i].() 
*/  
#include   
#include   
#include   
using namespace std;  
const int N = 41000;  
int a[N];       //a[i] 原始数据  
int d[N];       //d[i] 长度为i的递增子序列的最小值  
  
int BinSearch(int key, int* d, int low, int high)  
{  
    while(low<=high)  
    {  
        int mid = (low+high)>>1;  
        if(key>d[mid] && key<=d[mid+1])  
            return mid;  
        else if(key>d[mid])  
            low = mid+1;  
        else  
            high = mid-1;  
    }  
    return 0;  
}  
  
int LIS(int* a, int n, int* d)  
{  
    int i,j;  
    d[1] = a[1];  
    int len = 1;        //递增子序列长度  
    for(i = 2; i <= n; i++)  
    {  
        if(d[len]
            j = ++len;  
        else  
            j = BinSearch(a[i],d,1,len) + 1;  
        d[j] = a[i];  
    }  
    return len;  
}  
  
int main()  
{  
    int t;  
    int p;  
    scanf("%d",&t);  
    while(t--)  
    {  
        scanf("%d",&p);  
        for(int i = 1; i <= p; i++)  
            scanf("%d",&a[i]);  
        printf("%d\n",LIS(a,p,d));  
    }  
    return 0;  
}  

鑫龙 2012-11-30 17:44 发表评论

POJ题目分类(转)

鑫龙 — Mon, 26 Nov 2012 05:00:00 GMT

转贴 ACM的算法（觉得很好，有层次感）
OJ上的一些水题(可用来练手和增加自信)
(poj3299,poj2159,poj2739,poj1083,poj2262,poj1503,poj3006,poj2255,poj3094)

初期:

一.基本算法:
     (1)枚举. (poj1753,poj2965)
     (2)贪心(poj1328,poj2109,poj2586)
     (3)递归和分治法.
     (4)递推.
     (5)构造法.(poj3295)
     (6)模拟法.(poj1068,poj2632,poj1573,poj2993,poj2996)
二.图算法:
     (1)图的深度优先遍历和广度优先遍历.
     (2)最短路径算法(dijkstra,bellman-ford,floyd,heap+dijkstra)
        (poj1860,poj3259,poj1062,poj2253,poj1125,poj2240)
     (3)最小生成树算法(prim,kruskal)
        (poj1789,poj2485,poj1258,poj3026)
     (4)拓扑排序 (poj1094)
     (5)二分图的最大匹配 (匈牙利算法) (poj3041,poj3020)
     (6)最大流的增广路算法(KM算法). (poj1459,poj3436)
三.数据结构.
     (1)串 (poj1035,poj3080,poj1936)
     (2)排序(快排、归并排(与逆序数有关)、堆排) (poj2388,poj2299)
     (3)简单并查集的应用.
     (4)哈希表和二分查找等高效查找法(数的Hash,串的Hash)
        (poj3349,poj3274,POJ2151,poj1840,poj2002,poj2503)
     (5)哈夫曼树(poj3253)
     (6)堆
     (7)trie树(静态建树、动态建树) (poj2513)
四.简单搜索
     (1)深度优先搜索 (poj2488,poj3083,poj3009,poj1321,poj2251)
     (2)广度优先搜索(poj3278,poj1426,poj3126,poj3087.poj3414)
     (3)简单搜索技巧和剪枝(poj2531,poj1416,poj2676,1129)
五.动态规划
     (1)背包问题. (poj1837,poj1276)
     (2)型如下表的简单DP(可参考lrj的书 page149):
       1.E[j]=opt{D+w(i,j)} (poj3267,poj1836,poj1260,poj2533)
       2.E[i,j]=opt{D[i-1,j]+xi,D[i,j-1]+yj,D[i-1][j-1]+zij} (最长公共子序列)

         (poj3176,poj1080,poj1159)
       3.C[i,j]=w[i,j]+opt{C[i,k-1]+C[k,j]}.(最优二分检索树问题)
六.数学
     (1)组合数学:
        1.加法原理和乘法原理.
        2.排列组合.
        3.递推关系.
          (POJ3252,poj1850,poj1019,poj1942)
     (2)数论.
        1.素数与整除问题
        2.进制位.
        3.同余模运算.
          (poj2635, poj3292,poj1845,poj2115)
     (3)计算方法.
        1.二分法求解单调函数相关知识.(poj3273,poj3258,poj1905,poj3122)
七.计算几何学.
     (1)几何公式.
     (2)叉积和点积的运用(如线段相交的判定,点到线段的距离等). (poj2031,poj1039)

     (3)多边型的简单算法(求面积)和相关判定(点在多边型内,多边型是否相交)
         (poj1408,poj1584)
     (4)凸包. (poj2187,poj1113)

中级:

一.基本算法:
     (1)C++的标准模版库的应用. (poj3096,poj3007)
     (2)较为复杂的模拟题的训练(poj3393,poj1472,poj3371,poj1027,poj2706)
二.图算法:
     (1)差分约束系统的建立和求解. (poj1201,poj2983)
     (2)最小费用最大流(poj2516,poj2195)
     (3)双连通分量(poj2942)
     (4)强连通分支及其缩点.(poj2186)
     (5)图的割边和割点(poj3352)
     (6)最小割模型、网络流规约(poj3308, )
三.数据结构.
     (1)线段树. (poj2528,poj2828,poj2777,poj2886,poj2750)
     (2)静态二叉检索树. (poj2482,poj2352)
     (3)树状树组(poj1195,poj3321)
     (4)RMQ. (poj3264,poj3368)
     (5)并查集的高级应用. (poj1703,2492)
     (6)KMP算法. (poj1961,poj2406)
四.搜索
     (1)最优化剪枝和可行性剪枝
     (2)搜索的技巧和优化 (poj3411,poj1724)
     (3)记忆化搜索(poj3373,poj1691)

五.动态规划
     (1)较为复杂的动态规划(如动态规划解特别的施行商问题等)
         (poj1191,poj1054,poj3280,poj2029,poj2948,poj1925,poj3034)
     (2)记录状态的动态规划. (POJ3254,poj2411,poj1185)
     (3)树型动态规划(poj2057,poj1947,poj2486,poj3140)
六.数学
     (1)组合数学:
        1.容斥原理.
        2.抽屉原理.
        3.置换群与Polya定理(poj1286,poj2409,poj3270,poj1026).
        4.递推关系和母函数.

     (2)数学.
        1.高斯消元法(poj2947,poj1487, poj2065,poj1166,poj1222)
        2.概率问题. (poj3071,poj3440)
        3.GCD、扩展的欧几里德(中国剩余定理) (poj3101)
     (3)计算方法.
        1.0/1分数规划. (poj2976)
        2.三分法求解单峰(单谷)的极值.
        3.矩阵法(poj3150,poj3422,poj3070)
        4.迭代逼近(poj3301)
     (4)随机化算法(poj3318,poj2454)
     (5)杂题.
         (poj1870,poj3296,poj3286,poj1095)
七.计算几何学.
        (1)坐标离散化.
        (2)扫描线算法(例如求矩形的面积和周长并,常和线段树或堆一起使用).
            (poj1765,poj1177,poj1151,poj3277,poj2280,poj3004)
        (3)多边形的内核(半平面交)(poj3130,poj3335)
        (4)几何工具的综合应用.(poj1819,poj1066,poj2043,poj3227,poj2165,poj3429
)

高级:
一.基本算法要求:
      (1)代码快速写成,精简但不失风格
          (poj2525,poj1684,poj1421,poj1048,poj2050,poj3306)
      (2)保证正确性和高效性. poj3434
二.图算法:
      (1)度限制最小生成树和第K最短路. (poj1639)
      (2)最短路,最小生成树,二分图,最大流问题的相关理论(主要是模型建立和求解)

         (poj3155, poj2112,poj1966,poj3281,poj1087,poj2289,poj3216,poj2446
      (3)最优比率生成树. (poj2728)
      (4)最小树形图(poj3164)
      (5)次小生成树.
      (6)无向图、有向图的最小环
三.数据结构.
      (1)trie图的建立和应用. (poj2778)
      (2)LCA和RMQ问题(LCA(最近公共祖先问题) 有离线算法(并查集+dfs) 和在线算法

          (RMQ+dfs)).(poj1330)
      (3)双端队列和它的应用(维护一个单调的队列,常常在动态规划中起到优化状态转移
的
          目的). (poj2823)
      (4)左偏树(可合并堆).
      (5)后缀树(非常有用的数据结构,也是赛区考题的热点).
         (poj3415,poj3294)
四.搜索
      (1)较麻烦的搜索题目训练(poj1069,poj3322,poj1475,poj1924,poj2049,poj3426)

      (2)广搜的状态优化:利用M进制数存储状态、转化为串用hash表判重、按位压缩存储
状态、双向广搜、A*算法. (poj1768,poj1184,poj1872,poj1324,poj2046,poj1482)
      (3)深搜的优化:尽量用位运算、一定要加剪枝、函数参数尽可能少、层数不易过大
、可以考虑双向搜索或者是轮换搜索、IDA*算法. (poj3131,poj2870,poj2286)
五.动态规划
      (1)需要用数据结构优化的动态规划.
         (poj2754,poj3378,poj3017)
      (2)四边形不等式理论.
      (3)较难的状态DP(poj3133)
六.数学
      (1)组合数学.
        1.MoBius反演(poj2888,poj2154)
        2.偏序关系理论.
      (2)博奕论.
        1.极大极小过程(poj3317,poj1085)
        2.Nim问题.
七.计算几何学.
      (1)半平面求交(poj3384,poj2540)
      (2)可视图的建立(poj2966)
      (3)点集最小圆覆盖.
      (4)对踵点(poj2079)
      八.综合题.
      (poj3109,poj1478,poj1462,poj2729,poj2048,poj3336,poj3315,poj2148,poj1263
)

鑫龙 2012-11-26 13:00 发表评论

最小堆&&最大堆的实现(c++)(转)

鑫龙 — Mon, 19 Nov 2012 13:09:00 GMT

摘要: 最小堆：Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->templateclass MinHeap {public: MinHeap(int&nb... 阅读全文

鑫龙 2012-11-19 21:09 发表评论

全排列算法及其C++实现(转)

鑫龙 — Mon, 05 Nov 2012 13:01:00 GMT

第十六章、全排列问题

53.字符串的排列。
题目：输入一个字符串，打印出该字符串中字符的所有排列。
例如输入字符串abc，则输出由字符a、b、c 所能排列出来的所有字符串
abc、acb、bac、bca、cab 和cba。

分析：此题最初整理于去年的微软面试100题中第53题，第二次整理于微软、Google等公司非常好的面试题及解答[第61-70题] 第67题。无独有偶，这个问题今年又出现于今年的2011.10.09百度笔试题中。ok，接下来，咱们先好好分析这个问题。

一、递归实现
从集合中依次选出每一个元素，作为排列的第一个元素，然后对剩余的元素进行全排列，如此递归处理，从而得到所有元素的全排列。以对字符串abc进行全排列为例，我们可以这么做：以abc为例
固定a，求后面bc的排列：abc，acb，求好后，a和b交换，得到bac
固定b，求后面ac的排列：bac，bca，求好后，c放到第一位置，得到cba
固定c，求后面ba的排列：cba，cab。代码可如下编写所示：

template <typename T>
void CalcAllPermutation_R(T perm[], int first, int num)
{
if (num <= 1) {
return;
}
for (int i = first; i < first + num; ++i) {
swap(perm[i], perm[first]);
CalcAllPermutation_R(perm, first + 1, num - 1);
swap(perm[i], perm[first]);
}
}

或者如此编写，亦可：

void Permutation(char* pStr, char* pBegin);
void Permutation(char* pStr)
{
Permutation(pStr, pStr);
}
void Permutation(char* pStr, char* pBegin)
{
if(!pStr || !pBegin)
return;
if(*pBegin == '\0')
{
printf("%s\n", pStr);
}
else
{
for(char* pCh = pBegin; *pCh != '\0'; ++ pCh)
{
// swap pCh and pBegin
char temp = *pCh;
*pCh = *pBegin;
*pBegin = temp;
Permutation(pStr, pBegin + 1);
// restore pCh and pBegin
temp = *pCh;
*pCh = *pBegin;
*pBegin = temp;
}
}
}

二、字典序排列
把升序的排列（当然，也可以实现为降序）作为当前排列开始，然后依次计算当前排列的下一个字典序排列。
对当前排列从后向前扫描，找到一对为升序的相邻元素，记为i和j（i < j）。如果不存在这样一对为升序的相邻元素，则所有排列均已找到，算法结束；否则，重新对当前排列从后向前扫描，找到第一个大于i的元素k，交换i和k，然后对从j开始到结束的子序列反转，则此时得到的新排列就为下一个字典序排列。这种方式实现得到的所有排列是按字典序有序的，这也是C++ STL算法next_permutation的思想。算法实现如下：

template <typename T>
void CalcAllPermutation(T perm[], int num)
{
if (num < 1)
return;
while (true) {
int i;
for (i = num - 2; i >= 0; --i) {
if (perm[i] < perm[i + 1])
break;
}
if (i < 0)
break; // 已经找到所有排列
int k;
for (k = num - 1; k > i; --k) {
if (perm[k] > perm[i])
break;
}
swap(perm[i], perm[k]);
reverse(perm + i + 1, perm + num);
}
}

扩展：如果不是求字符的所有排列，而是求字符的所有组合，应该怎么办呢？当输入的字符串中含有相同的字符串时，相同的字符交换位置是不同的排列，但是同一个组合。举个例子，如果输入abc，它的组合有a、b、c、ab、ac、bc、abc

转自 http://blog.csdn.net/v_july_v/article/details/6879101

鑫龙 2012-11-05 21:01 发表评论

红黑树（转）

鑫龙 — Tue, 18 Sep 2012 12:32:00 GMT

红黑树的平衡

红黑树首先是一棵二叉查找树，它每个结点都被标上了颜色（红色或黑色），红黑树满足以下5个性质：

1、 每个结点的颜色只能是红色或黑色。

2、 根结点是黑色的。

3、 每个叶子结点都带有两个空的黑色结点（被称为黑哨兵），如果一个结点n的只有一个左孩子，那么n的右孩子是一个黑哨兵；如果结点n只有一个右孩子，那么n的左孩子是一个黑哨兵。

4、 如果一个结点是红的，则它的两个儿子都是黑的。也就是说在一条路径上不能出现相邻的两个红色结点。

5、 对于每个结点来说，从该结点到其子孙叶结点的所有路径上包含相同数目的黑结点。

红黑树的这5个性质中，第3点是比较难理解的，但它却非常有必要。我们看图1中的左边这张图，如果不使用黑哨兵，它完全满足红黑树性质，结点50到两个叶结点8和叶结点82路径上的黑色结点数都为2个。但如果加入黑哨兵后（如图1右图中的小黑圆点），叶结点的个数变为8个黑哨兵，根结点50到这8个叶结点路径上的黑高度就不一样了，所以它并不是一棵红黑树。

要看真正的红黑树请在以上动画中添加几个结点，看看是否满足以上性质。

红黑树的旋转操作

红黑树的旋转操作和AVL树一样，分为LL、RR、LR、RL四种旋转类型，差别在于旋转完成后改变的是结点的颜色，而不是平衡因子。旋转动画演示请参考AVL这篇文章中的Flash动画：

http://www.cnblogs.com/abatei/archive/2008/11/17/1335031.html

红黑树上结点的插入

在讨论红黑树的插入操作之前必须要明白，任何一个即将插入的新结点的初始颜色都为红色。这一点很容易理解，因为插入黑点会增加某条路径上黑结点的数目，从而导致整棵树黑高度的不平衡。但如果新结点父结点为红色时（如图2所示），将会违返红黑树性质：一条路径上不能出现相邻的两个红色结点。这时就需要通过一系列操作来使红黑树保持平衡。

为了清楚地表示插入操作以下在结点中使用“新”字表示一个新插入的结点；使用“父”字表示新插入点的父结点；使用“叔”字表示“父”结点的兄弟结点；使用“祖”字表示“父”结点的父结点。插入操作分为以下几种情况：

1、黑父

如图3所示，如果新点的父结点为黑色结点，那么插入一个红点将不会影响红黑树的平衡，此时插入操作完成。红黑树比AVL树优秀的地方之一在于黑父的情况比较常见，从而使红黑树需要旋转的几率相对AVL树来说会少一些。

2．红父

如果新点的父结点为红色，这时就需要进行一系列操作以保证整棵树红黑性质。如图3所示，由于父结点为红色，此时可以判定，祖父结点必定为黑色。这时需要根据叔父结点的颜色来决定做什么样的操作。青色结点表示颜色未知。由于有可能需要根结点到新点的路径上进行多次旋转操作，而每次进行不平衡判断的起始点（我们可将其视为新点）都不一样。所以我们在此使用一个蓝色箭头指向这个起始点，并称之为判定点。

2.1 红叔

当叔父结点为红色时，如图4所示，无需进行旋转操作，只要将父和叔结点变为黑色，将祖父结点变为红色即可。但由于祖父结点的父结点有可能为红色，从而违反红黑树性质。此时必须将祖父结点作为新的判定点继续向上进行平衡操作。

需要注意，无论“父”在“叔”的左边还是右边，无论“新”是“父”的左孩子还是右孩子，它们的操作都完全一样。

2.2 黑叔

当叔父结点为黑色时，需要进行旋转，以下图示了所有的旋转可能

情形1：

情形2：

情形3：

情形4：

可以观察到，当旋转完成后，新的旋转根全部为黑色，此时不需要再向上回溯进行平衡操作，插入操作完成。需要注意，上面四张图的“叔”、“1”、“2”、“3”结点有可能为黑哨兵结点。

其实红黑树的插入操作不是很难，甚至比AVL树的插入操作还更简单些。但删除操作就远远比AVL树复杂得多，下面就介绍红黑树的删除操作。

红黑树上结点的删除

红黑树本身是一棵二叉查找树，它的删除和二叉查找树的删除类似。首先要找到真正的删除点，当被删除结点n存在左右孩子时，真正的删除点应该是n的中序遍在前驱，关于这一点请复习二叉查找树的删除。如图9所示，当删除结点20时，实际被删除的结点应该为18，结点20的数据变为18。

所以可以推断出，在进行删除操作时，真正的删除点必定是只有一个孩子或没有孩子的结点。而根据红黑树的性质可以得出以下两个结论：

1、 删除操作中真正被删除的必定是只有一个红色孩子或没有孩子的结点。

2、 如果真正的删除点是一个红色结点，那么它必定是一个叶子结点。

理解这两点非常重要，如图10所示，除了情况(a)外，其他任一种况结点N都无法满足红黑树性质。

在以下讨论中，我们使用蓝色箭头表示真正的删除点，它也是旋转操作过程中的第一个判定点；真正的删除点使用“旧”标注，旧点所在位置将被它的的孩子结点所取代（最多只有一个孩子），我们使用“新”表示旧点的孩子结点。删除操作可分为以下几种情形：

1、旧点为红色结点

若旧点为红色结点，则它必定是叶子结点，直接删除即可。如图11所示

2、一红一黑

当旧点为黑色结点，新点为红色结点时，将新点取代旧点位置后，将新点染成黑色即可（如图12所示）。这里需要注意：旧点为红色，新点为黑色的情况不可能存在。

3、双黑

当旧点和新点都为黑色时（新点为空结点时，亦属于这种情况），情况比较复杂，需要根据旧点兄弟结点的颜色来决定进行什么样的操作。我们使用“兄”来表示旧点的兄弟结点。这里可分为红兄和黑兄两种情况：

3.1 红兄

由于兄弟结点为红色，所以父结点必定为黑色，而旧点被删除后，新点取代了它的位置。下图演示了两种可能的情况：

红兄的情况需要进行RR或LL型旋转，然后将父结点染成红色，兄结点染成黑色。然后重新以新点为判定点进行平衡操作。我们可以观察到，旋转操作完成后，判定点没有向上回溯，而是降低了一层，此时变成了黑兄的情况。

3.2 黑兄

黑兄的情况最为复杂，需要根据黑兄孩子结点（这里用“侄”表示）和父亲结点的颜色来决定做什么样的操作。

3.2.1 黑兄二黑侄红父

如图14所示，这种情况比较简单，只需将父结点变为黑色，兄结点变为黑色，新结点变为黑色即可，删除操作到此结束。

3.2.2 黑兄二黑侄黑父

如图15所示，此时将父结点染成新结点的颜色，新结点染成黑色，兄结点染成红色即可。当新结点为红色时，父结点被染成红色，此时需要以父结点为判定点继续向上进行平衡操作。

3.2.3 黑兄红侄

黑兄红侄有以下四种情形，下面分别进行图示：

情形1：

情形2：

情形3：

情形4：

由以上图例所示，看完以上四张图的兄弟有可能会有一个疑问，如果情形1和情形2中的两个侄子结点都为红色时，是该进行LL旋转还是进行LR旋转呢？答案是进行LL旋转。情形3和情形4则是优先进行RR旋转的判定。

红黑树的代码实现

鑫龙 2012-09-18 20:32 发表评论