算法——概率例题代码（OJ已测试通过）

题1 蒙特卡罗算法

设T[0:n-1]是n个元素的数组(1<=n<=200)，如果其中某个元素x在整个数组中的出现次数超过n/2，则称x为数组T的主元素。请设计一个蒙特卡罗算法，判断数组中的数据是否存在主元素。找不到主元素时输出null，找到时输出主元素的值。

输入：第1行为数组S中元素个数n；接下来的n行中，每行有一个自然数。

输出：找不到主元素时输出null，找到时输出主元素的值。

样例输入：11  1  1  1  1  1  1  2  3  4  1  1

样例输出：1

#define _CRT_SECURE_NO_WARNINGS//VS用户需要加的注释

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

// 随机数生成函数
int generaterandomnumber(int min, int max) {
    return rand() % (max - min + 1) + min;
}

// 判断是否为主元素的函数
int ismajority(int arr[], int n, int candidate) {
    int count = 0;
    for (int i = 0; i < n; i++) {
        if (arr[i] == candidate) {
//如果是重复的，其数量就+1
            count++;
        }
    }
//如果是主元素，数量应该大于n/2，就返回1，否则返回0
    return count > n / 2;
}

int main() {
//输入，首先是数量，其次是每一个数
    int n;
    scanf("%d", &n);

    int* arr = (int*)malloc(sizeof(int) * n);

    for (int i = 0; i < n; i++) {
        scanf("%d", &arr[i]);
    }
// 初始化随机数生成器
    srand(time(NULL)); 
// 迭代次数，可以根据需要调整
    int iterations = 1000; 

    for (int i = 0; i < iterations; i++) {
        int randomindex1 = generaterandomnumber(0, n - 1);
        int randomindex2 = generaterandomnumber(0, n - 1);
//不要重复的随机数
        while (randomindex2 == randomindex1) {
            randomindex2 = generaterandomnumber(0, n - 1);
        }
// 选取的两个元素相等，可能是主元素候选
        if (arr[randomindex1] == arr[randomindex2]) { 
            if (ismajority(arr, n, arr[randomindex1])) {
                printf("%d\n", arr[randomindex1]);
                free(arr);
                return 0;
            }
        }
    }
//没找到，返回null
    printf("null\n");
//记得释放开辟的空间
    free(arr);
    return 0;
}

如果对srand函数有疑问，参考随机化函数的深度解析。

蒙特卡洛和拉斯维加斯算法理解

这里解释一下各种概率算法。

上学的时候经常听各种人说：

---

数值概率算法常用于数值问题的求解，得到的是近似解。

蒙特卡洛算法能得到一个准确解但是，但该解未必正确。

拉斯维加斯算法不会得到不正确的解，但有时找不到问题的解。

舍伍德算法总能得到问题的一个解，而且所得到的解总是正确的。

---

拆开都好理解，但是放在“概率算法”里面就未免就……可远观而不可亵玩了，好姐妹都站在跟前了，不能交个朋友吗？（星星眼……）

首先我们需要知道一个问题，概率算法有n1种，而我们遇到的问题有n2种，我们对于问题结果的要求有n3种。

但并不是每一个算法都能1对n2的去解决问题的。原因就在于n3是多姿多彩的，要求计算Π的值，你说的不到正确解，那还玩啥。

所以，选择一个合适的算法直接取用就好，不需要横向比较。

---

就像刚刚题1所见到的，题目让用蒙特卡洛算法，所以我们定义循环iterations=1000，也就是人为折腾1000次。

如你所见，老蒙能找到的答案要不就是真正的主元素（如果是主元素，个数一定大于n/2），要不就是null。也就是我们拿老蒙给的答案，要不就是正确答案（找到主元素或者确实没有主元素），要不就是有主元素但是循环次数不够没找到主元素而得到了null。

所以我们说，蒙特卡洛算法会得到一个解，但是不一定是正确解。

