实验三 分治算法
分治算法课程思政
分治算法课程思政分治算法是一种常见的算法设计方法，它将一个大问题分解成若干个小问题，然后逐个解决这些小问题，最后将结果合并得到原问题的解。
这种算法思想在计算机科学中有着广泛的应用，不仅可以解决各种复杂的问题，还可以优化算法的时间复杂度。
在分治算法中，首先需要将原问题划分成若干个规模较小的子问题。
这种划分要求子问题的规模要比原问题小且相互独立。
然后，对每个子问题进行递归求解，直到子问题的规模足够小，可以直接求解为止。
最后，将子问题的解合并起来，得到原问题的解。
分治算法的基本步骤如下：1. 分解：将原问题划分成若干个规模较小的子问题；2. 解决：递归地求解每个子问题；3. 合并：将子问题的解合并起来，得到原问题的解。
分治算法的关键在于如何将原问题划分成子问题。
一般来说，划分子问题的方法有很多种，可以根据具体问题的特点选择合适的划分方式。
常见的划分方法有二分法、多项式拆分法、均匀划分法等。
分治算法的优势在于能够将原问题分解成多个规模较小的子问题，从而降低问题的复杂度。
通过递归地求解子问题，可以大大提高算法的效率。
此外，分治算法还具有天然的并行性，可以通过并行计算进一步提高算法的速度。
分治算法在实际应用中有着广泛的应用。
比如在排序算法中，快速排序和归并排序都是基于分治算法的思想。
在图像处理中，分治算法可以用来实现图像的分割和合并。
在并行计算中，分治算法可以用来解决任务的划分和合并问题。
然而，分治算法也存在一些限制和不足之处。
首先，分治算法要求子问题的规模要比原问题小且相互独立，这在某些问题中并不容易实现。
其次，分治算法在解决一些问题时可能会产生重复计算，导致算法效率降低。
此外，分治算法的实现需要额外的空间来存储子问题的解，这在一些资源受限的环境下可能会成为问题。
在实际应用中，我们需要根据具体问题的特点来选择合适的算法设计方法。
分治算法作为一种常见的算法思想，在解决一些复杂的问题时具有明显的优势。
通过将原问题分解成若干个规模较小的子问题，并递归地求解这些子问题，最后将结果合并得到原问题的解。
分治算法实验
分治算法实验（用分治法查找数组元素的最大值和最小值）算法分析与设计实验报告第一次实验实验步骤关键代码}else//当数组中元素个数少于2时，直接赋值处理1. 先解决小规模的问题，如数组中只有1个元素或者只有两个元素时候的情况。
2. 将问题分解，如果数组的元素大于等于3个，将数组分为两个小的数组。
3. 递归的解各子问题，将中分解的两个小的数组再进行以上两个步骤最后都化为小规模问题。
4. 将各子问题的解进行比较最终得到原问题的解。
//分治法处理整个数组，求出最大值与最小值void merge( int a[], int left, int right, int &Max, int &Min){int max1=0,min 1=0,max2=0,min2=0;if (right-left>2) //当数组中元素个数大于3时，才实行分治法{int mid=(right+left)/2;merge(a,left,mid,max1,mi n1);//左半边递归调用自身，求岀最大值与最小值，分别保存在max1,min1中merge(a,mid+1,right,max2,mi n2);//右半边递归调用自身，求岀最大值与最小值，分别保存在max2,min2中if (max1>=max2)Max=max1; //子序列两两合并，求岀最大值与最小值elseMax=max2; //分别保存在Max与Minif (min1<=min2)Min=mi n1;elseMin=mi n2;测试结果实验心得Max=compmax(a,left,right);Min=compmi n( a,left,right);}}利用分治法（递归实现）：非递归实现:请输入数据克1000093 32767The tine is1990003276? 9The tine is1000032767 0TJ IE tine is1000 32767 9The time is3276? RThe tine is內.0060-004TO通解，明白了分治法到底是怎样的一个过程，在代码实现分治法的时候，也使我加深了对于自己构造函数的理解，明白了分治法利用代码是怎样实现的，以及构造函数的传参与返回值等等地方需要注意的F;\鮒实验沁［p || B附录：完整代码（分治法）#include <iostream>#inelude <time.h>#include <iomanip> using namespacestd;//当数组中的元素个数小于3时，处理最大值int compmax(int A[], int start, int end) {int max;if (start<end) //有两个元素{if (A[start]<=A[end]) max=A[e nd];elsemax=A[start];}else //有一个元素max=A[start];return max;}//当数组中元素的个数小于2时，处理最小值int compmin(int A[], int start, int end){int min;if (start<end) //有两个元素{if (A[start]<=A[end]) mi n= A[start];elsemin= A[e nd];}else //有一个元素mi n=A[start];return mi n;}//分治法处理整个数组，求最大值与最小值void merge( int a[], int left, int right, int &Max,int &Min) 〃Max,Min 用来保存最大值与最小值//之所以使用&引用，是由于如果只是简单的使用变量，并不会改变Ma>与Min的值，使用指针也可以{int max1=0,min 1=0,max2=0,min2=0;if (right-left>2) //当数组中元素个数大于等于3时，进行分治{int mid=(right+left)/2;merge(a,left,mid,max1,min1); //左半边递归调用自身，求出最大值最小值，分别保存在max1,min1中merge(a,mid+1,right,max2,min2); //右半边递归调用自身，求出最大值最小值，分别保存在max2,min2中if (max1>=max2) //子序列两两合并，求出最大值与最小值，保存在Max与Mi n 中Max=max1;elseMax=max2;if (min 1<=min2)Min=min1;elseMin=min 2;}else //数组中元素个数小于3时的情况，直接赋值{Max=compmax(a,left,right);Mi n=compmi n( a,left,right);}}void ran( int *input, int n) //随机生成数组元素函数{int i;sran d(time(0)); for(i=0;i<n;i++) input[i]=ra nd();input[i]= '\0';}int a[1000000]; //定义全局变量用来存放要查找的数组int main(){int n;int i;int max;int min;coutvv "请输入要查找的序列个数:"<<e ndl;for (i=0;i<5;i++){cin>>n;ran (a,n);start=clock();en d=clock();over=end-start;start=clock();//调用分治法算法merge(a,0, n-1,max,min);coutvvmax<<‘ " vvminvvendl;en d=clock();printf( "The time is %6.3f" ,( double )(end-start-over)/CLK_TCK); //显示运行时间}system( "pause"); // 停止运行窗口return 0;}完整代码(非递归方法)#include <iostream>#include <time.h>#include <iomanip> usingnamespacestd;void ran( int *input, int n) {//随机生成数组元素函数int i;sran d(time(0));for (i=0;i<n;i++)in put[i]=ra nd();input[i]= '\0';}int a[1000000];int main(){int max=a[0],min=a[0];int i,j,n;cout<<"请输入数据规模: "<<e ndl;for (j=0;j<5;j++){cin»n;ran( a, n);clock_t start,e nd,over;//计算程序运行时间的算法start=clock();en d=clock();start=clock(); for(i=1;i<n;i++) {if (a[i]>max)max=a[i];if (a[i]<min) min=a[i];}coutvvmax<<‘ " vvminvvendl;en d=clock();printf( "The time is %6.3f" ,( double )(end-start-over)/CLK_TCK); // 显示运行时间}system( "pause");return 0;}。
如何应用分治算法求解问题
如何应用分治算法求解问题分治算法，英文名为Divide and Conquer Algorithm，是一种高效的算法设计策略，在计算机科学中有着广泛的应用。
该算法将一个大问题分解成多个小问题，各自独立地解决，再将结果合并起来得到最终结果。
在本文中，我们将阐述如何应用分治算法求解问题，并通过几个实例来具体说明该算法的应用。
一、分治算法的原理分治算法的核心思想是将一个大问题分解成若干个小问题来解决，然后将这些小问题的解组合起来生成大问题的解。
其具体步骤如下：1. 分解：将原问题划分成若干个规模较小的子问题。
2. 解决：递归地解决每个子问题。
如果子问题足够小，则直接求解。
3. 合并：将所有子问题的解合并成原问题的解。
分治算法的主要优点在于它可以有效地缩小问题规模，从而缩短整个算法的执行时间。
另外，该算法天然适用于并行计算，因为每个子问题都是独立求解的。
二、分治算法的应用分治算法在各种领域都有广泛应用，包括数学、自然科学、计算机科学等。
以计算机科学领域为例，分治算法常常用于解决以下类型的问题：1. 排序问题2. 查找问题3. 字符串匹配问题4. 最大子序列和问题5. 矩阵乘法问题6. 图形问题下面我们将一一讲解这些问题的分治算法实现。
1. 排序问题排序问题是在一组数据中将其按指定规律进行排列的问题。
在计算机科学中，排序算法是十分重要的一类算法。
其中，分治算法由于其高效性和可并行性被广泛应用。
常用的分治排序算法包括归并排序和快速排序。
归并排序的基本思想是将待排序元素以中心点为界分成两个序列，对每个序列进行排序，然后将两个序列合并成一个有序序列；而快速排序则利用了分割的思想，通过每次选取一个元素作为“轴点”，将数组分成小于轴点和大于轴点的两部分，对这两部分分别进行快速排序。
2. 查找问题查找问题是在一组数据中寻找某个元素的问题。
分治算法在查找问题中的应用主要体现在二分查找中。
在二分查找中，我们首先将已排序的数组分成两半，在其中一半中查找目标值。
分治算法的实验报告
一、实验背景分治算法是一种常用的算法设计方法，其基本思想是将一个复杂问题分解成若干个相互独立的小问题，然后将小问题递归求解，最终将子问题的解合并为原问题的解。
分治算法具有高效性、可扩展性和易于实现等优点，被广泛应用于各个领域。
本实验旨在通过实现分治算法解决实际问题，掌握分治算法的设计思想，并分析其时间复杂度。
二、实验目的1. 理解分治算法的基本思想；2. 掌握分治算法的递归实现方法；3. 分析分治算法的时间复杂度；4. 应用分治算法解决实际问题。
三、实验内容本实验选择两个分治算法：快速排序和合并排序。
1. 快速排序快速排序是一种高效的排序算法，其基本思想是将待排序序列分为两个子序列，其中一个子序列的所有元素均小于另一个子序列的所有元素，然后递归地对两个子序列进行快速排序。
（1）算法描述：① 选择一个基准值（pivot），通常取序列的第一个元素；② 将序列分为两个子序列，一个子序列包含所有小于基准值的元素，另一个子序列包含所有大于基准值的元素；③ 递归地对两个子序列进行快速排序。
（2）代码实现：```cvoid quickSort(int arr[], int left, int right) {if (left < right) {int pivot = arr[left];int i = left;int j = right;while (i < j) {while (i < j && arr[j] >= pivot) {j--;}arr[i] = arr[j];while (i < j && arr[i] <= pivot) {i++;}arr[j] = arr[i];}arr[i] = pivot;quickSort(arr, left, i - 1);quickSort(arr, i + 1, right);}}```2. 合并排序合并排序是一种稳定的排序算法，其基本思想是将待排序序列分为两个子序列，分别对两个子序列进行排序，然后将排序后的子序列合并为一个有序序列。
分治算法实验报告
算法分析与设计实验报告第 1 次实验if（maxi>maxj)max=maxi；elsemax=maxj；if（mini<minj)min=mini;elsemin=minj;return；｝}srand(（unsigned int)time(NULL)）；cout <〈”随机产生的数据（0—100）：”;for（int i=0； i〈m; i++）a[i] = rand(）%100；测试结果附录：完整代码SelectMaxMin.cpp:＃include <iostream>＃include <ctime>＃include 〈cstdio>#include <iomanip>＃include 〈cstdlib〉using namespace std;void SelectMaxMin（int ＊a，int i，int j,int &max,int ＆min) ｛if（i==j)｛max= a[i];min =a［i]；return;}else｛int mid=（i+j)/2;int maxi，maxj，mini，minj;SelectMaxMin（a,i，（i+j）/2,maxi,mini）;SelectMaxMin(a，((i+j）/2）+1,j，maxj，minj);if（maxi〉maxj)max=maxi;elsemax=maxj;if(mini<minj)min=mini；elsemin=minj;return;}}int main（）{clock_t start,end，over；start=clock();end=clock();over=end—start;start=clock(）；//freopen（"in。
txt",”r"，stdin）；//freopen(”out。
txt”，”w"，stdout);int m；cout 〈<"Please input the number : ”;cin>〉 m；int a［m]；srand((unsigned int）time(NULL））;cout 〈〈 "随机产生的数据（0-100)："；for（int i=0; i〈m; i++）a［i] = rand（)％100；for(int i=0； i〈m; i++)cout <〈 a[i] 〈< " ";cout 〈< endl；int max，min;SelectMaxMin(a,0,m-1,max,min）;cout 〈< "max = " 〈〈 max 〈〈 endl;cout <〈”min = " <〈 min 〈〈 endl；end=clock（)；printf（”The time is %6.3f”,（double）(end-start—over）/CLK_TCK）; ｝。
分治算法举例范文
分治算法举例范文分治算法是一种很重要的算法思想，它将一个大的问题划分成较小的子问题，然后分别求解这些子问题，最后将子问题的解合并起来得到原问题的解。
下面我将详细介绍分治算法的几个经典例子。
1. 快速排序（Quick Sort）快速排序是一种经典的使用分治算法的排序算法。
它首先选择一个基准元素，然后将数组划分成两个子数组：小于基准元素的和大于基准元素的。
然后对这两个子数组分别递归地进行快速排序，最后将两个子数组合并起来即可得到有序的数组。
快速排序的时间复杂度为O(nlogn)。
2. 归并排序（Merge Sort）归并排序也是一种利用分治思想的排序算法。
它将待排序的数组划分成两个子数组，然后分别对这两个子数组进行归并排序，最后将两个有序的子数组合并成一个有序的数组。
归并排序的时间复杂度也是O(nlogn)。
3. 汉诺塔问题（Tower of Hanoi）汉诺塔问题是数学领域中一个经典的问题，也可以通过分治算法来解决。
问题的规模是将n个圆盘从一个柱子移动到另一个柱子上，移动时需要遵守以下规则：每次只能移动一个盘子，移动过程中不能将较大的盘子放在较小的盘子上。
可以将问题划分成三个子问题：将前n-1个盘子从起始柱子移动到中间柱子上，将最后一个盘子从起始柱子移动到目标柱子上，最后将前n-1个盘子从中间柱子移动到目标柱子上。
这样就可以递归地求解子问题，最后合并起来得到原问题的解。
4. 最大子数组和问题（Maximum Subarray）最大子数组和问题是求解给定数组中连续子数组的最大和的问题。
可以使用分治算法来解决这个问题。
首先将数组划分成两个子数组，然后分别求解这两个子数组中的最大子数组和。
接下来，需要考虑跨越中点的情况，即包含中点的子数组的最大和。
最后，将这三种情况中的最大值作为最终的结果。
最大子数组和问题的时间复杂度为O(nlogn)。
5. 矩阵乘法（Matrix Multiplication）矩阵乘法也可以通过分治算法来实现。
最近点对算法 C++
实验三最近点对1.算法设计思路：设共有n个点，找其中距离最近的两点及其距离。
（1）蛮力法：蛮力法的思路是把所有点之间距离比较找出中间最小的。
先假设最短距离是第一个元素和第二个元素的距离，然后求第一个元素与其后的（n-1）个元素各自的距离，若比之前记录的最短距离小则记录当前值···求第i个元素与其后的（n-i）个元素各自的距离，记录之前所得到的所有距离中的最小值，直到计算到第（n-1）个元素与第n个元素的距离，此时记录的距离即为这n个元素中的最短距离。
（2）分治法：分治法是把一个大的问题划分成相似的小问题，采用递归的思想。
找中线把n个元素分成左右两部分元素分别求得两边的最短距离，然后取两者中的最小者记为l，在中线两边分别取l的距离，记录该距离范围内点的个数，中线左边有L个元素，右边有R个元素，求左边元素到右边元素的距离看其是否小于之前记录的最短距离，小则记录下来，此时的右边元素只取y值和左边元素y值距离小于l的（减少循环次数）。
循环结束即可找到最小的距离。
2.程序代码：#include<iostream>#include<cstdlib>#include<ctime>#include<cmath>using std::cout;using std::endl;#define N 5int x[N],y[N],record[N]; //产生原始点数据，x坐标放在x[]中，y坐标放在y[]中。
double Min;//////////////////////////产生随机数组/////////////////////////////void randnum(){int i;srand(time(0));for (i=0;i<N;i++){x[i]=rand()%N;cout<<x[i]<<' ';}cout<<endl;for (i=0;i<N;i++){y[i]=rand()%N;cout<<y[i]<<' ';}cout<<endl;}//////////////////////////////交换数组元素/////////////////////////// void swap(int & a, int & b){int temp=a;a=b;b=temp;}///////////////////////////////求平方///////////////////////////////////int square(int x){return x*x;}/////////////////////////////////////求两点之间距离////////////////////double lengthf(int x1,int y1,int x2,int y2){return sqrt(square(x1-x2)+square(y1-y2));}//////////////////////////////////求两者中最小者////////////////////// double min(double a,double b){if (a>=b)return b;elsereturn a;}////////////////////////////对平面数组排序//////////////////////////// void sort(int A[]){int i,j;for (i=0;i<N;i++)record[i]=i;for (j=1;j<N;j++){i=j;while (i>=0&&A[i]<A[i-1]){swap(A[i],A[i-1]);swap(record[i-1],record[i]); //得到x排序后对应的原y的坐标i--;}}cout<<"排序后的元素数组："<<endl;for (i=0;i<N;i++)cout<<A[i]<<' ';cout<<endl;for (i=0;i<N;i++)cout<<record[i]<<' ';cout<<endl;}///////////////////////////穷举法找最小点对///////////////////////////////double exhaustion(){int i,j,k1,k2;double num;double length;num=10000;k1=k2=-1;for (j=0;j<N-1;j++){for (i=j+1;i<N;i++){length=lengthf(x[i],y[i],x[j],y[j]);if (length<num){num=length;k1=i;k2=j;}}}cout<<"平面数组最短距离是："<<endl;cout<<"min="<<num<<endl;cout<<"对应数组下标及点坐标为："<<endl;cout<<"i="<<k1<<','<<k2<<endl;cout<<"(x1,y1)="<<'('<<x[k1]<<','<<y[k1]<<')'<<endl<<"(x2,y2)="<<'('<<x[k2]<<','<<y[k2]<<')' <<endl;return num;}////////////////////////////////////分治法////////////////////////////////*************************************************************************/double merge(int left,int right){double mlength;if (right==left)mlength=10e-6;if (right==left+1)mlength=lengthf(x[right],y[record[right]],x[left],y[record[left]]); //两个点时求最小值if (right-left==2)mlength=min(min(lengthf(x[right-1],y[record[right-1]],x[left],y[record[left]]),lengthf(x[right],y[re cord[right]],x[left+1],y[record[left+1]])),lengthf(x[right],y[record[right]],x[left],y[record[left]]));//三个点时求最大值return mlength;}double divide(int left,int right){if (right-left<=2){Min=merge(left,right);}else{double l1,l2,mi; //l1记录划分区域后左半面最小距离，l2记录右半面最小距离，min为两者中较小者，m为全部中的最小者int rem1,rem2,l; //记录获得最短距离对应的两个点//int il,jl,ir,jr;int i,j;int R,L;R=L=0; //记录划分小区域后的左半块和右半块个有多少元素l1=l2=Min=100;l=(right-left+1)/2-1; //中线位置///////////////////////////////////////////////////l1=divide(left,l);l2=divide(l+1,right);if (l1<l2){Min=l1;//cout<<"两半面最短距离是："<<min;else{Min=l2;//cout<<"两半面最短距离是："<<min;}///////////////////得到右半块元素数R//cout<<"min="<<min<<endl;for (i=l+1;i<N;i++){if (x[i]-x[l]<=Min)R++;else break;}//cout<<"R="<<R<<endl;/////////////////////得到左半块元素数Lfor (i=l;i>=0;i--){if (x[l]-x[i]<=Min)L++;else break;}//cout<<"L="<<L<<endl;if (L!=0&&R!=0){for (i=l-L+1;i<=l;i++)for (j=l+1;j<=l+R;j++){if (y[record[j]]-y[record[i]]<Min||-Min<y[record[j]]-y[record[i]]){mi=lengthf(x[i],y[record[i]],x[j],y[record[j]]);if (mi<Min){Min=mi;rem1=i;rem2=j;}}}// cout<<"min="<<min<<endl;//cout<<"rem1="<<rem1<<endl<<"rem2="<<rem2<<endl;}return Min;}/***********************************************************************///////////////////////////////////主函数///////////////////////////////////int main(){//double a;randnum();cout<<"***************************遍历法*************************"<<endl;exhaustion();cout<<"***************************分治法*************************"<<endl;sort(x);divide(0,N-1);cout<<"元素组中最短距离为："<<endl;cout<<"min="<<Min<<endl;return 0;}3.实验数据及实验结果：实验数据：随机产生的五个点坐标分别为：（1，3），（4，2），（3，0），（2，0），（0，3）实验结果：用蛮力法得到平面数组最短距离为：min=1用分治法得到平面数组最短距离为：min=14.实验总结：从本次试验中得到的领悟是：分治法事把问题分解成两个相似小问题，子问题和原来的大问题解决方法一样所以可以用递归，分治法重要是找到递归出口，什么时候递归结束，一般都有元素个数的限制。
数据结构实验报告-排序
数据结构实验报告-排序一、实验目的本实验旨在探究不同的排序算法在处理大数据量时的效率和性能表现，并对比它们的优缺点。
二、实验内容本次实验共选择了三种常见的排序算法：冒泡排序、快速排序和归并排序。
三个算法将在同一组随机生成的数据集上进行排序，并记录其性能指标，包括排序时间和所占用的内存空间。
三、实验步骤1. 数据的生成在实验开始前，首先生成一组随机数据作为排序的输入。
定义一个具有大数据量的数组，并随机生成一组在指定范围内的整数，用于后续排序算法的比较。
2. 冒泡排序冒泡排序是一种简单直观的排序算法。
其基本思想是从待排序的数据序列中逐个比较相邻元素的大小，并依次交换，从而将最大（或最小）的元素冒泡到序列的末尾。
重复该过程直到所有数据排序完成。
3. 快速排序快速排序是一种分治策略的排序算法，效率较高。
它将待排序的序列划分成两个子序列，其中一个子序列的所有元素都小于等于另一个子序列的所有元素。
然后对两个子序列分别递归地进行快速排序。
4. 归并排序归并排序是一种稳定的排序算法，使用分治策略将序列拆分成较小的子序列，然后递归地对子序列进行排序，最后再将子序列合并成有序的输出序列。
归并排序相对于其他算法的优势在于其稳定性和对大数据量的高效处理。
四、实验结果经过多次实验，我们得到了以下结果：1. 冒泡排序在数据量较小时，冒泡排序表现良好，但随着数据规模的增大，其性能明显下降。
排序时间随数据量的增长呈平方级别增加。
2. 快速排序相比冒泡排序，快速排序在大数据量下的表现更佳。
它的排序时间线性增长，且具有较低的内存占用。
3. 归并排序归并排序在各种数据规模下都有较好的表现。
它的排序时间与数据量呈对数级别增长，且对内存的使用相对较高。
五、实验分析根据实验结果，我们可以得出以下结论：1. 冒泡排序适用于数据较小的排序任务，但面对大数据量时表现较差，不推荐用于处理大规模数据。
2. 快速排序是一种高效的排序算法，适用于各种数据规模。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验三分治算法（4学时）
一、实验目的与要求
1、熟悉二分搜索算法和快速排序算法；
2、初步掌握分治算法；
二、实验题
1、设a[0:n-1]是一个已排好序的数组。
请改写二分搜索算法，使得当搜索元素x不在数组中时，返回小于x的最大元素的位置i和大于x的最小元素位置j。
当搜索元素在数组中时，I和j相同，均为x在数组中的位置。
设有n个不同的整数排好序后存放于t[0:n-1]中，若存在一个下标i，0≤i＜n，使得t[i]=i，设计一个有效的算法找到这个下标。
要求算法在最坏的情况下的计算时间为O（logn）。
2、在快速排序中，记录的比较和交换是从两端向中间进行的，关键字较大的记录一次就能交换到后面单元，关键字较小的记录一次就能交换到前面单元，记录每次移动的距离较大，因而总的比较和移动次数较少。
三、实验提示
1、用i，j做参数，且采用传递引用或指针的形式带回值。
2、。