笔试题

1、计算斐波那契数列第n项的函数定义如下：

1 2 3 4 5 6 7 8

int fib(int n){       if(n==0)          return 1;       else if(n==1)          return 2;       else          return fib(n-1)+fib(n-2); }

若执行函数调用表达式fib(7),函数fib被调用的次数是：

设f(n) 表示执行fib(n)函数的次数： f(n) = f(n-1) + f(n-2) + 1 （1表示执行到了fib（n）的时候执行了一次fib函数）

f(0) = 1；f(1) = 1；f(2) = 3；f(3) = 5；f(4) = 9；f(5) = 15；f(6) = 25；f(7) = 41

2、决策树的父节点和子节点的熵的大小关系是什么？

1. 决策树的父节点更大
2. 子节点的熵更大
3. 两者相等
4. 根据具体情况而定

网上答案1,2,4都有选的。。。。。

决策树分解策略是保证子结点的熵小于父结点的熵。但“子结点的熵”是该父结点所有孩子结点的熵的加权总和，因此，并不保证任意单个子节点的熵都小于父结点熵。

3、下列排序中最好和最坏时间复杂度是nlgn的是（3,4），对任意数列进行排序时，平均排序时间最短的排序算法为（1 ）【快速排序的平均时间为Tavg(n)=knln(n),其中n为待排序记录中记录的个数，k为某个常数，经验证明，在所有同数量级的此类（先进的）排序方法中，快速排序的常数因子k最小。因此，就平均时间而言，快速排序是目前被认为是最好的一种内部排序方法。——>《数据结构（C语言版）》】

1. 快速排序   【最坏情况下是O(N2)，最好和平均时间复杂度是O(NlgN)】
2. 插入排序  【平均和最坏情况下是O(N2)，最好时间复杂度是O(N)】
3. 归并排序 【最坏和最好和平均时间复杂度是O(NlgN)】
4. 堆排序   【最坏和最好和平均时间复杂度是O(NlgN)】

from：https://blog.csdn.net/qq_30815237/article/details/90766878

4、哪些树在最坏时，删除的复杂度是lgn(1,3)

1. AVL树
2. 伸展树
3. 红黑树
4. 二叉查找树

BST：二叉搜索树
查找最好时间复杂度为O(lgn),最坏为O(n);删除和插入的时间复杂度与查找差不多
AVL：二叉平衡树
查找、插入、删除的时候需要的时间复杂度为O(lgn)
红黑树：
查找、删除和插入的时间复杂度为O(lgn)

5、P为给定的二维平面整数点集。定义 P 中某点x，如果x满足 P 中任意点都不在 x 的右上方区域内（横纵坐标都大于x），则称其为“最大的”。求出所有“最大的”点的集合。（所有点的横坐标和纵坐标都不重复, 坐标轴范围在[0, 1e9) 内）如下图：实心点为满足条件的点的集合。请实现代码找到集合 P 中的所有 ”最大“ 点的集合并输出。

                                       

输入例子1:

5
1 2
5 3
4 6
7 5
9 0

输出例子1:

4 6
7 5
9 0

list=[[1,2],[5,3],[4,6],[7,5],[9,0]]
len=len(list)
a=list[0][1]
result=[]
for i in range(len):
    for j in range(len):
        if list[i][0]<list[j][0] and list[i][1]<list[j][1]:
            break
        elif j==(len-1):
            result.append(list[i])
idx=[i for i,v in sorted(enumerate(result))]

6、给定一个数组序列, 需要求选出一个区间, 使得该区间是所有区间中经过如下计算的值最大的一个：

区间中的最小数 * 区间所有数的和最后程序输出经过计算后的最大值即可，不需要输出具体的区间。如给定序列  [6 2 1]则根据上述公式, 可得到所有可以选定各个区间的计算值:

[6] = 6 * 6 = 36;

[2] = 2 * 2 = 4;

[1] = 1 * 1 = 1;

[6,2] = 2 * 8 = 16;

[2,1] = 1 * 3 = 3;

[6, 2, 1] = 1 * 9 = 9;

从上述计算可见选定区间 [6] ，计算值为 36， 则程序输出为 36。

list1=[6,2,1]
list=[]
result=[]
len1=len(list1)
for m in range(len1):
    for j in range(m,len1):
        list=list1[m:j+1]
        mi=min(list)
        su=sum(list)
        b=mi*su
        a=[m,j,b]
        result.append(a)

