常见算法题

一、维护O(1)时间查找最大元素的栈

问题描述：一个栈stack，具有push和pop操作，其时间复杂度皆为O(1)。设计算法max操作，

求栈中的最大值，该操作的时间复杂度也要求为O(1)。

可以修改栈的存储方式，push，pop的操作，但是要保证O(1)的时间复杂度，空间时间复杂

度无要求。

 

可以创建一个类，类里有两个栈，一个栈S维持正常的push、pop操作，另一个Sm保存当前的最大值

假设元素以5,4,1,2,3,10,9,8,6,7,15顺序入栈，则两个栈中存储的元素如下图所示：

S    5    4    1    2    3    10    9    8    6    7    15

Sm 5    10  15

struct max_stack{
    stack<int> s1;
    stack<int> sm;
};
max_stack s;
void my_push(int k) {
    if(!s.s1.empty()){
        if(k>s.sm.top()) s.sm.push(k);
        s.s1.push(k);
    } else {
        s.s1.push(k);   s.sm.push(k);
    }
}
void my_pop() {
    if(!s.s1.empty()) {
        if(s.s1.top()==s.sm.top())  s.sm.pop();
        s.s1.pop();
    }
}
int my_max() {
    if(!s.s1.empty()) {
        return s.sm.top();
    }
}

二、约瑟夫环问题

瑟夫环问题的原来描述为，设有编号为1，2，……，n的n(n>0)个人围成一个圈，从第1个人

开始报数，报到m时停止报数，报m的人出圈，再从他的下一个人起重新报数，报到m时停止

报数，报m的出圈，……，如此下去，直到所有人全部出圈为止。当任意给定n和m后，设计

算法求n个人出圈的次序。换一种表述如下

问题描述：n个人（编号0~(n-1))，从0开始报数，报到(m-1)的退出，剩下的人继续从0开始

报数。求胜利者的编号。

具体数学上给出通项公式：

f(0)=0       

f(n)=(f(n-1)+m)%n    ,    (n>1)

int joseph(int n,int m) {
    int *f=new int[n+1];
    f[0]=f[1]=0;
    for(int i=2;i<n+1;i++) 
        f[i]=(f[i-1]+m)%i;
    int result=f[n];
    delete []f;
    return result;
}

如果求解原表述的解，只需要将result加1即可。

三、寻找明星

问题描述：有个聚会有N人参加，其中N-1个是群众。1个是明星。其中所有群众都认识明星，

明星不认识任何群众，群众之前是否认识不知道。

假设有个机器人能问问题A是否认识B？时间复杂度为O（1），那么设计一个算法用最小的复

杂度找出明星。

从问题的描述中可以知道，对于任意两个人A、B，如果A认识B那么A一定不是明星；如果A不

认识B，那么B一定不是明星。将所有人存储在数组中，每次比较询问A[0]是否认识A[1]，将一

定不是明星的人放在数组的最后，并且在以后可以不用管了。代码描述如下

int famous(int A[],int n) {
    int j=n;
    while(j>1) {
        if(A[0] knows A[1]) 
            swap(A[0],A[1]);
        swap(A[1],A[--j]);
    }
    return A[0];
}

由于询问和交换的时间复杂度是O(1),while循环进行了n-1次，所以时间复杂度是O(n).

四、最小交流次数

问题描述：有n个战士其中n>4他们手中都有不同的情报，假设每个人通过交流能过得双方所有

的情报。设计一个算法使得用最少的交流次数使得所有的战士都获得全部的情报，给出算法并

给出最小交流次数？

 

可以建立递推式:

                       f(4)=4

                       f(n)=f(n-1)+2  ,  n>4

假设在战士人数是n-1时需要f(n-1)次交流，则增加一个人时，如下步骤进行：

1、第n个战士和前面任意一个战士交流一次

2、前n-1个战士互相交流，使得前面n-1个战士都有所有战士获得的情报

3、第n个战士和前面任意一个战士交流一次。

这样n个战士都有所有情报了。

五、数星星

问题描述：A和B晚上无聊就开始数星星。每次只能数K个（20<=k<=30）A和B轮流数。最后

谁把星星数完谁就获胜，那么当星星数量为多少时候A必胜？

这是一个博弈的问题，我们可以从胜利条件出发，A必胜，那么最后一次是A数，并且剩下星星

的个数 20<=k<=30 ，那么如何保证呢？最后50颗由B先数，B数m颗，然后A数剩下的50-m

颗。好了，那么第一次A数的话必须保证，第一次A数完之后，剩下的个数是50的倍数。所以

案就明了了,星星的数量应满足    

50k+20 <= N <=50K+30    ,    k是整数

六、求连续子数组的最大和

这是一个动态规划问题递推式为

M(i)=max{M(i-1)+a(i),a(i)},i>0

int max_sub_sum(int *A,int n) {
    int thissum=0,maxsum=0;
    for(int i=0;i<n;i++) {
        thissum+=A[i];
        if(thissum>maxsum)    maxsum=thissum;
        if(thisum<0)          thisum=0;
    }
    return maxsum;
}

七、二分查找

用二分法查找已排序的大小为n的数组A是否存在value，如果存在返回下标，否则返回-1。

int b_search(int *A,int n,int value) {
    int low=0,high=n-1;
    while(low<=high) {
        int mid=(low+high)/2;
        if(A[mid]==value)        return mid;
        else if(A[mid]>value)    high=mid-1;
        else                     low=mid+1;
    }
    return -1;
}