c - 该算法(Big-O)的时间复杂度是多少？

Question

我仍在尝试理解 BigO 表示法和时间复杂度，但是，我真的不确定这个算法(我的代码)的时间复杂度是多少。

// 03_BeaverConstructions.c
// Created for FIKS on 28/12/2013 by Dominik Hadl
//
// Time complexity: O(N+M)
// Space complexity: O(N)
// ------------------------------------------
// LICENSE (MIT)
// Copyright (c) 2013 Dominik Hadl
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
// ------------------------------------------

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// ------------------------------------------
// Setup
// ------------------------------------------

#define MAX_PROFILE_LENGTH 10000
#define NO_VALUE -99999

#define BLOCK_VOLUME 1
#define SLOPE_VOLUME 0.5

const char kSlopeRise = '/';
const char kSlopeLower = '\\';
const char kSlopeStay = '_';

// ------------------------------------------
// Structs
// ------------------------------------------

typedef struct
{
    int start_elevation;
    float current_volume;
} Lake;

typedef struct
{
    int location;
    int elevation;
} Peak;

// ------------------------------------------
// Declarations
// ------------------------------------------

int main(int argc, char const *argv[]);
float get_water_volume_of_profile(char const *hill_profile);

// ------------------------------------------
// Main
// ------------------------------------------

int main(int argc, char const *argv[])
{
    // Get the profile
    char hill_profile[MAX_PROFILE_LENGTH + 1];
    fgets(hill_profile, MAX_PROFILE_LENGTH + 1, stdin);

    // Calculate the volume
    float volume = get_water_volume_of_profile(hill_profile);

    // Print it!
    printf("%0.1f\n", volume);

    return 0;
}

// ------------------------------------------
// Calculation
// ------------------------------------------

float get_water_volume_of_profile(char const *hill_profile)
{
    float total_volume = 0; 
    int current_elevation = 0, number_of_peaks = 0, last_peak_index = 0;

    // Get the actual length of the hill profile    
    int profile_length = strlen(hill_profile);

    // Prepare the peaks and lakes in the hill profile
    Peak peaks[profile_length / 2];
    Lake lake = {NO_VALUE, 0};

    // First, get all the peaks
    for (int i = 0; i < profile_length; i++)
    {
        char current_char = hill_profile[i];
        char next_char = hill_profile[i + 1];

        switch (current_char)
        {
            case kSlopeRise:
                current_elevation += 1;
                break;
            case kSlopeLower:
                current_elevation -= 1;
                break;
            case kSlopeStay:
                break;
        }

        if (next_char == '\n')
        {
            peaks[number_of_peaks].location = i + 1;
            peaks[number_of_peaks].elevation = current_elevation;
            number_of_peaks++;
            break;
        }

        if (current_char == kSlopeRise &&
            (next_char == kSlopeLower || next_char == kSlopeStay))
        {
            peaks[number_of_peaks].location = i + 1;
            peaks[number_of_peaks].elevation = current_elevation;
            number_of_peaks++;
        }
    }

    // Now, go through the profile and get the water volume
    current_elevation = 0;
    for (int i = 0; i < profile_length; i++)
    {
        // Get current char and decide what to do
        char current_char = hill_profile[i];
        switch (current_char)
        {
            case kSlopeRise:
            {
                if (lake.start_elevation != NO_VALUE &&
                    lake.start_elevation > current_elevation)
                {
                    lake.current_volume += SLOPE_VOLUME;
                }

                // Increase the elevation
                current_elevation++;

                if (lake.start_elevation == current_elevation)
                {
                    total_volume += lake.current_volume;

                    lake.start_elevation = NO_VALUE;
                    lake.current_volume = 0;
                    break;
                }

                if (lake.start_elevation != NO_VALUE)
                {
                    int elevation_diff = abs(lake.start_elevation - current_elevation);
                    if (elevation_diff > 1)
                    {
                        lake.current_volume += (elevation_diff - 1) * BLOCK_VOLUME;
                    }
                }

                break;
            }
            case kSlopeLower:
            {
                current_elevation--; // Lower the elevation

                // Set elevation where water starts if not already set
                if (lake.start_elevation == NO_VALUE)
                {
                    for (int p = last_peak_index; p < number_of_peaks; p++)
                    {
                        if (peaks[p].elevation >= current_elevation + 1 &&
                            peaks[p].location > i)
                        {
                            lake.start_elevation = current_elevation + 1;
                            last_peak_index = p;
                            break;
                        }
                    }
                    if (lake.start_elevation == NO_VALUE) 
                    {
                        break;
                    }
                }

                lake.current_volume += SLOPE_VOLUME;

                int elevation_diff = abs(lake.start_elevation - current_elevation);
                if (elevation_diff > 1)
                {
                    lake.current_volume += elevation_diff * BLOCK_VOLUME;
                }

                break;
            }
            case kSlopeStay:
            {
                if (lake.start_elevation != NO_VALUE)
                {
                    int elevation_diff = abs(lake.start_elevation - current_elevation);
                    lake.current_volume += elevation_diff * BLOCK_VOLUME;
                }   
                break;
            }
        }
    }

    // Return the total water volume
    return total_volume;
}

我不确定它是否是 O(N)，但我不这么认为，因为第二个 for 循环中有一个嵌套循环。然而，它可能也不是 O(N^2)...更像是 O((N^2)/2)。

有人可以给我建议吗？

Answer 1

算法的复杂度为 O(n + m)，其中 n 是输入的大小，m 是输入的数量“峰值”，无论它们是什么。

原因是核心算法由两个大约运行 n 次的循环组成。其中一个循环包含一个内循环。我们需要计算内循环体执行了多少次。

当您遇到峰值时，内部循环就会运行，看起来循环的主体执行的总次数大致就是您所拥有的峰值数量。循环嵌套并不重要:对于复杂性计算，主体的迭代总数才是重要的。

(通常，嵌套循环的迭代计数会相乘而不是相加，因为它在外部循环的每次迭代中都会完整执行，但这里的情况并非如此。从逻辑上讲，您是从第一个峰值开始迭代(在内部循环中)到最后；请注意，您跟踪(使用 p)在外部循环迭代之间打破内部循环的位置，并从 p 开始 当您返回到内循环时。)