maxnum=result[0][2]
maxidx=0;
len2=len(result)#定义了一个名为len的变量与len()方法重名，后期再遇到len时，python将其认为是len这个int类型的变量，而不是len()方法
for i in range(len2):
    if result[i][2]>maxnum:
        maxnum=result[i][2]
        maxidx=i

7、在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数

import numpy as np
def find(array,target):
    row = array.shape[0]
    col=array.shape[1]
    i=0
    j=col
    while(i<row and j>0):
        start=array[i,j-1]
        if start>target:
            j=j-1
        elif start<target:
            i+=1
        else:

            return 1,i,j#返回一个元组

    return 0

a=np.array([[1,3,8,10],[4,5,7,12],[9,11,14,19],[21,24,25,30]])
flag=find(a,25)
print(flag)

8、#实现字符串反转的几种方法

s="abcdefghijk"
result=s[::-1]
#转化为列表
l=list(s)
l.reverse()
result2="".join(l)
#列表模拟栈（先进先出）
m=list(s)
result3=""
while len(m)>0:
    result3+=m.pop()
#for循环
result4=""
result5=""
for i in range(len(s)-1,0,-1):
    result4+=s[i]
result4+=s[0]

for i in range(len(s)):
    result5+=s[len(s)-i-1]

9、下列选项中，不可能是快速排序第二趟排序结果的是：（C）

A. 2,3,5,4,6,7,9 
B. 2,7,5,6,4,3,9 
C. 3,2,5,4,7,6,9 
D. 4,2,3,5,7,6,9

分析：只需要掌握一点就可以解出这个问题：每趟排序就有一个元素排在了最终的位置上。那么就是说，第n趟结束，至少有n个元素已经排在了最终的位置上。（快速排序每趟趟排序后，轴值将在其最终位置上；）

所以我们把最终排序结果写出来：2,3,4,5,6,7,9去与每一项做比较即可快速判断。

C: 
2,3,4,5,6,7,9 
3,2,5,4,7,6,9 
只有一个，不满足

10、给出二叉树的中序排列与后序排列。求出它的先序排列

   例如 A：根节点、B：左节点、C：右节点，前序顺序是ABC（根节点排最先，然后同级先左后右）；中序顺序是BAC(先左后根最后右）；后序顺序是BCA（先左后右最后根）。

分析中序遍历如下图：

                         

前序遍历：ABCDEFGHK

中序遍历：BDCAEHGKF

后序遍历：DCBHKGFEA

    已知2个，可以求另一个：首先前序中，第一个是根节点，第二个是根的左节点；后序中，最后一个是根节点；中序中，根节点后面紧跟着的是右节点。

10.1、如果W是由有序树V转换的二叉树，则V中的结点的后序遍历顺序是W结点的（B     ）

A先序遍历  B中序遍历   C后序遍历   D层次遍历

11、

 int main()
{
    int a[]={1,8,5,9,12,6};
    int *p=a;
    int *q=a;
    int x=*p++;   //先取指针p指向的值（数组第一个元素1）赋值给x，再将指针p自增1,此时指向a[1]；  x=1
    int y=(*q)++;  //先取指针q指向的值（数组第一个元素1）赋值给y，再将指针q指向的值自增1； y=1,但执行完a[0]=2
    cout<<y<<endl<<((*q)++) <<endl<<x<<endl<<(*++p)++<<endl<<a[0];
}

输出结果：

解析：((*q)++) 输出:q指向的值,此时是2，复制后再将指针q指向的值自增1，即a[0]=3;

(*++p)++:根据运算符优先级,先计算括号内内容,++p,首先自增p,此时p指向第3个元素,即指向a[2];然后通过*得到a[2]；后置++不立即改变a[2]的值（输出5）,而在此表达式之后a[2]值为6.

1. *++p 先将指针p自增1（此时指向数组第二个元素），* 操作再取出该值
2. ++*p 先取指针p指向的值（数组第一个元素1），再将该值自增1，

11.1/假定一个类的构造函数为A(int aa,int bb){a=aa++;b=a*++bb;}，则执行A x(4,5);语句后，x.a和x.b的值分别为（C ）

A. 4和5 B. 4和20   C. 4和24       D. 20和5

a=aa++:先赋值后aa++;a=4,b=a*++bb先++b,后进行乘运算b=4*6=24

12、设一个栈的输入序列为A，B，C，D，则借助一个栈所得到的输出序列不可能是__d__。
                a. A，B，C，D             b. D，C，B，A           c. A，C，D，B          d. D，A，B，C

A：A进栈再出栈，B进栈再出栈，C进栈再出栈，D进栈再出栈，所以出栈顺序可以 是 A，B，C，D
B：A、B、C、D依次进栈，再D、C、B、A依次出栈
C：A进栈再出栈，然后B、C依次进栈，然后C出栈（这时栈里只有B),接着D进栈再出栈，最后B出栈，所以ACDB的顺序是可能的
D是不可以的

