精华内容
下载资源
问答
  • 分治求逆序
    千次阅读
    2018-10-08 17:16:32

    题目:有一实数序列 a 1 a_1 a1, a 2 a_2 a2, a 3 a_3 a3, a N a_N aN,若 i &lt; j i &lt; j i<j a j &gt; a i a_j &gt; a_i aj>ai,则 ( a i , a j ) (a_i, a_j) (ai,aj)构成了一个逆序对,请使用分治方法求整个序列中逆序对个数,并分析算法的时间复杂性。
    例如:序列 ( 4 , 3 , 2 ) (4, 3, 2) (4,3,2)逆序对有 ( 4 , 3 ) (4, 3) (4,3) ( 4 , 2 ) (4, 2) (4,2) ( 3 , 2 ) (3, 2) (3,2) 3 3 3个。

    分析:采用分治法,每次将当前问题规模分解一半,即从中间分解两半,左右两边各自进行递归求解。当问题规模为1的时候,此时不含有逆序对,在向上合并的时候,不要拿左半边每个数去和右半边每个数进行比较,因为这样合并的时间复杂度就是 O ( n 2 ) O(n^2) O(n2),这样做最后整体时间复杂度还是 O ( n 2 ) O(n^2) O(n2),分治也就没有意义了。
    普遍的做法就是拿空间换时间,也就是归并排序的思想。先假设合并时array左右是各自从小到大有序的,那么左右同时遍历,左边一旦找到一个数比右边大,那么左边剩下的数都能和右边这个数构成逆序对。这也就是为什么会有pairs += mid - i + 1了。引入temp临时数组就是为了实现array左右是有序的,每次比较时,总是把较小的数放到temp里,最后一次合并结束时,把temp里的数更新到array数组当中。

    时间复杂度:因为合并时,最坏的情况是左右都遍历了,由于是同时遍历,也就是 O ( n 2 ) O(n^2) O(n2)的时间复杂度,这样整体的时间开销就是 T ( n ) = 2 T ( n 2 ) + O ( n 2 ) T(n) = 2T(\frac{n}{2}) + O(n^2) T(n)=2T(2n)+O(n2),根据Master定理,其时间复杂度为 O ( n l o g 2 n ) O(nlog_2n) O(nlog2n)

    代码实现

    int merge(int * array, int * temp, int begin, int mid, int end) {
    		int i = begin;
    		int j = mid + 1;
    		int k = begin;
    		int pairs = 0;
    		while (i <= mid && j <= end) {
    			if (array[i] > array[j]) {
    				temp[k++] = array[j++];
    				pairs += mid - i + 1;
    			}
    			else {
    				temp[k++] = array[i++];
    			}
    		}
    		while (j <= end) temp[k++] = array[j++];
    		while (i <= mid) temp[k++] = array[i++];
    		for (int i = begin; i <= end; i++) array[i] = temp[i];
    		return pairs;
    	}
    int reversal_pairs(int * array, int * temp, int begin, int end) {
    	if (begin == end)
    		return 0;
    	int pairs = 0;
    	int mid = (begin + end) / 2;
    	pairs += reversal_pairs(array, temp, begin, mid);
    	pairs += reversal_pairs(array, temp, mid + 1, end);
    	pairs += merge(array, temp, begin, mid, end);
    	return pairs;
    }
    

    实际应充分考虑到各种特殊情况,比如数组为空等。

    更多相关内容
  • 讲解分治求最近点问题的思想与算法实现。 利用分治求最近点与归并排序的结构上的相同,将时间复杂度降到真正意义上的O(nlogn)而不是O(nlognlogn)。 1. 预处理:创建结构体Node附带属性x,y表示在平面...

    讲解分治法求最近点对问题的思想与算法实现。

    利用分治法求最近点对与归并排序的结构上的相同,将时间复杂度降到真正意义上的O(nlogn)而不是O(nlognlogn)。

     

    1. 预处理:创建结构体Node附带属性x,y表示在平面坐标系中的位置,由Node构成点集S,任一Node就是点集S中的点,生成点时要保证任意两点不重复。

    2. 点数较少时的情形(点数为1返回无穷大,点数为2直接计算返回距离,本实现方法不允许在三个点时也直接计算,两个点以上时必须再均分,这样才符合归并排序的二分法)。

     

    3. 点数|S|>=3时,将平面点集S分割成为大小大致相等的两个子集SL和SR,选取一个垂直线L作为分割直线。通过先对点集以x进行预排序,然后取下标的中间值,就能将数组分为均等的两半( mid=(l+r)/2 ),在不将预排序的时间计入的情况下,此分割方法在单个递归函数中的时间复杂度在为O(1)。

     

    4. 两个递归调用,分别求出SL和SR中的最短距离为dl和dr。递归调用的实际过程就是再把SL和SR进行划分成左右两部分,再对左右两部分继续进行划分,直至划分的部分只包含一个或两个点才停止,并开始计算返回。

    5. 取d=min(dl, dr),在直线L两边分别扩展d,得到中间区域,将中间区域的点放入一个新点集中并按y进行排序(我的实现方法是先对所有点进行Y轴排序然后再存入一个临时的中间点集数组中),对y排序使得对于中间区域的任意一点,我们都可以快速找到在y轴方向上离它最近的点。

     

    6.不能直接在递归函数中写一个排序方法对y进行排序,因为二分法递归本身的复杂度为logn,而排序算法最快为nlogn,这样子总的时间复杂度就会变成nlognlogn。利用归并排序和最近点对两者在算法结构上的相同(二分法),在递归函数中一边求子数组的最近点对距离,一边利用归并排序中的合并操作(在单个递归函数中的复杂度为O(n))按y对点集进行整理排序,总时间复杂度就为nlogn。

     

    这一步会比较难理解,如上图:假设原数据按x排好序,方块中显示的是它们y轴上的值,初始点数组的y轴数据为【5,1,2,4,3,7,6】;分治法最后会将所有点分成只有1个或2个的情况,如【5】,【1,2】,【4,3】,【7,6】 ,在分到一个点的情况,函数会返回这个点(只有一个点所以一定是有序的)和一段无穷大的距离,在两个点的情况,函数通过计算和merge合并操作会返回一个有序的子序列和最近的两个点间的距离,比如【4,3】会返回dis(点4,点3)和【3,4】,【6,7】会返回dis(点6,点7)和【6,7】,接下来就merge合并【3,4】,【6,7】得到【3,4,6,7】,同时比较dis(点4,点3)和dis(点6,点7)得到较短的距离。用过这种方法不断在返回最近点对距离的同时返回一个对y有序的数组,直到统计完所有的点。 

    7.对于中间区域SL的每一点,检查SR中的点与它的距离,更新所获得的最近距离。为使此步骤做到线性效率,我选择将SL和SR合并起来。我们将已对y排好序且均位于中间区域的点的数组从第一个点开始向后遍历,检测两点间的距离(因为每个点已经与前面的点比较过,所以只需向后遍历)。因为左右两边的已找到的最近点对距离为mindis,若中间区域的某点A存在另一点构成距离更短的点对,这两点的y值之差必须小于mindis。画出长为2*mindis,宽为mindis的矩形,点A位于矩形上边,所有与A有可能构成最近点对的候选点应位于矩形候选区域中。SL和SR中的矩形(正方形)各自最多只能存在4个点(位于顶点),但点集中不存在重复的点,所以一旦有一个矩形中有两个点占据了中线的上顶点,另一矩形便最多只能在中线上存在一个点,所以整个矩形中最多存在7个点。但因为点A位于矩形边上,在图1情况下,左边矩形上边的两个顶点都不可能存在,所以最多为5个点,在图2情况下(此时中线上的点A算左边区域),被点A覆盖的点不可能存在,所以最多为6个点。所以对于任意一点,最多只需向下遍历6个点就行,所以此操作是线性效率。

    8. 在计算过程中,每次获得最短距离时,要记录下点对的位置信息。

    分治法的递归操作每次都是均等分,所以其递归树为logn层,递归函数中的操作均为线性,所以总的时间复杂度为O(nlogn)。

    T(n) = 2T(n/2)+O(n)递推= O(nlogn)

    分治法实现方法:

    //定义储存点的结构
    struct Node {	
    	double x;
    	double y;
    };
    
    Node *PointsX;
    Node *PointsY;
    
    int main(){
    	//省略
    	PointsX = new Node[pointNumber];
    	CreatePoints(PointsX, pointNumber);			//创建散点	
    	sort(PointsX, PointsX + pointNumber, cmpX);		//对点以X坐标进行排序
    	PointsY = new Node[pointNumber];		//创建新数组在Merge合并操作时用
    	dis = MergeMethod(PointsX, 0, pointNumber - 1, minPoint1, minPoint2);	//调用分治法
    	//省略
    	return 0;
    }
    //随机生成点
    void CreatePoints(Node Points[], int pointNumber){
    	srand(time(NULL));		//随机化随机数种子
    	for (int i = 0; i<pointNumber; i++){
    		Points[i].x = rand()/(double)RAND_MAX;
    		Points[i].y = rand()/(double)RAND_MAX;
    		//每1000个数据乘以一个特定的数,将数据尽量分散,减少重复
    		Points[i].x *= ((i / 1000) + 1);
    		Points[i].y *= ((i / 1000) + 1);
    		//遍历已经生成的所有点,一旦发现重合则重新生成该点
    		for (int j = 0; j < i; j++){
    			if (Points[j].x == Points[i].x && Points[j].y == Points[i].y) {
    				i--;
    				break;
    			}
    		}
    	}
    }

     

    double MergeMethod(Node *px, int l, int r, Node &p1, Node &p2) {
    	if (r - l <= 0)	{//点数为1时输出无穷大
    		return MAX_DISTANCE;
    	}
    	else if (r - l == 1) {		//点数为2直接输出点距同时记录点对
    		Merge(l,r);
    		p1 = px[l];
    		p2 = px[r];
    		return sqrt((px[r].x - px[l].x)*(px[r].x - px[l].x) + (px[r].y - px[l].y)*(px[r].y - px[l].y));
    	}
    	else {
    		Node c, d, e, f;
    		double mindis;
    		int i, j;
    		int mid = (r + l) / 2;		//前面已排好序,直接平均分
    		
    		double middlex = PointsX[mid].x;	//记录中线的x值,用于后面判断和存储中间区域的点
    
    		double mindis1 = MergeMethod(px, l, mid, c, d);		//求左边部分的最短点距
    		double mindis2 = MergeMethod(px, mid+1, r, e, f);	//求右边部分的最短点距
    
    		if (mindis1 < mindis2){		//两边比较取最小值,并记录点对
    			mindis = mindis1;
    			p1 = c;
    			p2 = d;
    		}
    		else{
    			mindis = mindis2;
    			p1 = e;
    			p2 = f;
    		}
    
    		Node *temp = new Node[r - l + 1];		//将所有与中间点的横坐标距离小于mindis的点纳入数组
    		int number = 0;
    		
    		Merge(l, r);			//对点进行合并操作,之后的数组已是按y值排好的数组
    
    		for (i = l; i <= r; i++) {
    			if (fabs(px[i].x - middlex ) <= mindis) {	//数组内的数据相当于在横坐标范围[middlex-mindis,middlex+mindis]之间
    				temp[number++] = px[i];
    			}
    		}
    
    		double tempdis;		//遍历中间数组,每个点最多遍历其他点6次,记录最短距离和点对
    		for (i = 0; i < number; i++) {
    			for (j = i + 1; j < i+1+6 && j < number; j++) {
    				tempdis = sqrt((temp[i].x - temp[j].x)*(temp[i].x - temp[j].x) + (temp[i].y - temp[j].y)*(temp[i].y - temp[j].y));
    				if (tempdis < mindis) {
    					mindis = tempdis;
    					p1 = temp[i];
    					p2 = temp[j];
    				}
    			}
    		}
    		delete[]temp;
    		return mindis;
    	}
    }
    
    bool cmpX(Node &a, Node &b){
    	return a.x<b.x;
    }
    //归并排序的合并整理操作
    void Merge(int left, int right) {
    
    	int mid = (left + right) / 2;
    	int i = left, j = mid + 1;
    	int idx = left;
    
    	while (i <= mid && j <= right) {
    		if (PointsX[i].y < PointsX[j].y) 
    			PointsY[idx++] = PointsX[i++];
    		else 
    			PointsY[idx++] = PointsX[j++];
    	}
    
    	while (i <= mid) 
    		PointsY[idx++] = PointsX[i++];
    	while (j <= right) 
    		PointsY[idx++] = PointsX[j++];
    
    	for (i = left; i <= right; i++) 
    		PointsX[i] = PointsY[i];
    }

    蛮力法的思想与算法实现:

    遍历点集中的所有点,算出所有点与其他点的距离,比较得出点集中距离最短的两点的距离,并将两点记录下来。

    时间复杂度:T(n) =an² + bn + c

    蛮力法实现方法:

     

    //蛮力法
    double BruteForceMethod(Node p[], int length)
    {
    	if (length == 1)		//点数为1输出无穷大
    		return MAX_DISTANCE;
    	else if (length == 2)	//点数为2直接输出点距
    		return ((p[0].x - p[1].x)*(p[0].x - p[1].x) + (p[0].y - p[1].y)*(p[0].y - p[1].y));
    	else{
    		int i, j;
    		double mindis, temp;
    		mindis = (p[0].x - p[1].x)*(p[0].x - p[1].x) + (p[0].y - p[1].y)*(p[0].y - p[1].y);	//先取前两个点的点距为最小距离
    		minPoint1 = p[0];
    		minPoint2 = p[1];
    		for (i = 0; i < length - 1; i++){
    			for (j = i + 1; j < length; j++){
    				temp = (p[i].x - p[j].x)*(p[i].x - p[j].x) + (p[i].y - p[j].y)*(p[i].y - p[j].y);	//算出每两个点的点距
    				if (temp < mindis){				{
    					mindis = temp;			//当发现更小的距离时,替换最小点距,并记录两个点的信息
    					minPoint1 = p[i];
    					minPoint2 = p[j];
    				}
    			}
    		}
    		return mindis;			//直到返回结果时才求sqrt得到真正距离,减少运算量
    	}
    }
    

     

     

     

     

    展开全文
  • 世界上最好的学习:费曼学习

    万次阅读 多人点赞 2019-09-27 19:15:09
    当然,也可以通过优秀的学习来进行学习,比如今天讲的“费曼学习”,可以将你的学习效率极大的提高。 费曼学习是由加拿大物理学家费曼所发明的一种高效的学习方法,费曼本身是一个天才,13岁自学微积分,24岁...

    你是否曾幻想读一遍书就记住所有的内容?是否想学习完一项技能就马上达到巅峰水平?除非你是天才,不然这是不可能的。对于大多数的普通人来说,可以通过笨办法(死记硬背)来达到学习的目的,但效率低下。当然,也可以通过优秀的学习法来进行学习,比如今天讲的“费曼学习法”,可以将你的学习效率极大的提高。

    费曼学习法是由加拿大物理学家费曼所发明的一种高效的学习方法,费曼本身是一个天才,13岁自学微积分,24岁加入曼哈顿计划(核武器计划);而Google创始人谢尔盖布林都在使用的学习方法,比尔盖茨、乔布斯、拉里佩奇都是费曼学习法的拥戴者。
    在这里插入图片描述
    加拿大人斯科特.H.杨(Scott H Young)使用这种方法,只用一年时间自学完成了 MIT 公开课上的 33 门计算机科学课程,正常情况下需要四年才能修完,并最终通过了所有考试!

    另外有一则报道说:一个农民让自己的孩子每天去学校上课回来教学过的内容,这样可以一份学费学两次,就这么一个单纯的想法,他的孩子学习成绩一直很优异最终考上了清华。

    不论上面的报道是否属实,但它正是费曼学习法的典型体现。费曼学习法用通俗易懂的话来说就是:通过向别人清楚的解说某一件事,来确认自己是否真正弄懂了这件事。

    下面我们就来了解一下费曼学习法的具体操作。
    在这里插入图片描述

    第一步:选择目标

    选择目标的选择很简单,就是确定你要学什么,或要干什么。在这里比如学习一门技术、学习一个科学领域、学习一门语言、学习一个概念等,都可以称作目标。

    但如果想制定非常棒的目标,还可以学习一下SMART原则:Specific具体、Measurable可测量、Attainable可实现、Relevant相关性、Time—based时效性。也就是说计划要具体、可测量、坚持即可实现、对你有意义并且要在一定的期限内完成。

    第二步:教学

    创造一个场景,在这个场景中将自己学到的知识讲授给“别人”。在这个过程中会遇到很多问题,比如说不清楚,讲不明白,自己也模棱两可等,那就说明这些知识点并没有熟练掌握。尝试教授和发现薄弱点就是这一步的重点。

    有朋友可能说,没有人可教授怎么办?其实,这里的教学是统称,具体可因地制宜的创造出许多场景。如果能真实的一对一或一对多的教授那再好不过了。如果没办这样,可以通过写作、录制教学视频、对着手机录音、实践等方式来进行演变。
    在这里插入图片描述
    日常中很常见的一个场景就是,在你学习一个新知识时,你感觉自己已经看懂了,但是去使用、去说、或去写出来的时候发现完全没有思路。这就是知识掌握薄弱的表现。

    第三步:纠错学习

    在第二步中遇到了问题,那么就需要进入第三步——纠错学习。无论是在教授的过程中说错的、说不清楚的、模棱两可的都需要在这一步中进行强化。反复查询资料、学习、强化记忆,然后再重复第二步进行验证,直到可以顺利的教授相应的知识。

    第二步和第三步的结合有别于传统的题海战术,题海战术之所以效果不好,是因为大多数人大多数情况下只是在做自己会做的,而忽略了不会的内容,也就是“用低廉的勤奋代替高质量的思考”。

    第四步:简化

    这一步是对上面学习的内容进行提炼、简化,去掉非必要的,多余的信息,并且能够用自己的语言通俗易懂的表达出来,而不是照本宣科。

    其实这一步骤还有一个重点,就是简化到可以通过类比,让一个非专业人士(夸张点说就是小孩儿)都能听懂。此时,你就真正掌握了这门学习方法。

    小结

    有时候我们会觉得自己后知后觉,那是因为学习的太少,了解的太少,很多问题前人已经总结好了现成的方法和方案,我们却不知道,还在自己探索,当然行动缓慢,后知后觉了。只有站在巨人的肩膀上才能看得更远。

    原文链接:《世界上最好的学习法:费曼学习法


    程序新视界

    关注程序员的职场生涯,大量优质学习资源、技术文章分享

    csdn-微信公众号

    展开全文
  • 数值计算——追赶求解三角方程组(附代码)

    万次阅读 多人点赞 2019-09-22 20:30:30
    目录 追赶基础理论 追赶c++程序代码 程序运行结果 源码文件下载地址 ...在数值计算中,三次样条曲线插值和用差分方法求解常微分方程边值问题,通常会遇到Ax=d三角形式的方程组: ...

    目录

    追赶法基础理论

    追赶法c++程序代码

    程序运行结果

    源码文件下载地址


    追赶法基础理论

    在数值计算中,对三次样条曲线插值和用差分方法求解常微分方程边值问题时,通常会遇到Ax=d三对角形式的方程组:

    \begin{bmatrix} b_{1} & c_{1} & & & \\ a_{2} & b_{2} & c_{2} & & \\ & \ddots & \ddots & \ddots & \\ & & a_{n-1} & b_{n-1} & c_{n-1} \\ & & & a_{n} & b_{n} \end{bmatrix}\begin{bmatrix} x_{1}\\ x_{2}\\ \vdots \\ x_{n-1}\\ x_{n} \end{bmatrix}=\begin{bmatrix} d_{1}\\ d_{2}\\ \vdots \\ d_{n-1}\\ d_{n} \end{bmatrix}                                                                                                                 (1)

    利用三对角矩阵的LU分解建立计算量更少的线性方程组求解公式,现将系数矩阵A进行克劳特分解,即A分解为下三角矩阵和单位上三角矩阵的乘积:

    \begin{bmatrix} b_{1} & c_{1} & & & \\ a_{2} & b_{2} & c_{2} & & \\ & \ddots & \ddots & \ddots & \\ & & a_{n-1} & b_{n-1} & c_{n-1} \\ & & & a_{n} & b_{n} \end{bmatrix}=\begin{bmatrix} \alpha _{1} && & & \\ \gamma _{2} & \alpha _{2} & & & \\ & \ddots & \ddots & & \\ & & \gamma _{n-1} & \alpha _{n-1} & \\ & & & \gamma _{n} & \alpha _{n} \end{bmatrix}\begin{bmatrix} 1 & \beta _{1} & & & \\& 1 & \beta _{2} & & \\ && \ddots & \ddots & \\ & && 1 & \beta _{n-1} \\ & & & & 1 \end{bmatrix}                                       (2)

    计算\alpha _{i},\beta _{i},\gamma _{i},的公式:

    \alpha _{1}=b_{1}\beta _{1}=c_{1}/b_{1}

    \gamma _{i}=a_{i}\alpha _{i}=b_{i}-a_{i}\beta _{i-1}i=2,3,\cdots n;                                                                                                                 (3)

    \beta _{i}=c_{i}/\alpha _{i}

    求解Ax=d等价于求解Ly=d和Ux=y.

    因而经过推导得到解三对角线性方程组的追赶法公式.

    • 计算\beta _{1}的递推公式:

              \beta _{1}=c_{1}/b_{1}\beta _{i}=c_{i}/\left ( b_{i}-a_{i}\beta _{i-1} \right )i=2,3,\cdots n-1;                                                                                 (4)

    • 解Ly=d:

             y _{1}=d_{1}/b_{1}y _{i}=\left ( d_{i}-a_{i}y_{i-1} \right )/\left ( b_{i}-a_{i}\beta _{i-1} \right )i=2,3,\cdots n;                                                                      (5)

    • 解Ux=y:

              x_{n}=y_{n}x _{i}= y_{i}-\beta_{i}x_{i+1}i=n-1,n-2,\cdots 1;                                                                                      (6)

    整个求解过程是先有(4)式和(5)式计算\beta _{1}\rightarrow \beta _{2}\rightarrow\cdots \rightarrow \beta _{n-1}y _{1}\rightarrow y_{2}\rightarrow\cdots \rightarrow y _{n},这个过程称为由前到后“追”的过程;再由(6)式求出x _{n}\rightarrow x_{n-1}\rightarrow\cdots \rightarrow x _{1},这个过程是由后往前“赶”的过程,因此上述解法通常称为追赶法。

    追赶法c++程序代码

    #include <iostream>
    #include <vector>
    #include <iomanip> //参数化输入/输出 
    using namespace std;
    //*****************************
     //追赶法求解AX=B矩阵
    //*****************************
    vector<double> Chasing_method(vector<vector<double>>a, vector<double>d)
    {
    	int n = size(d);
    	vector<double>x(n);
    	vector<double>alpha(n);
    	vector<double>gama(n);
    	vector<double>beta(n);
    	vector<double>y(n);
    	alpha[0] = a[0][0];
    	beta[0] = a[0][1] / a[0][0]; y[0] = d[0] / a[0][0];
    	for (int i = 1; i < n; i++)
    	{
    		gama[i] = a[i ][i - 1];
    		alpha[i] = a[i][i] - gama[i] * beta[i - 1];
    		if (i < n- 1)
    		{
    			beta[i] = a[i ][i + 1] / alpha[i];
    		}
    		y[i] = (d[i] - a[i][i - 1] * y[i - 1]) / alpha[i];
    	}
    	x[n- 1] = y[n- 1];
    	for (int i = n- 2; i >= 0; i--)
    	{
    		x[i] = y[i] - beta[i] * x[i + 1];
    	}
    	return x;
    }
    int main()
    {
    	vector<vector<double>>a(4, vector<double>(4));
    	vector<double>b(4);
    	vector<double>x(4);
    	a[0] = { 3,4,0,0 }; a[1] = { 1,4,1,0 }; a[2] = { 0,1,6,1 }; a[3] = {0,0,2,8 };
    	b = { 10,11,30,48 };
    	x = Chasing_method(a, b);
    	for (int i = 0; i < 4; i++)
    	{
    		for (int j = 0; j < 4; j++)
    		{    
    			cout << fixed << setw(8) << setprecision(4) << a[i][j];
    		}
    		cout << fixed << setw(8) << setprecision(4) << b[i] << endl;
    	}
    	cout << "追赶法求解:" << endl;
    	for (int i = 0; i < 4; i++)
    	{
    		cout<<"x"<<i<<"=   " <<x[i] << endl;
    	}
    }
    

    程序运行结果

    源码文件下载地址

    https://download.csdn.net/download/weixin_41788456/11828550

    展开全文
  • 最近点问题(分治

    千次阅读 多人点赞 2020-04-23 16:46:56
    给定平面S上n个点,找其中的一对点,使得在n个点组成的所有点中,该点间的距离最小 蛮力求解 点的存储: class Point{ //横坐标 int x; //纵坐标 int y; /** * 求解两个坐标之间的距离 * ...
  • 这次来实现三角线方程组的追赶,追赶的本质还是高斯消元,而且是没选主元的高斯消元,只是因为Ax=b中系数矩阵A非常特殊,所以就可以采用相对特殊的方法来解方程组。同样,按照常规的步骤,先分析什么是...
  • 空间滤波是通过在图像空间借助模板进行邻域操作完成图像的滤波操作,包括线性的和非线性的。 空域滤波的主要功能: 平滑:低通滤波器: 目的: 模糊化:在提取较大目标前去除太小的细节或将目标内的小间断连接...
  • 利用冒泡法对10个数字进行排序

    千次阅读 2021-09-03 08:31:38
    利用冒泡法对10个数字进行排序(数组)
  • 代码生成 | 安积分模型搭建

    千次阅读 多人点赞 2020-07-12 09:50:52
    积分是电池电量计量最基础的方法,今天我们用simulink建模的方式做一个安积分模型,从而更好地理解安积分的思想也掌握建模的基础操 ​新建文件 打开MATLAB启动simulink新建一个模型文件 定义变量 和...
  • 用算符优先法对算术表达式求值(六)

    万次阅读 多人点赞 2018-11-23 00:19:22
    掌握栈在解决实际问题中的应用,设计一个程序,演算用算符优先法对算术表达式求值的过程,利用算符优先关系,实现算术四则混合运算表达式的求值 。。挺难的。。 思路在这! 思路 这个程序是这样,当你点击运行它的...
  • 初值牛顿迭代的影响

    万次阅读 多人点赞 2019-01-15 17:44:55
    工程上 ,不少实际问题的数学... 目前 ,人们已提出了不少求解非线性方程 f (x )= 0近似解的方法 ,其中 ,牛顿迭代是最基本的方法 之一。 由于牛顿迭代在方程的单根附近具有平方收敛速度 ,而且还可以求解方程的重根...
  • 德尔菲——意见可靠预测方法

    千次阅读 2019-07-09 08:59:14
    德尔菲/得尔飞(Delphi Method) 目录 1德尔菲的简介 1.1德尔菲的起源演变 1.2德尔菲的典型特征 2德尔菲的特征 3德尔菲的具体实施步骤 3....
  •  总价(gross price method):销售商品以发票价格同时记录应收账款和销售收入,不考虑现金折扣,如购货企业享受现金折扣,则以“销售折扣”账户反映现金折扣。销售折扣作为销售收入的减项列入损益表。  净价...
  • 面积归一、内标、...各成分校正因子一致可用该,该简便、准确,特别是进样量不容易准确控制,进样浓度及进样量的变化的影响很小。其他操作条件,如流速、柱温等变化定量结果的影响也很小。GC应用广于...
  • 选择排序和冒泡排序

    万次阅读 多人点赞 2020-05-21 17:00:57
    选择排序和冒泡排序 1.选择排序 #include<stdio.h> int main() { void sort(int a[],int n); int i,a[10];... printf("please input the ...//调用函数sort这十个数进行排序 for(i=0;i<10;i++) pri
  • 基于熵权法对Topsis模型的修正

    千次阅读 2020-05-01 14:26:35
    层次分析是一种评价模型,当没有给出数据,我们不同的准则进行分析,最后求得每一种方案的评分,但是有很大的缺点,比如主观性太强、方案层不能过多。而Topsis优劣解距离可以已有数据进行分析,经过正向化...
  • 基于熵权法对TOPSIS模型的修正

    千次阅读 2020-04-17 16:23:39
    1. 熵权的原理(客观赋权的方法) 2. 如何度量信息量的大小 3. 信息熵的定义 4. 熵权的计算步骤 4.1 将输入矩阵中的负数变为正数(指标标准化) 4.2 计算概率 4.3计算信息熵 5. 熵权背后的原理 6. 熵...
  • satty 标度

    千次阅读 2021-04-29 10:50:04
    1 层次分析 首先建立了层次结构模型后,其上下层之间元素的隶属关系就被确定了。最后需要每一个层级的所有指标进行两两对比,确定其相对的重要性。而层次分 析通常采用 Saaty 标度来给判断矩阵的元素赋值。如表 ...
  • //输入的十个字符进行由小到大的排序 /*#include<stdio.h> #include<string.h> void fun(char s[10]) { int i,j,k,t; for(i=0;i<10-1;i++) { for(j=0;j<10-1-i&&s[j]!='\0';j++) ...
  • 逆序的几种求

    万次阅读 多人点赞 2018-05-08 22:09:59
    逆序的几种求 1.暴力比较: 写两层循环,时间复杂度为 2.归并排序: 众所周知,归并排序就是将一个序列分成两部分进行排序,然后将排序后的两个序列中的元素一个一个插入(如图) 然后,我们发现,对于两...
  • 场景

    千次阅读 2019-10-02 10:21:32
    场景概述: 1、场景就是模拟用户操作软件的场景... 当业务流程测试没有问题,也就是该软件的主要功能没有问题,我们再重点从边界值、等价类等方面控件进行测试 2、在冒烟测试也主要采用场景进行测...
  • 场景 :BigDecimal类型字段如果值为类似0.000001这种精度很高的小数,则会转为科学记数 在实体类字段上添加注解 @JsonSerialize(using=BigDecimalJsonSerializer.class) private BigDecimal amount; 新建...
  • 数学优化入门:梯度下降、牛顿、共轭梯度

    万次阅读 多人点赞 2016-10-13 19:45:43
    相比最速下降,牛顿带有一定全局的预测性,收敛性质也更优良。当然由于牛顿是二阶收敛的,比梯度下降收敛的更快。 假设我们要求f(x)的最小值,首先用泰勒级数求得其二阶近似 显然这里x是自变量,...
  • Newton(牛顿 Newton Method)

    万次阅读 多人点赞 2017-09-16 15:30:47
    平时经常看到牛顿怎样怎样,一直不得要领,今天下午查了一下维基百科,写写我的认识,很多地方是直观理解,并没有严谨的证明。在我看来,牛顿至少有两个应用方向,1、求方程的根,2、最优化。牛顿涉及到方程...
  • numpy写入csv文件不使用科学计数

    千次阅读 多人点赞 2019-08-31 11:29:39
    TIPS:解决在写入csv文件整数格式出错问题。 文章目录具体实现原始保存保留多位小数保留原始位小数保留整数基础知识扫盲numpy.savetxt参数解释 具体实现 原始保存 # 代码一 c = np.array([1.1, 2.2, 3.3, 4.4]) ...
  • double型做除法时的注意事项

    万次阅读 2018-08-03 11:42:54
    对于int i=3; double t=i/2; t得到的结果是1.0 而double t=i/2.0; t得到的结果是1.5 所以double型做除法时,一定要注意除数或者被除数一定要至少有一个为double型!!!...
  • 数组排序之冒泡和选择

    千次阅读 多人点赞 2018-12-16 22:50:33
    这一次,我们来聊聊冒泡排序和简单选择排序。 一.冒泡排序: 1.算法: 1&gt;.基本思想:在排序过程中元素进行两两比较,越小的元素会经由交换慢慢‘’浮‘’到数组的最前面(低下标处),像气泡一样慢慢浮...
  • 定期订货与定量订货分析

    千次阅读 2021-02-12 00:49:48
    《定期订货与定量订货分析》由会员分享,可在线阅读,更多相关《定期订货与定量订货分析(3页珍藏版)》请在人人文库... 定量订货在进行采购,需要企业人员仓库中的物资随时进行库存量的盘点和检查,一...
  • 交叉验证与留出及其python实现

    千次阅读 多人点赞 2019-01-30 15:16:37
    但是,我们往往只有一个包含m个观测的数据集D,我们既要用它进行训练,又要它进行测试。 对于数据集D的划分,我们尽量需要满足三个要求: 训练集样本量充足 训练模型的计算量可以忍受 不同的划分方式会...
  • 追赶求解三角方程组

    万次阅读 多人点赞 2015-12-04 09:37:50
    在这篇文章里,我们介绍追赶的基本原理,以及用追赶求解三角方程组的算法.

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,158,469
精华内容 463,387
关键字:

对时法