而对比拉斯维加斯算法，小拉说，如果这次答案不对，我连给出答案都不会，只要我给答案，就肯定是正确结果！

小拉在算法内部多了一步判断，保证如果这个结果不对，那就干脆不给出任何结果。

题2 舍伍德算法

设T[0:n-1]是n个互不相同的整数数组(1<=n<=200)，请采用舍伍德算法思想改造原有的线性时间选择算法，找到其中第K小的元素的值。

输入：第1行为数组S中元素个数n；第2行为K值； 接下来的n行中，每行有一个整数。 

输出： 输出第K小元素的值。 

样例输入：8  2  1  3  5  7  9  11  13  15

样例输出：3

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define Random(n) (rand() % n)
#define INF 0x7fffffff

int select(int a[], int l, int r, int k) {
 // 无限循环，直到找到第 k 小的元素
    while (1) {
// 如果左边界大于等于右边界，说明只有一个元素，直接返回这个元素
        if (l >= r) return a[l];
// 随机选择一个元素的位置，将其作为枢纽元素
        int i = l, j = l + Random(r - l + 1);
        int temp;
// 交换 a[i] 和 a[j]，将随机选择的元素放在数组的开头
        temp = a[i];
        a[i] = a[j];
        a[j] = temp;
// 将 j 设为数组最右侧数的再右边一个，准备开始划分
        j = r + 1;
// 选择枢纽元素
        int pivot = a[l];

        while (1) {
// 找到左边第一个大于等于枢纽元素的位置
            while (a[++i] < pivot && i <= r);
// 找到右边第一个小于等于枢纽元素的位置
            while (a[--j] > pivot && j >= 0);
// 如果 i >= j，说明划分完成
            if (i >= j) break;
//将大于枢纽元素的数组元素放在右边，小于的放在左边
            temp = a[i];
            a[i] = a[j];
            a[j] = temp;
        }
// 如果枢纽元素的位置正好是第 k 小的位置，返回枢纽元素
        if (j - l + 1 == k) return pivot;
//第一次swap的时候把随机选出来的枢纽元素放在l位置了
        a[l] = a[j];
        a[j] = pivot;
// 更新 k 的值，减去已经找到的小于枢纽元素的个数
        if (j - l + 1 < k) {
            k = k - (j - l + 1);
// 在右边继续查找
            l = j + 1;
        }
        else {
// 在左边继续查找
            r = j - 1;
        }
    }
}

int S_select(int a[], int n, int k) {
    if (k < 1 || k > n) return INF;
    return select(a, 0, n - 1, k);
}


int main() {
//输入数据
    int n, k, num;
    scanf("%d", &n);
    scanf("%d", &k);
    int* arr = (int*)malloc(sizeof(int) * n);
    for (int i = 0; i < n; i++) {
        scanf("%d", &arr[i]);
    }
//进入算法
    num = S_select(arr, n, k);
    if (num != 0x7fffffff)
        printf("%d\n", num);
    return 0;
}

如果你是用普通OJ做题呢，差不多可以过关了。

---

舍伍德理解

实际上上面的算法并不能称作是舍伍德算法本法。可以看到它除了随机化好像也没做什么。

正真的舍老师这边除了随机化，还做了什么呢？

就是出错的告知。

比如，当算法运行过程中出现了超时未完成的时候，就会输出错误信号。

话说回来，每次见舍老师，那必须是伴随着5毛钱特效闪闪发光的弹幕大喊：消除在不同输入下的时间复杂度区别大的问题！

怎么做到呢？就是在原有算法的基础上，不再有序进行正确答案的寻找，而是随机找一个起始位置。这样有什么好处呢？

打个比方，我在一万个纸币里面找一张真币，本来前9999张都是假的第10000张是真的，那顺序找就得找10000次。但如果我打乱顺序，随便一摸，甚至有可能第一把就摸到真的。

总结就是，舍伍德算法更高效的找到正确结果，同时如果消耗算力过大，也会报告错误，但不会输出错误结果。