[题解]《算法零基础100讲》(第32讲) 多维枚举(二) - 进阶

最新推荐文章于 2024-11-03 01:08:04 发布

友人苏

最新推荐文章于 2024-11-03 01:08:04 发布

阅读量805

点赞数 9

分类专栏：刷题算法文章标签： c语言算法 leetcode

本文链接：https://blog.csdn.net/qq_53060585/article/details/121458525

版权

刷题算法专栏收录该内容

50 篇文章 20 订阅

订阅专栏

本文介绍了多维枚举的概念，并提供了相关编程练习的详细解答，包括两个数组间距离值的计算、顺次数的查找、平衡数的求解以及数组交集的找出。文章通过多种算法实现，如暴力枚举、打表优化和模拟枚举，展示了不同的解题思路和优化技巧。

摘要由CSDN通过智能技术生成

一. 概念定义

1.1 多维枚举

由之前的讲述我们知道，线性枚举就是用一个循环进行一次遍历，多维枚举就是在循环里面嵌套一个或多个循环。

for(int i = 0; i < n; i++){
	for(int j = 0; j < n; j++){
		for(int k = 0; k < n; k++){
			...
		}
	}
}

二. 相关练习

2.1 两个数组间的距离值

题目链接：
1385. 两个数组间的距离值

这道题我们只需将arr1的每个数与分别与arr2中的数进行计算，查看是否符合条件即可。

代码如下：

int findTheDistanceValue(int* arr1, int arr1Size, int* arr2, int arr2Size, int d){
    int ans = 0;
    int len = fmax(arr1Size, arr2Size);
    for(int i = 0; i < arr1Size; i++){
        int flag = 1;
        for(int j = 0; j < arr2Size; j++){
            //如果不符合条件直接跳出
            if(abs(arr1[i] - arr2[j]) <= d){
                flag = 0;
            }
        }
        //符合条件则记录下来
        if(flag){
            ans++;
        }
    }
    return ans;
}

2.2 顺次数

题目链接：

1291. 顺次数

2.2.1 方法一暴力

暴力的方法就是对，范围内的每个数都进行枚举，对每个数进行拆分，判断其是否为顺次数，但是这种办法的时间复杂度很高，会超时。

代码如下：

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* sequentialDigits(int low, int high, int* returnSize){
    int* ret = (int*) malloc (sizeof(int) * 501);
    int retSize = 0;
    //枚举
    for(int i = low; i <= high; i++){
        int k = i;
        int flag = 1;
        int m, n;
        m = k % 10;
        k /= 10;
        //拆分并判断
        while(k){
            n = k % 10;
            k /= 10;
            if(m - n != 1){
                flag = 0;
                break;
            }
            m = n;
        }
        if(flag){
            ret[retSize++] = i;
        }
    }
    *returnSize = retSize;
    return ret;
}

虽然这种方法过不了，但我们可以靠他得到所有结果。

2.2.2 方法二 — 打表

通过上面的代码，稍微对其进行一些修改，我们在编译器上运行一下，可以得出[10，1000000000]范围内的所有顺次数，然后直接进行打表。这种方法的时间复杂度为O(1)。

代码如下：

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int arr[] = {12, 23, 34, 45, 56, 67, 78, 89, 123, 234, 345, 456, 567, 678, 789, 1234, 2345, 3456, 4567, 5678, 6789, 12345, 23456, 34567, 45678, 56789, 123456, 234567, 345678, 456789, 1234567, 2345678, 3456789, 12345678, 23456789, 123456789};

int* sequentialDigits(int low, int high, int* returnSize){
    int n = sizeof(arr)/sizeof(arr[0]);
    int *ans = (int*) malloc (sizeof(int) * n);
    int ansSize = 0;
    for(int i = 0; i < n; i++){
        if(arr[i] >= low && arr[i] <= high){
            ans[ansSize++] = arr[i];
        }
    }
    *returnSize = ansSize;
    return ans;
}

2.2.3 方法三 — 模拟枚举

我们首先枚举顺次数的最高位数字 i，然后逐步模拟较低位置数字 j，其中i < j，对于每组i 和 j，我们可以得到它的顺次数num，如果num在low和high之间，则将其计入下来。由于这种方法不是按升序遍历的，所以我们还需对其进行排序。时间复杂度为O(1)。

代码如下：

int cmp(const int* a, const int* b){
    return *a - *b;
}
int* sequentialDigits(int low, int high, int* returnSize){
    int *ans = (int*) malloc (sizeof(int) * 40);
    int ansSize = 0;
    for(int i = 1; i <= 9; i++){
        int num = i;
        for(int j = i + 1; j <= 9; j++){
            num = num * 10 + j;
            if(num >= low && num <= high){
                ans[ansSize++] = num;
            }
        }
    }
    qsort(ans, ansSize, sizeof(int), cmp);
    *returnSize = ansSize;
    return ans;
}

2.3 下一个更大的数值平衡数

2048. 下一个更大的数值平衡数

分析：

这道题的意思是，一个数中的每位数它的大小等于在该数中出现的次数则为数值平衡数，例如数字122，2包含两个，2 = 2，1包含一个，1 = 1，所以122是数值平衡数。

解题思路：

我们可以用两个数组，分别记录某个数字出现的次数，和出现过的数字。然后再对其进比较。

代码如下：

int nextBeautifulNumber(int n){
    while(n++){
        int k = n;
        int arr[10] = { 0 };//记录每位数字出现的次数
        int nums[7];//记录出现了哪些数
        int numsSize = 0;
        int flag = 1;
        while(k){
            arr[k % 10]++;
            nums[numsSize++] = k % 10;
            k /= 10;
        }
        for(int i = 0; i < numsSize; i++){
            //判断
            if(arr[nums[i]] != nums[i]){
                flag = 0;
                break;
            }
        }
        if(flag)return n;
    }
    return 1;
}

2.4 两个数组的交集

349. 两个数组的交集

这道题我们可以先对其进行排序，然后同时遍历两个数组，用index1和index2两个指针指向他们，如果nums1[index1] == nums2[index2]，并且之前没有记录该数，则将其放入，并且两个指针同时移动，否则，移动数值较小的哪个指针。

如图：
在这里插入图片描述

代码如下：

 int cmp(const int* a, const int* b){
     return *a - *b;
 }

int* intersection(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize){
    qsort(nums1, nums1Size, sizeof(int), cmp);
    qsort(nums2, nums2Size, sizeof(int), cmp);
    *returnSize = 0;
    int *ans = (int*) malloc (sizeof(int) * (nums1Size + nums2Size));
    int index1 = 0, index2 = 0;
    while(index1 < nums1Size && index2 < nums2Size){
        int num1 = nums1[index1], num2 = nums2[index2];
        if(num1 == num2){
            if(!(*returnSize) || ans[*returnSize - 1] != num1){
                ans[(*returnSize)++] = num1;
            }
            index1++;index2++;
        }
        else if(num1 < num2){
            index1++;
        }
        else{
            index2++;
        }
    }
    return ans;
}