Week1Day3C：程序效率优化【2023 安全创客实践训练|笔记】

最新推荐文章于 2024-07-25 01:51:24 发布

昊乾_

最新推荐文章于 2024-07-25 01:51:24 发布

阅读量80

点赞数

分类专栏：【2023 安全创客实践训练|笔记】文章标签：笔记

原文链接：https://whu.suanfaedu.com/course/35020

版权

【2023 安全创客实践训练|笔记】专栏收录该内容

25 篇文章 15 订阅

订阅专栏

内容为武汉大学国家网络安全学院2022级大一第三学期“996”实训课程中所做的笔记，仅供个人复习使用，如有侵权请联系本人，将与15个工作日内将博客设置为仅粉丝可见。

时间复杂度分析

递归程序分析

算法选择

时间复杂度分析

回忆一下之前学过的计数排序。

当元素在一定范围的时候，比如在 [0,m) 范围内时，可以采用计数排序。统计每个值出现的个数，然后遍历一遍cnt数组，就能从小到大一个个把数放到待排序的数组里。

memset(cnt, 0, sizeof(cnt));
int m = 100;
for (int i = 0; i < n; i++) {
    cnt[a[i]]++;
}
int pos = 0;
for (int i = 0; i < m; i++) {
    while (cnt[i] > 0) {
        cnt[i]--;
        a[pos++] = i;
    }
}

清空cnt数组的时间频度可以看做 m，while循环里面的语句一共执行了 n 次，因为∑cnt_i=n。

T(n)=m+n+m+n=2m+2n

时间复杂度为O(n+m)。

我们来回顾一下练习题《装饰效果》。

小明在美术课上给马上要过生日的妈妈做了张贺卡，为了装饰这张贺卡，小明买了一条彩带，但是彩带上并不是所有颜色小明都喜欢，于是小明决定裁剪这条彩带，以取得最好的装饰效果。

现已知彩带由 n 种不同的颜色顺次相接而成，而每种颜色的装饰效果用一个整数表示（包括正整数，0，或负整数），从左到右依次为 1,2,...,a_1,a_2,...,a_n，小明可以从中裁剪出连续的一段用来装饰贺卡，而装饰效果就是这一段上各个颜色装饰效果的总和，小明需要选取装饰效果最好的一段颜色来制作贺卡（取该段颜色数值之和的最大值）。当然，如果所有颜色的装饰效果都只能起到负面的作用（即 a_i<0），小明也可以放弃用彩带来装饰贺卡（获得的装饰效果为 0）。

题意就是求一个数组的最大子段和，容易想到最暴力的做法是枚举子段的起点位置i和终点位置j，然后计算其中的和sum，并更新答案。

int ans = 0;
for (int i = 1; i <= n; i++) {
    for (int j = i; j <= n; j++) {
        int sum = 0;
        for (int k = i; k <= j; k++) {
            sum += a[k];
        }
        if (sum > ans) {
            ans = sum;
        }
    }
}

我们可以发现第三层循环是没必要的，在右端点j往后移的时候，同时维护sum就行了。

int ans = 0;
for (int i = 1; i <= n; i++) {
    int sum = 0;
    for (int j = i; j <= n; j++) {
        sum += a[j];
        if (sum > ans) {
            ans = sum;
        }
    }
}

这样时间复杂度就变为 O(n^2)。

事实上，我们还可以继续优化，详细的解释会在后面动态规划的课程中介绍。

int ans = 0, sum = 0;
for (int i = 1; i <= n; i++) {
    sum += a[i];
    if (sum > ans) {
        ans = sum;
    }
    if (sum < 0) {
        sum = 0;
    }
}

时间复杂度就变为 O(n)。

递归程序分析

递归调用：是指一个函数调用自身从而产生循环的过程。

int fun(int n) {
    if (n <= 1) {
        return 1;
    }
    return n * fun(n - 1);
}

那么该递归程序的时间复杂度是多少呢？

我们观察程序中 return n * fun(n - 1); 每次递归调用的时候传递参数 n−1，也就是说程序会递归调用 n 次。乘法的时间复杂度是 O(1)，总体的时间复杂度为：O(n)。

递归程序二：

int fun(int n) {
    if (n <= 1) {
        return 1;
    }
    return n * fun(n/2);
}

那么该递归程序的时间复杂度是多少呢？

我们观察程序中 return n * fun(n/2); 每次递归调用的时候传递参数 n/2，也就是说程序会递归调用 log2n 次。乘法的时间复杂度是 O(1)，总体的时间复杂度为：O(logn)。

递归程序三：

int fun(int n, int m) {
    if (n <= 1) {
        return 1;
    }
    int tmp = 1;
    for (int i = 1; i <= m; i++) {
        tmp *= i;
    }
    return n * fun(n/2, m);
}

那么该递归程序的时间复杂度是多少呢？

我们观察程序中 return n * fun(n/2, m); 每次递归调用的时候传递参数 n/2,m，也就是说程序会递归调用 log2n 次。在每个递归函数中，程序会通过循环计算出 m!，时间复杂度为 O(m)。总体的时间复杂度为：O(mlogn)。

算法选择

面对不同的问题，不同的数据范围，要综合考虑时间复杂度和空间复杂度，选择较优的算法。

下面来看几个例子。

有 n 个人报数，报数范围为 [0,m) 的整数，现在有若干个询问，每个询问查询报数为 x 的人有多少？

当 m 不大时（比如 m≤10^6），可以开一个数组储存每个数的个数，时间复杂度 O(n+m)，空间复杂度 O(m)，每次查询的时间复杂度为 O(1)。
当 m 很大，n≤10^6 时，可以把所有人报的数排序，然后每次进行二分查找即可。时间复杂度 O(nlogn)，空间复杂度 O(n)，每次查询的时间复杂度都是 O(logn)。

有 q 个询问，每次询问两个数 x,y 的最大公因数，1≤x,y≤m。

当 q 很小（比如1≤q≤100）时，每次直接计算 gcd(x,y)，用辗转相除法，时间复杂度 O(logm)，总时间复杂度 O(qlogm)。
当 q 很大（比如1≤q≤106）且 m 不大时（比如 m≤1000），开一个 m×m 的数组预处理出所有情况，预处理时间复杂度 O(m2logm)，空间复杂度 O(m2)，每次查询时间复杂度 O(1)。