算法分析实验报告--分治策略

分治算法实验（用分治法查找数组元素的最大值和最小值）算法分析与设计实验报告第一次实验实验步骤关键代码}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;}。

算法分析与设计实验报告第 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）; ｝。

《算法设计与分析》实验报告实验一递归与分治策略应用基础学号：**************姓名：*************班级：*************日期：2014-2015学年第1学期第九周一、实验目的1、理解递归的概念和分治法的基本思想2、了解适用递归与分治策略的问题类型，并能设计相应的分治策略算法3、掌握递归与分治算法时间空间复杂度分析，以及问题复杂性分析方法二、实验内容任务：以下题目要求应用递归与分治策略设计解决方案，本次实验成绩按百分制计，完成各小题的得分如下，每小题要求算法描述准确且程序运行正确。

1、求n个元素的全排。

（30分）2、解决一个2k*2k的特殊棋牌上的L型骨牌覆盖问题。

（30分）3、设有n=2k个运动员要进行网球循环赛。

设计一个满足要求的比赛日程表。

（40分）提交结果：算法设计分析思路、源代码及其分析说明和测试运行报告。

三、设计分析四、算法描述及程序五、测试与分析六、实验总结与体会#include "iostream"using namespace std;#define N 100void Perm(int* list, int k, int m){if (k == m){for (int i=0; i<m; i++)cout << list[i] << " ";cout << endl;return;}else{for (int i=m; i<k; i++){swap(list[m], list[i]);Perm(list, k, m+1);swap(list[m], list[i]);}}}void swap(int a,int b){int temp;temp=a;a=b;b=temp;}int main(){int i,n;int a[N];cout<<"请输入排列数据总个数：";cin>>n;cout<<"请输入数据：";for(i=0;i<n;i++){cin>>a[i];}cout<<"该数据的全排列："<<endl;Perm(a,n,0);return 0;}《算法设计与分析》实验报告实验二递归与分治策略应用提高学号：**************姓名：*************班级：*************日期：2014-2015学年第1学期一、实验目的1、深入理解递归的概念和分治法的基本思想2、正确使用递归与分治策略设计相应的问题的算法3、掌握递归与分治算法时间空间复杂度分析，以及问题复杂性分析方法二、实验内容任务：从以下题目中任选一题完成，要求应用递归与分治策略设计解决方案。

分治法实验心得分治法实验心得分治法是一种常见的算法设计策略，它将原问题划分成若干个规模较小但结构与原问题相似的子问题，然后递归地求解这些子问题，最终将子问题的解合并得到原问题的解。

在本次实验中，我们实现了两个基于分治法的算法：归并排序和快速排序，并对它们进行了性能测试和比较。

一、归并排序1. 原理归并排序是一种典型的分治算法。

它将待排序数组不断地二分为两个子数组，直到每个子数组只剩下一个元素。

然后将相邻的两个子数组合并成一个有序数组，再将相邻的两个有序数组合并成一个更大的有序数组，直到最终合并成整个待排序数组。

2. 实现我们采用了自顶向下的递归方式实现了归并排序。

具体来说，我们定义了一个merge函数用于合并两个有序子数组，并定义了一个sort 函数用于递归地对左右两个子数组进行排序和合并。

3. 性能测试与比较我们使用Python内置的time模块对不同规模（10^2 ~ 10^6）的随机整数列表进行了性能测试，并绘制出了运行时间随数组规模增大的变化曲线。

结果表明，归并排序的时间复杂度为O(nlogn)，与理论分析相符。

二、快速排序1. 原理快速排序也是一种分治算法。

它选择一个基准元素，将数组中小于等于它的元素放在其左侧，大于它的元素放在其右侧。

然后递归地对左右两个子数组进行同样的操作，直到每个子数组只剩下一个元素。

2. 实现我们实现了两个版本的快速排序：递归版本和非递归版本。