13、有一家医院为了研究癌症的诊断，对一大批人作了一次普查，给每人打了试验针，然后进行统计，得到如下统计数字：

    ①这批人中，每1000人有5个癌症病人；

    ②这批人中，每100个正常人有1人对试验的反应为阳性，

    ③这批人中，每100个癌症病人有95人对试验的反应为阳性。

   通过普查统计，该医院可开展癌症诊断。

   现在某人试验结果为阳性，根据最小风险贝叶斯决策理论，将此患者预测为患癌症的风险概率为（ C ）。

假设将正常人预测为正常人和将癌症患者预测为癌症患者的损失函数均为0，将癌症患者预测为正常人的损失函数为3，将正常人预测为癌症患者的损失函数为1.

A  75.5%  B 32.3%    C 67.7%     D 96.9%

from：https://blog.csdn.net/qq_30815237/article/details/86571250

14、

k=10

i=0

while k>1:

      print(k)

      i=i+1    

      k=k/2

print(i)

则i最后输出为：4

注意上面是Python3代码,“/”除法会得到小数  (python2代码中输出print 后面不用加小括号，Python2中:a=10.0/3    a=3.33333    b=10/3    b=3)。如果是C++的话，除法规则如下，如果两个操作数中有一个为浮点型，则结果为浮点，如果两个均为整型，则为整除。当整型取浮点时就要强制转换（float）或者(double)

例如：int a = 5;int b = 2;  则a/b的值为2（整除），而用(double)a/b的值则为2.5，用个强制类型转换(double)就行了。

int a = 1.0;int b = 2;则a/b的值为0.5。

15、如当前样本集合D中第K类样本所占的比列为P(k)（k= 1,2,3,…,y），则样本的信息熵最大值为（ C）

A1   B0.5   CLog2(y)     Dlog2(P(y))

 

当p_k相等时，信息熵最大为 -1*log p_k=-1*log (1/y)=Log2(y) 

16、序列[9,14,11,16,21,15,20,31]为小顶堆，在删除堆顶元素9之后，调整后的结果是（ c）

A[14,11,16,21,15,20,31]                     B[11,14,16,21,15,20,31]

C[11,14,15,16,21,31,20]                    D[11,14,15,16,20,21,31]

步骤：删除堆顶，然后总是从堆尾将某个数先放置到堆顶，然后依次下调到符合完全二叉树的要求，即每个子树的两个子节点都比父节点大（最小堆）

from :https://blog.csdn.net/FX677588/article/details/77964912

17、假设测试样本x,若最近邻样本为s,y是类别集合，则KNN分类出错的概率为（c）

