一个判断连续数存在性的算法

  从0~13中任取出7个数，然后判断这7个数中是否存在连续的5个数， 规则如下：

1) 7个数可以是重复的数.
2) 0可以表示任意数
例子如下：
0, 1, 4, 3, 8, 0, 13--->true: 1-2-3-4-5
0, 1, 1, 1, 9, 10, 0--->false
0, 1, 3, 9, 10, 11, 12->true: 9-10-11-12-13
0, 0, 0, 0, 0, 0, 0->true: 0-1-2-3-4

这是最近看到的一个算法题， 粗粗一看，觉得很简单， 可是慢慢往里面想，觉得要考虑的还是挺多的。现在把它实现出来放在这里，当然，加了几个参数使其更加通用。希望对大家有些参考价值。写的不明白的地方，有错误的地方大家可以指出来；大家如果有好的思路的话也希望能写下来共享一下。以下是代码与注释：

#include <stdio.h>
#include <iostream>
using namespace std;

/*
从0~13中任取出7个数，然后判断这7个数中是否存在连续的5个数， 规则如下：
1) 7个数可以是重复的数.
2) 0可以表示任意数
例子如下：
0, 1, 4, 3, 8, 0, 13--->true: 1-2-3-4-5
0, 1, 1, 1, 9, 10, 0--->false
0, 1, 3, 9, 10, 11, 12->true: 9-10-11-12-13 
0, 0, 0, 0, 0, 0, 0->true: 0-1-2-3-4
*/


// Helper functions
void outputarray(int a[], int n)
{
    for(int i = 0; i < n; ++i) cout<<a[i]<<" ";
    cout<<endl;
}

void outputresult(int nstart, int m)
{
    cout<<"Continuous Array:";
    while(m--)    cout<<nstart++<<" ";
    cout<<endl;
}

// Return if the n elements array contains m continuous numbers, the elements must large than 0
// this is a common implementation
bool Is_n_Contains_m_ContinuousNum(int a[], int n, int m) 
{
    // step 1: get num of 0
    int nZeroNum = 0;
    for(int i = 0; i < n; ++i)
        if(0 == a[i]) ++nZeroNum;

    cout<<"Original Array:  "; outputarray(a, n);

    // step 2: if we have enough 0, get continuous num is easy.
    if(nZeroNum >= m-1)
    {
        int min = a[0];
        for(int i = 1; i < n; ++i)
            if(a[i] < min || 0 == min) min = a[i];
        outputresult(min, m);
        return true;
    }
    // not enough zero, we need to refine the judgement
    else
    {
        // step 2.1: sort the array. (bubble sort, ascending)
        bool bIsDone = false;
        for(int i = n-1; i >= 0 && !bIsDone; --i)
        {
            bIsDone = true;
            for(int j = 0; j < i; ++j)
            {
                if(a[j+1] < a[j])
                {
                    bIsDone = false;
                    int tmp = a[j+1];
                    a[j+1] = a[j];
                    a[j] = tmp;
                }
            }
        }

        cout<<"Sorted Array:    "; outputarray(a, n);

        // step 2.2: remove redundant num except 0
        int aa[256];
        aa[0] = a[0];
        int j = 1;
        for(int i = 0; i < n-1; ++i)
        {
            if(a[i+1] != a[i] || 0 == a[i+1])
                aa[j++] = a[i+1];
        }
        memcpy(a, aa, j * sizeof(aa[0]));
        n = j;
        if(n < m) return false;

        cout<<"Unique Array:    "; outputarray(a, n);


        // step 2.3: get index of first non-zero element
        int nIndex = 0;
        for(int i = 0; i < n; ++i)
        {
            if(a[i] != 0) 
            {
                nIndex = i;
                break;
            }
        }

        // step 2.4: refined judgement
        // if n = 7; m = 5; nZeroNum = 2;
        // if we can get continious number without zero or only with 1 zero, then with 2 zero is ok too.
        // so if we got x zeros, we need to check if can success with (0 ~ x-1) zeros
        for(int k = 0; k <= nZeroNum; ++k)
        {
            int nInterval = m - k - 1;
            for(int i = nIndex; i < n-nInterval; ++i)
            {
                // when k = nZeroNum = 2;
                // if the a[i+nInterval] - a[i] ranged in (nInterval, m-1), then it is continuous)
                // means a[i+2] - a[i] ranged in (2, 4), for example:
                // 1 3 5;  1 2 3; 1 2 4;
                if(a[i+nInterval] - a[i] <= m-1 && a[i+nInterval] - a[i] >= nInterval)
                {
                    outputresult(a[i], m);
                    return true;
                }
            }
        }
    }

    return false;
}


int main(int argc, char *argv[])
{
    int a[] = {0, 0, 0, 0, 0, 0, 0};
    if(!Is_n_Contains_m_ContinuousNum(a, sizeof(a)/sizeof(a[0]),5))
        cout<<"Continuous Array:Not Found ";
    return 0;
} 

PS：网友建议

fflush：不需要这么复杂吧，题目说明了是从0~13中任取出7个数，那么建立一个int A[13]，记录哪些数有哪些数没有（有的话置A[i]为1，否则是0），然后检测A中连续的5个位置的情况就可以了

SmartPtr：fflush的思路对我很有启发， 但我们还要考虑多个0的情况， 按着这个思路的话我觉得可以这么做：针对0～13建立一个数组A[14], A[0], A[1]...分别对应0， 1...的个数。然后依次检测A中连续的5个位置， 如果其0的个数小于A[0],那么就存在连续的数。（当然还有一些边缘情况要处理）。

这个算法我觉得十分有效， 通过引入一个数组大大的简化了问题。但是有个缺点就是如果要判断任意范围内的5个连续数就不容易了。如：
0， 1， 122， 678， 10000， 3， 6 

(搬自以前blog, 2007-08-26)