其中，递归版本采用了经典的Lomuto分区方案，而非递归版本则采用了更高效的Hoare分区方案。

3. 性能测试与比较我们同样使用Python内置的time模块对不同规模（10^2 ~ 10^6）的随机整数列表进行了性能测试，并绘制出了运行时间随数组规模增大的变化曲线。

结果表明，快速排序具有很好的平均时间复杂度（O(nlogn)），但最坏情况下时间复杂度会退化到O(n^2)。

三、总结与思考通过本次实验，我们深入理解了分治算法设计策略，并学会了如何实现归并排序和快速排序。

算法设计与分析：递归与分治法-实验报告(总8页)实验目的：掌握递归与分治法的基本思想和应用，学会设计和实现递归算法和分治算法，能够分析和评价算法的时间复杂度和空间复杂度。

实验内容：1.递归算法的设计与实现3.算法的时间复杂度和空间复杂度分析实验步骤：1）递归定义：一个函数或过程，在其定义或实现中，直接或间接地调用自身的方法，被成为递归。

递归算法是一种控制结构，它包含了解决问题的基础情境，也包含了递归处理的情境。

2）递归特点：递归算法具有以下特点：①依赖于递归问题的部分解被划分为若干较小的部分。

②问题的规模可以通过递推式递减，最终递归终止。

③当问题的规模足够小时，可以直接求解。

3）递归实现步骤：①确定函数的定义②确定递归终止条件③确定递归调用的过程4）经典实例：斐波那契数列递推式：f(n) = f(n-1) + f(n-2)int fib(int n) {if (n <= 0)return 0;else}5）优化递归算法：避免重复计算例如，上述斐波那契数列的递归算法会重复计算一些中间结果，影响效率。

可以使用动态规划技术，将算法改为非递归形式。