A  ∑(b∈y){P(b|x){P(b|s)                                             B 0.5

C  1-∑(b∈y){P(b|x){P(b|s))                                    D  1-∑(b∈y){P(x|b){P(s|b)

给定测试样本x,若其最近邻样本为z,则最近邻分类器出错的概率就是x与z类别标记不同的概率,即

                                      

from :https://yifdu.github.io/2019/01/17/%E8%A5%BF%E7%93%9C%E4%B9%A6%E9%87%8D%E8%AF%BB%EF%BC%88%E4%B9%9D%EF%BC%89/

18、物体在纹理上与其周围背景或其它物体有区别，纹理可以作为图像分析的重要的概念，下列哪一项是关于纹理图像特征描述所用的参数（D）

A对比度、灰度值分布、平均值、行程比

B角度方向二阶矩、熵、灰度值分布、行程比

C角度方向二阶矩、行程比、灰度值分布、行程长度分布

D对比度、角度方向二阶矩、熵、平均值

  行程比用于图像编码

19、在图像增强中，得到边缘锐化、对比度增强的图像，下列说法正确的是 A

A先进行高频加强，再进行直方图均衡化                 B先进行直方图均衡化，再进行高频加强

C先后顺序没有关系                                                D同时进行

     若先进行直方图均衡化，再进行高频加强，对于图像亮度呈现较强的两极现象时，例如多数像素主要分布在极暗区域，而少数像素存在于极亮区域时，先直方图均衡化会导致图像被漂白，再进行高频加强，获得的图像边缘不突出，图像的对比度较差。

图像的高频提升增强：a>=0,b>=a    Hhfe(u,v)=a+bHhp(u,v)     其中a=0.5,b=2.0

                               

from：https://wenku.baidu.com/view/691609fe690203d8ce2f0066f5335a8103d26639.html

19.5、图形中的三种常见距离：

1：欧氏距离，D的平方=(x1-x2)(x1-x2)+(y1-y2)(y1-y2);

2.城市街区距离：D=|x1-x2|+|y1-y2|;

3.棋盘距离：D=MAX{|x1-x2|,|y1-y2|};

20、下列程序的功能是取出浮点数的整数部分，请将横线处缺失程序补充完整（&i ）

void  s(float x, int—— )  {    i=int(x); }

int main()  {  int n; float x; cin >> x; s(x,n);cout<<n<<endl;}

带&的是引用型参数，它是地址传递，其实参会随着形参的改变而改变；不带&的参数是一般参数，是值传递，其实参不会随着形参的改变而改变

21、在分时系统中，时间片设置Q=3,以下关于响应时间的分析，正确的是（ AD

A用户数量越多响应时间越长                   B内存空间越大响应时间越长

C时间片越小响应时间越长                      D进程数量越多响应时间越长

        响应时间=进程数*时间片大小，当进程数一定时，时间片越小，响应时间越短，并且注意响应时间的定义，从提交第一个请求到产生第一个响应所用时间。

     首先需要明确的是，系统的响应时间依赖于时间片的选择，但并不是越小越好。举个例子假设A任务需要运行任务1秒钟，B任务需要运行2秒钟，两个任务轮询执行，假设CPU的时间片为0.5秒，A先执行

理论情况下，A的响应时间为0.5+0.5+0.5=1.5秒，B的响应时间为0.5（A）+0.5（B）+0.5（A）+0.5（B）+0.5（B）+0.5（B） = 3秒，则系统平均响应时间为（3+1.5）/2 =2.25秒

若时间片选为1秒，则A的响应时间为1秒，B的响应时间为3秒，系统平均响应时间为2秒。通过对比，可以看出并不是时间片越小，响应时间越短

22、已知序列(50,30,80,20,40,90,35,85,32,88) ，按照依次插入的方法生成二叉排序树，则在该树中删除关键字值为50的结点后，其二叉排序树的根节点的值可能为（BC）

                          A30    B40    C80     D90

                           

掌握二叉排序树的插入与删除操作：https://blog.csdn.net/qq_30815237/article/details/90548558

23、有下列类定义

class Base

{public:

    Base(int data):_ma(data)  

    {cout<<"Base()"<<endl;}

    ~Base()

    {cout<<"~Base()"<<endl;}

    void Show1()

    {cout<<_ma<<endl;}

private:

    int _ma;};

class D:public Base

{public:

  D(int data):Base(data),_mb(data)  

 {cout<<"D()"<<endl;}

    ~D()

    {cout<<"~D()"<<endl;}

    void Show2()

    {cout<<_mb<<endl;}

private:

    int _mb;};

则语句D d(1); d.Show2();调用构造函数和析构函数的顺序是（Base构造、D构造、D析构、Base析构 

构造函数的调用顺序：
1.基类构造函数。如果有多个基类，则构造函数的调用顺序是某类在类派生表中出现的顺序，而不是它们在成员初始化表中的顺序。
2.成员类对象构造函数。如果有多个成员类对象则构造函数的调用顺序是对象在类中被声明的顺序，而不是它们出现在成员初始化表中的顺序。
3.派生类构造函数。

析构函数的调用顺序与构造函数的调用顺序正好相反，将上面3个点反过来用就可以了，首先调用派生类的析构函数；其次再调用成员类对象的析构函数；最后调用基类的析构函数。

from：https://blog.csdn.net/bresponse/article/details/6914155

24、下列程序的运行结果是1  0，请将横线处缺失程序补充完整（int Test:: y=0;）

class Test{

public:

 Test(){x=1;}

void print(){cout<<x<<"  "<<y<<endl;}

private:

     int x;

     static int y;

};

int____y=0;

int main(){

Test t;

t.print();

return 0;}

双冒号（::）用法:表示“域操作符”. 

   例：声明了一个类A，类A里声明了一个成员函数void f()，但没有在类的声明里给出f的定义，那么在类外定义f时， 就要写成void A::f()，表示这个f()函数是类A的成员函数。此题相当于在类外对成员变量进行初始化。

24、梯度法与Laplacian算子检测边缘的异同点

                     

25、static

# include <stdio.h>
int f(int x){ 
   static y=2;
   ++y;
   x+=y;
   return x;
}
int main(){
 int k;
 k=f(7);
 printf("%d %d\n", k, f(k));
}

以上代码运行的结果是  10  14

static只在第一次调用时，初始化，当执行f(k)，不会再对y 重新进行初始化。

25.1、下面程序的输出结果为：  8  1

int change(int m,int n); 
main () 
{ int aa=40,ab=24,ac,ad; 
  ac=change(aa,ab);
  ad=change(aa-1,ab-2);
  printf("%d,  %d\n",ac,ad); 
｝
int change(int u,int v)
{ static int w; 
   u=u/(w+1);
   v=v/(w+1);
   while(v) 
   { w=u%v; u=v; v=w; } 
   return u; 
}

第一次调用后，static int w默认为0，调用结束后，w=0，第二次调用时，不再初始化，而是直接使用w=0;虽然在本例中二者都是零，但要注意：static变量只会初始化1次，在程序整个运行期间都不释放；

26、针对机器学习算法，下面说法错误的是：:D

AApriori算法分为两个阶段：寻找频繁项集和由频繁项集找关联规则。

BSVM是基于分类边界的分类算法，主要是通过训练，找到这些分类之间的边界。

CAdaboost是一种迭代算法，核心思想是针对同一个训练集训练不同的分类器，然后将这些分类器集合起来，构成一个更强的最终分类器。

DEM算法是在概率模型中寻找参数最小似然估计的算法，其中概率模型依赖于无法观测的隐藏变量。

注释：bagging的分类器不是在同一训练集上得到的；EM算法是在概率模型中寻找参数最大似然估计的算法

27、若用一个大小为7的数组来实现循环队列，且当前front和rear的值分别为3和0，当从队列中删除一个元素，再加入两个元素后，front和rear的值分别是（  4和2  ）

28、判定一个有向图上是否存在回路除了可以利用拓扑排序方法外，还可以用： C 

A求关键路径的方法

B广度优先遍历算法

C深度优先遍历算法

D求最短路径的Dijkstra方法

from：https://blog.csdn.net/qq_30815237/article/details/88804399

29、在下列排序方法中，不稳定的方法有   C

A归并排序（稳定）与基数排序（稳定）                           B插进排序（稳定）与希尔排序（不稳定）

C堆排序与快速排序    （不稳定）                                 D选择排序（不稳定）与冒泡排序(稳定)

选择排序：3 3 2 1  :1 3 2 3   :1 2 3 3

希尔：3   5  10  8  7  2  8  1  20  6  分成2组  （3  10  7  8  20） 和（5  8  2  1  6） 排序后（3  7  8  10  20）和 （1  2  5  6  8）

快速：假设此时的快排是小于关键字为排在前面的一组,：1 3 5 3  ： 1 3 3 5

from：https://blog.csdn.net/qq_30815237/article/details/88646699

30、 假定AB为一个类，则执行"AB a(2),b[3],*p[4] ;" 语句调用该类构造函数的次数为（B）
             A.3 B.4 C.5 D.6

因为有4个对象被构建。a(4)是一个，b[3]是三个，至于 *p[2] 这个是指针数组，只是包含两个指针，不会调用AB类的构造函数

31、在 int a = 3,int *p = &a ;中，*p的值为（D）
       A.变量a的地址值 B.未定义              C.变量p的地址值 D.3

可以分解为：int a=3; int *p ;    # *p是定义一个指针变量p

p=&a;  将a的地址赋给指针,p指向a的地址，p存放a所在的地址。所以第二个*p是从p指向的地址中得到值

32、template＜class Q＞
       Q Sum(Q x，Q y)
     return(x)+(y)；
则下列语句中对该函数模板的使用错误的是( D)
A．Sum(10，2)；                 B．Sum(5.0，6.7)；
C．Sum(15.2f，16.0f)；      D．Sum("AB"，"CD")；

 由Q Sum(Q x，Q y)可知形参和函数返回值都是同一种数据类型。A、B、C三项都正确。而D项用字符串作为实参，字符串的操作与数值类型不同，要用特殊方法进行字符串的连接和运算。

33、已知f1和f2 是同一类两个成员函数，但是f1不能直接调用f2,这说明（C）
A.f1和f2都是静态函数 B.f1不是静态函数  C.f1是静态函数，f2不是静态函数 D.f1和f2 都不是静态函数

普通成员函数可以调用静态函数，相反静态函数不能调用普通成员函数

34 下面的程序合法吗？如果合法，它将输出什么？

int main()
{
    int i = 100, sum = 0;
    for (int i = 0; i != 10; ++i){
        sum += i;
        cout << i << " " << sum << endl;}
	cout<<i;
}

35\\一个静态变量，是静态存储的，而不是在栈上，也就是说你不退出程序的情况下，下一次访问时它的值是上一次执行后的值，不像其它变量一样调用完成后就被释放。

    静态变量在func函数退出后继续保存，下次fun在执行时直接读取保存的值,不再赋值初始化。i依次为：6 7 8 9 10.循环5次。

static int func(int j ){
static int i = j;   //静态变量只初始化依次
return ++i;
}
 
 
int main(int argc, chr * argv[]){
int i = 0;
int j = 5; 
for (;j != 0; --j){
i = fun(j);
}
std::cout << i << std::endl;
return 0;
}

36、函数调用func((exp1,exp2),(exp3,exp4,exp5))中所含实参的个数为（2）

逗号是一个运算符，其运算过程为依次计算左右操作数并返回右操作数的右值（即不可写值）。所以func( (exp1,exp2),(exp3,exp4,exp5) );相当于func(exp2, exp5);

37、要禁止修改指针p本身，又要禁止修改p所指向的数据，这样的指针应定义为( D)

A．const char*p=“ABCD”； 
B．char*const p=“ABCD”；
C．char const*p=“ABCD”； 
D．const char*const p=“ABCD”；

const char*p说明禁止通过p修改所指向的数据。char*cons p则说明不能修改指针p的地址。因此const char*const p="ABCD"；表示既禁止修改指针p本身，又禁止修改p所指向的数据。

38、维纳滤波也称最小均方误差滤波，它能处理被退化函数退化和噪声污染的图像。该滤波方法建立在图像和噪声都是随机变量的基础之上，目标是找到未污染图像f(x,y)的一个估计，使它们之间的均方误差最小，均方误差函数的最小值在频率域由如下表达式给出：

                                                 

其中，G(u,v)是退化后图像的傅里叶变换，H(u,v)是退化函数的傅里叶变换，H*(u,v)为H(u,v)的复共轭，|H(u,v)|^2=H(u,v)H*(u,v)，Sη(u,v)=|N(u,v)|^2=噪声的功率谱，Sf(u,v)=|F(u,v)|^2=未退化图像的功率谱，

从上面的公式可以发现，如没有噪声，即Sη(u,v)=0，此时维纳滤波变为直接逆滤波，

from：https://blog.csdn.net/yi_tech_blog/article/details/53958082

39、哪个是错的（3）

1头文件在预处理阶段展开

2宏定义在预处理阶段就会被展开

3汇编阶段，把C语言转为汇编语言

概率题1：甲乙丙三人猜谜语，猜对的概率分别是0.8,0.7,0.6.已知只有一人猜对，求甲猜对的概率。

P(甲猜对|只有一人猜对）=（0.8*0.3*0.4）/(0.8*0.3*0.4+0.2*0.7*0.4+0.2*0.3*0.6)

2 互斥事件与对立事件的区别

互斥事件仅仅是要求俩个事件不能同时发生。

对立事件是如果两个事件一个不发生则另一个事件一定发生,即两个事件互斥同时还共同构成一个全集。

例如：甲乙比赛，事件={甲胜乙负}的对立事件为{甲败或平局}