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


      从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[] = {0000000};
        
    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)
  • 相关阅读:
    EL+Serilog日志
    HttpClientFactory-向外请求的最佳
    Autofac依赖注入
    .Net Core MemoryCache
    时间复杂度和空间复杂度
    中间件-异常处理
    依赖注入-1
    使用并发集合
    安卓刷机&root
    Mac Android Studio 常用快捷键大全
  • 原文地址:https://www.cnblogs.com/baiyanhuang/p/1730734.html
Copyright © 2020-2023  润新知