int f1 = 0, f2 = 1;for (int i = 2; i <= n; i++) {f1 = f2;使用循环避免递归，重复计算可以大大减少，提高效率。

1）分治算法的定义：将原问题分解成若干个规模较小且类似的子问题，递归求解子问题，然后合并各子问题得到原问题的解。

2）分治算法流程：②将问题分解成若干个规模较小的子问题。

③递归地解决各子问题。

④将各子问题的解合并成原问题的解。

3）分治算法实例：归并排序归并排序是一种基于分治思想的经典排序算法。

排序流程：②分别对各子数组递归进行归并排序。

③将已经排序好的各子数组合并成最终的排序结果。

实现源代码：void mergeSort(int* arr, int left, int right) {if (left >= right)while (i <= mid && j <= right)temp[k++] = arr[i] < arr[j] ? arr[i++] : arr[j++];temp[k++] = arr[i++];1) 时间复杂度的概念：指完成算法所需的计算次数或操作次数。

一、实验背景分治策略是一种常用的算法设计思想，它将一个复杂的问题分解成若干个相互独立、规模较小的子问题，分别解决这些子问题，再将子问题的解合并，从而得到原问题的解。

本实验旨在通过具体案例，深入理解分治策略的基本思想，掌握其应用方法，并分析其实际效果。

二、实验目的1. 理解分治策略的基本思想；2. 掌握分治策略的应用方法；3. 分析分治策略在解决实际问题中的效果；4. 提高算法设计与分析能力。

三、实验内容1. 分治策略案例分析实验中，我们选择了以下案例进行分析：（1）归并排序归并排序是一种典型的分治策略应用。

它将待排序的序列分为两半，分别对这两半进行归并排序，然后将两个有序序列合并为一个有序序列。

（2）二分查找二分查找也是一种分治策略应用。

它将待查找的序列分为两半，根据查找目标值与中间值的大小关系，确定目标值所在的一半，然后在该半序列中继续查找。

2. 分治策略实现（1）归并排序实现```cvoid mergeSort(int arr[], int left, int right) {if (left < right) {int mid = (left + right) / 2;mergeSort(arr, left, mid);mergeSort(arr, mid + 1, right);merge(arr, left, mid, right);}}void merge(int arr[], int left, int mid, int right) { int n1 = mid - left + 1;int n2 = right - mid;int L[n1], R[n2];for (int i = 0; i < n1; i++)L[i] = arr[left + i];for (int j = 0; j < n2; j++)R[j] = arr[mid + 1 + j];int i = 0, j = 0, k = left;while (i < n1 && j < n2) {if (L[i] <= R[j]) {arr[k] = L[i];i++;} else {arr[k] = R[j];j++;}k++;}while (i < n1) {arr[k] = L[i];i++;k++;}while (j < n2) {arr[k] = R[j];j++;k++;}}```（2）二分查找实现```cint binarySearch(int arr[], int left, int right, int target) { while (left <= right) {int mid = (left + right) / 2;if (arr[mid] == target)return mid;else if (arr[mid] < target)left = mid + 1;elseright = mid - 1;}return -1;}```3. 分治策略效果分析（1）归并排序归并排序的平均时间复杂度为O(nlogn)，空间复杂度为O(n)。

《算法设计与分析》实验报告分治策略一、试验名称：分治策略( 1) 写出源程序，并编译运行( 2) 详细记录程序调试及运行结果二、实验目的(1) 了解分治策略算法思想(2) 掌握快速排序、归并排序算法(3) 了解其他分治问题典型算法三、实验内容(1) 编写一个简单的程序，实现归并排序。

(2) 编写一段程序，实现快速排序。

(3) 编写程序实现循环赛日程表。

设有n=2k 个运动员要进行网球循环赛。

现要设计一个满足以下要求的比赛日程表： (1)每个选手必须与其它n-1 个选手各赛一次( 2)每个选手一天只能赛一场( 3)循环赛进行n-1 天四、算法思想分析(1) 编写一个简单的程序，实现归并排序。

将待排序元素分成大小大致相同的 2 个子集合，分别对 2 个子集合进行排序，最终将排好序的子集合合并成为所要求的排好序的集合。

(2) 编写一段程序，实现快速排序。

通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

(3) 编写程序实现循环日赛表。

按分治策略，将所有的选手分为两组，n 个选手的比赛日程表就可以通过为n/2 个选手设计的比赛日程表来决定。

递归地用对选手进行分割，直到只剩下 2 个选手时，比赛日程表的制定就变得很简单。

这时只要让这 2 个选手进行比赛就可以了。

五、算法源代码及用户程序(1) 编写一个简单的程序，实现归并排序。

#include<iostream>#include<>#define MAX 10using namespace std;void merge(int array[],int p,int q,int r){int i,k;int begin1,end1,begin2,end2;int* temp = new int[r-p+1];begin1 = p;end1 = q;begin2 = q+1;end2 = r;k = 0;while((begin1 <= end1)&&(begin2 <= end2)){if(array[begin1] < array[begin2]){temp[k] = array[begin1];begin1++;}else{temp[k] = array[begin2];begin2++;}k++;}while(begin1 <= end1) {temp[k++] = array[begin1++];while(begin2 <= end2){temp[k++] = array[begin2++];}for(i = 0;i < (r-p+1);i++){array[p+i] = temp[i];}delete[](temp);}void merge_sort(int data[],int left,int right){if(left < right){int mid = (left + right)/2;merge_sort(data,left,mid);merge_sort(data,mid + 1,right); merge(data,left,mid,right);}}void main(){int number[MAX] = {0};srand(time(NULL));printf(" 排序前：");for(int i = 0; i < MAX; i++) {number[i] = rand() % 100; printf("%d ", number[i]);}cout<<endl;merge_sort(number,0,9);printf(" 排序后：");for(int j = 0; j < MAX; j++) { printf("%d ", number[j]);}(2) 编写一段程序，实现快速排序。

实验一找最大和最小元素与归并分类算法实现（用分治法）一、实验目的1．掌握能用分治法求解的问题应满足的条件；2．加深对分治法算法设计方法的理解与应用；3．锻炼学生对程序跟踪调试能力；4．通过本次实验的练习培养学生应用所学知识解决实际问题的能力。

二、实验内容1、找最大和最小元素输入n 个数，找出最大和最小数的问题。

2、归并分类将一个含有n个元素的集合，按非降的次序分类（排序）。

三、实验要求（1）用分治法求解问题（2）上机实现所设计的算法；四、实验过程设计（算法设计过程）1、找最大和最小元素采用分治法，将数组不断划分，进行递归。

递归结束的条件为划分到最后若为一个元素则max和min都是这个元素，若为两个取大值赋给max，小值给min。

否则就继续进行划分，找到两个子问题的最大和最小值后，比较这两个最大值和最小值找到解。

2、归并分类使用分治的策略来将一个待排序的数组分成两个子数组，然后递归地对子数组进行排序，最后将排序好的子数组合并成一个有序的数组。

在合并过程中，比较两个子数组的首个元素，将较小的元素放入辅助数组，并指针向后移动，直到将所有元素都合并到辅助数组中。

五、源代码1、找最大和最小元素#include<iostream>using namespace std;void MAXMIN(int num[], int left, int right, int& fmax, int& fmin); int main() {int n;int left=0, right;int fmax, fmin;int num[100];cout<<"请输入数字个数：";cin >> n;right = n-1;cout << "输入数字:";for (int i = 0; i < n; i++) {cin >> num[i];}MAXMIN(num, left, right, fmax, fmin);cout << "最大值为：";cout << fmax << endl;cout << "最小值为：";cout << fmin << endl;return 0;}void MAXMIN(int num[], int left, int right, int& fmax, int& fmin) { int mid;int lmax, lmin;int rmax, rmin;if (left == right) {fmax = num[left];fmin = num[left];}else if (right - left == 1) {if (num[right] > num[left]) {fmax = num[right];fmin = num[left];}else {fmax = num[left];fmin = num[right];}}else {mid = left + (right - left) / 2;MAXMIN(num, left, mid, lmax, lmin);MAXMIN(num, mid+1, right, rmax, rmin);fmax = max(lmax, rmax);fmin = min(lmin, rmin);}}2、归并分类#include<iostream>using namespace std;int num[100];int n;void merge(int left, int mid, int right) { int a[100];int i, j,k,m;i = left;j = mid+1;k = left;while (i <= mid && j <= right) {if (num[i] < num[j]) {a[k] = num[i++];}else {a[k] = num[j++];}k++;}if (i <= mid) {for (m = i; m <= mid; m++) {a[k++] = num[i++];}}else {for (m = j; m <= right; m++) {a[k++] = num[j++];}}for (i = left; i <= right; i++) { num[i] = a[i];}}void mergesort(int left, int right) { int mid;if (left < right) {mid = left + (right - left) / 2;mergesort(left, mid);mergesort(mid + 1, right);merge(left, mid, right);}}int main() {int left=0,right;int i;cout << "请输入数字个数：";cin >> n;right = n - 1;cout << "输入数字:";for (i = 0; i < n; i++) {cin >> num[i];}mergesort(left,right);for (i = 0; i < n; i++) {cout<< num[i];}return 0;}六、运行结果和算法复杂度分析1、找最大和最小元素图1-1 找最大和最小元素结果算法复杂度为O(logn）2、归并分类图1-2 归并分类结果算法复杂度为O(nlogn）实验二背包问题和最小生成树算法实现（用贪心法）一、实验目的1．掌握能用贪心法求解的问题应满足的条件；2．加深对贪心法算法设计方法的理解与应用；3．锻炼学生对程序跟踪调试能力；4．通过本次实验的练习培养学生应用所学知识解决实际问题的能力。

分治法实验总结
分治法是一种常用的算法设计策略，它将问题分解成若干个子问题，然后递归地解决这些子问题，最后将子问题的解合并成原问题的解。

在本次实验中，我们通过实现归并排序和快速排序两个算法，深入理解了分治法的思想和实现方式。

我们实现了归并排序算法。

归并排序的基本思想是将待排序的序列分成若干个子序列，每个子序列都是有序的，然后再将子序列合并成一个有序的序列。

在实现过程中，我们采用了递归的方式，将序列不断地分成两半，直到每个子序列只有一个元素，然后再将这些子序列两两合并，直到最终得到一个有序的序列。

归并排序的时间复杂度为O(nlogn)，是一种稳定的排序算法。

接着，我们实现了快速排序算法。

快速排序的基本思想是选择一个基准元素，将序列分成两个部分，一部分比基准元素小，一部分比基准元素大，然后递归地对这两个部分进行排序。

在实现过程中，我们选择了序列的第一个元素作为基准元素，然后使用两个指针分别从序列的两端开始扫描，将比基准元素小的元素放在左边，将比基准元素大的元素放在右边，最后将基准元素放在中间，然后递归地对左右两个部分进行排序。

快速排序的时间复杂度为O(nlogn)，但是在最坏情况下，时间复杂度会退化为O(n^2)。

通过实现归并排序和快速排序两个算法，我们深入理解了分治法的
思想和实现方式。

分治法是一种非常重要的算法设计策略，可以用来解决很多复杂的问题，比如最近点对问题、矩阵乘法问题等。

在实际应用中，我们可以根据具体问题的特点选择合适的分治算法，以提高算法的效率和准确性。

算法实验报告一分治法实验一、实验目的及要求利用分治方法设计大整数乘法的递归算法，掌握分治法的基本思想和算法设计的基本步骤。

要求：设计十进制的大整数乘法，必须利用分治的思想编写算法，利用c语言（或者c++语言）实现算法，给出程序的正确运行结果。

（必须完成）设计二进制的大整数乘法，要求利用分治的思想编写递归算法，并可以实现多位数的乘法（利用数组实现），给出程序的正确运行结果。

（任选）二、算法描述1、输入两个相同位数的大整数u，v 输出uv的值判断大整数的位数i；w=u/10^(i/2);y=v/10^(i/2);x=u-w*10^(i/2);z= v-y*10^(i/2);然后将w,x,y,z代入公式求得最后结果uv=wy10^i+((w+x)(y+z)-wy-xz)10^(i/2)+xz三、调试过程及运行结果在实验中我遇到的问题：原来以为这两个大整数的位数不同，结果题目要求是相同位数的大整数在写10的多少次方时，写的是10^(i/2),10^(i)，结果不对，我就将它改成了for循环语句四、实验总结在本次实验中，我知道了分治算法，以及分治算法的基本思想。

我还掌握了编写大整数乘法的算法与步骤，以及如何修改在编写程序时遇到的问题。

五、附录（源程序代码清单）1、#include&lt;iostream.h&gt; int weishu(int x){int i;while(x!=0){ x=x/10;i++;}return i;}void main(){int u,v;cout&lt;&lt;输入两个位数相同的大整数:&lt;&lt;endl; cin&gt;&gt;u;cin&gt;&gt;v;int i,j,m,n;int p,x,y,z,w;int a=1;int b=1;i=weishu(u);for(int k=1;k&lt;=i;k++){a=a*10;}for(int q=1;q&lt;=i/2;q++) {b=b*10;}w=u/b;y=v/b;x=u-w*b;z=v-y*b;p=w*y*a+((w+x)*(y+z)-w*y-x*z)*b+x*z; cout&lt;&lt;u&lt;&lt;*&lt;&lt;v&lt;&lt;=&lt;&lt;p; }教师评语：成绩：√优良中及格不及格算法实验报告二动态规划法实验一、实验目的及要求利用动态规划方法设计背包问题算法，掌握动态规划法的基本思想和算法设计的基本步骤。