精华内容
下载资源
问答
  • 这是我才从事java开发遇到的问题,现在举个例子分享一下,问题是无法用EL表达式显示设备对应的所有订单,后发现是懒加载问题,相信大家都遇到过。 实体类: public class Machine { //唯一标识id ...

    这是我才从事java开发遇到的问题,现在举个例子分享一下,问题是无法用EL表达式显示设备对应的所有订单,后发现是懒加载问题,相信大家都遇到过。

    实体类:

    public class Machine {

    //唯一标识id

    private Integer machId;

    //设备编号

    private String mNo;

    //订单

    private List<Order> orderList=new ArrayList<Order>();

    //对应设备

    private Machine machine;

     

    解决方法一:

    @ManyToOne(cascade={CascadeType.ALL},fetch=FetchType.LAZY)

    @JoinColumn(name="machId")

    public Machine getMachine() {

    return machine;

    }

     

    public void setMachine(Machine machine) {

    this.machine = machine;

    }

    @OneToMany(targetEntity=Order.class,cascade=CascadeType.ALL,fetch=FetchType.EAGER)

    @JoinColumn(name="machId")

    public List<Order> getOrderList() {

    return orderList;

    }

    public void setOrderList(List<Order> orderList) {

    this.orderList = orderList;

    }

    一端默认为fetch=FetchType.LAZY需设置成fetch=FetchType.EAGER端默认为fetch=FetchType.EAGER需设置成fetch=FetchType.LAZY这样查询machine.orderList才有结果。

    解决方法2

    使用springfilter(要加在Strutsfilter的前面,因为有先后顺序,有先进先出的原则)

    在我们的web.xml里加上

    <filter>

      <filter-name>openSessionInViewFilter</filter-name>

      <filter-class>org.springframework.orm.hibernate4.support.OpenSessionInViewFilter</filter-class>

      </filter>

      <filter-mapping>

      <filter-name>openSessionInViewFilter</filter-name>

      <url-pattern>*.action</url-pattern>

      </filter-mapping>

     

    展开全文
  • 在实际项目中可能会遇到这种情况,当获取某记录的总条数之后,需要进行分页查询,这时就需要总条数进行除操作,判断一共有多少页数据,比如有110条数据,每页显示20条,一共需要6页显示,这时就需要以下操作,来...

    在实际项目中可能会遇到这种情况,当获取某记录的总条数之后,需要进行分页查询,这时就需要对总条数进行除法操作,判断一共有多少页数据,比如有110条数据,每页显示20条,一共需要6页显示,这时就需要以下操作,来判断有6页。

     int number = (int)Math.ceil(total/20.00);
    

    number:是最后得出的页数
    total:是数据总条数
    20.00:是每页需要显示的条数,书写时不能是整形

    展开全文
  • 讲解分治求最近点问题的思想与算法实现。 利用分治求最近点与归并排序的结构上的相同,将时间复杂度降到真正意义上的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得到真正距离,减少运算量
    	}
    }
    

     

     

     

     

    展开全文
  • 基于此问题,文章结合传统的开路电压和负载电压积分 估算蓄电池 SOC 的不足进行补偿,解决了安积分的缺陷。能够实时估算电池的荷电状态,并估算过程中 的不足通过负载电压进行修正。结果表明...
  • 数学归纳的总结

    2020-06-04 10:42:00
    最简单和最常见的数学归纳是证明当n等于任意一个自然数,某命题成立.证明分为以下两步: 1:证明 n=1 命题成立 2:假设 n=m 命题成立,那么可以推导出在 n=m+1的时候命题也成立.(m代表任意自然数)
    什么是数学归纳法
    • 数学归纳法是一种数学证明的方法,通常被用于证明某个给定命题在整个(或者局部)自然数范围内成立.
    • 除了自然数以外,广义上的数学归纳法也可以用于证明一般的良基结构,例如: 集合论中的树.这种广义的数学归纳法应用于数学逻辑和技术按及科学领域,称为结构归纳法
    数学归纳法的原理
    • 最简单和最常见的数学归纳法是证明当n等于任意一个自然数时,某命题成立.证明分为以下两步:
    1:证明 n=1 时命题成立
    2:假设 n=m 时命题成立,那么可以推导出在 n=m+1的时候命题也成立.(m代表任意自然数)
    
    • 这种方法的原理在于:首先证明在某个起始点的时候命题成立,然后证明从一个值到下一个值得过程有效.这两个点都已经证明,那么任意值都可以通过反复使用这个方法推导出来.
    数学归纳法的证明
    • 举例证明下面的定理
    1+2+3+...+n = n(n+1)/2    //等差数列求和公式
    第一步:验证改公式在n=1时成立,即=左边为1,右边为1(1+1)/2=1,等式成立
    第二步:需要证明假设n=m时公式成立,那么还可以推导出n=m+1时公式也成立.
    	步骤如下:
    		在n=m时: 1+2+3+...+m=m(m+1)/2  //等式1
    		然后再等式两边同时加上m+1 即: 1+2+3+...+m+(m+1) = m(m+1)/2 + (m+1)  //等式2
    		根据等式1 证明等式2成立 :
    		等式一等号左边=1+2+3+...+m那么也可以写成1+2+3+...+(m+1)
    		等式二等号右边= m(m+1)/2 + 2(m+1)/2 = 
    		(m+1)(m+2)/2 = (m+1)[(m+1)+1]/2
    		最终:
    		1+2+3+...+(m+1) = (m+1)[(m+1)+1]/2
    		这样就完成了由n=m成立推导出n=m+1也成立的过程
    

    本文摘要于百度百科

    展开全文
  • 梯度下降的简单理解

    千次阅读 2015-02-11 12:16:42
    梯度下降又叫最速下降,英文名为steepest descend method...具体化到1元函数中,梯度方向首先是沿着曲线的切线的,然后取切线向上增长的方向为梯度方向,2元或者多元函数中,梯度向量为函数值f每个变量的导数,
  • 分治之最近问题

    2020-03-25 21:34:40
    在利用分治思想解决此问题,首先考虑将最近问题进行分治,设计其分治策略。将集合S分成两个子集S1和S2,根据平衡子问题原则,每个子集中的点数大致都为n/2。这样分治后,最近点将会出现三种情况:在S1中,在...
  • 分治求最近点实验

    千次阅读 2019-07-06 14:14:11
    分治求最近点 实验概述 对于平面上给定的N个点,给出所有点的最短距离,即,输入是平面上的N个点,输出...首先明确分治的一大特点就是大化小,不知道从哪里下手可以先思考最小的情况。 最小情况:只有一...
  • 1、SOC估算方法及缺陷 电池组SOC估算的方法有很多种,既有传统的电流积分、电池内阻、放电试验、开路电压、负载电压,也有较为创新的卡尔曼滤波、模糊逻辑理论和神经网络等,各种估算方法都有自己...
  • 机器学习实验五,详情请参考《模式分类》第二版第五章课后上机练习5.4节实验环境:Matlab 2016a基本梯度下降和牛顿:我们在寻找能将两类类别分开的权向量采用的方法是:定义一个准则函数J(a),当a是解向量...
  • 三点估算的理解

    千次阅读 2017-02-19 22:08:40
    三点估算也称PERT,在计算每项活动的工期都要考虑三种可能性,计算最悲观的工期、最可能的工期、最乐观的工期,然后再计算出该活动的期望工期,PERT计算的是期望工期. 用PERT计算工期,我们必须记住下面三...
  • 基于熵权法对Topsis模型的修正

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

    2018-11-05 21:09:13
    分治的思想,结合归并排序,我们在归并进行处理,当左区间存在一个数left[a]&gt;right[b],我们的 逆数个数answer+=mid-a+1。因为合并区间,左区间一定有序,右区间也一定有序。 模板代码: #...
  • 求非线性方程的根

    千次阅读 2016-12-16 13:44:22
    对于非线性方程的求解,有时候很难找到解的解析函数,所以只能才用数值求解。常见的一些非线性方程为基本原理:如果非线性方程f(x)=0,的左端函数f(x)在区间[a,b]上连续,并满足f(a)f(b),则...所以,将
  • 在数值计算中,三次样条曲线插值和用差分方法求解常微分方程边值问题,通常会遇到Ax=d三角形式的方程组: (1) 利用三角矩阵的LU分解建立计算量更少的线性方程组求解公式,现将系数矩阵A进行克劳特...
  • 在前文——“不动点迭代计算三元一次方程及不同迭代函数收敛性的影响”中,对于函数f(x)=x^3-2*x-1,用不动点迭代求根,当选取迭代函数x=(x^3-1)/2,计算结果不收敛。下面用Aitken加速尝试,看看会发生...
  • 最近点 平面上给定的N个点,...在平面上所有点不断进行二分,当剩余一个点和两个点可以直接求解,剩余一个点,距离为∞,剩余两个点可以直接计算距离。 二分过程中记录左右两部分中的最短距离dist1和dist2
  • 散列冲突的处理——开放定址

    千次阅读 2018-10-05 13:40:02
    散列冲突的处理——开放定址 之前聊了聊用分离链接解决散列冲突的问题,这次就来聊聊散列冲突的另一种解决办法:开放定址。开放定址分为线性探测,平方探测,双...开放定址的思想是当发生冲突,...
  • 寻找最近点-分治

    2013-09-18 10:50:52
    1. 题意 ... - x2)^2 + (y1- y2)^2),当Q中有2点重合,最近点的距离是0; 最简单的算法是暴力搜索,查看所有的O(n^2)个点。现在利用分治解决,其运行时间是T(n) = 2 T(n/2) + O(n),该算法
  • 分治求平面最近点

    千次阅读 2018-04-20 00:20:26
    那么可以利用分治把时间复杂度降到nlognlogn 当然,利用归并排序可以降到nlogn的,不过显然我是写不来归并排序的 原理是这样的,先把平面上的点按x,y的顺序排序//nlogn 然后再找下标为中间的点,把平面上的点...
  • 分治求最近点问题 下面是我的代码,还有些地方需要改进,但是一直有空指针问题(代码中已标出),主要在调用静态函数进行递归和求两点间距离出现错误,请大佬指正! 总共30个点,a数组是x的排序,b数组是y...
  •   最速下降利用目标函数一阶梯度进行下降求解,易产生锯齿现象,在快接近最小值收敛速度慢。Newton利用了二阶梯度,收敛速度快,但是目标函数的Hesse矩阵不一定正定。于是出现了修正的Newton,主要是...
  • 题目描述 ...暴力时间复杂度O(n2),数据规模大不能AC。需要寻求一种分发高效的算法。考虑到逆序也是一种有序,可以采取一种边排序边计算的方法。归并排序是可以解决这个问题的。 #include&...
  • 写一个函数,用“起泡输入的10个字符按由小到大顺序排序。 要点:1.交换两个字符串常量不能用字符串拷贝。 如:const char *str1=“haha”; const char *str2=“nihao”; const char *tmp=str1; str1=str2; ...
  • 数学归纳的思考

    2010-01-14 20:16:00
    偶然看到数学归纳的如下演绎: 人吃饭,饭的粒数用变量n表示,当n=1,吃不饱;假设当n=k吃不饱,那么当n=k+1也吃不饱,因为不会因为增加一粒饭就吃饱,所以永远吃不饱。 虽然是调侃,貌似也没什么漏洞。。...
  • 场景 :BigDecimal类型字段如果值为类似0.000001这种精度很高的小数,则会转为科学记数 在实体类字段上添加注解 @JsonSerialize(using=BigDecimalJsonSerializer.class) private BigDecimal amount; 新建...
  • 高斯消元法对矩阵LU分解的影响

    千次阅读 2017-01-01 15:52:21
    本文详细介绍了Matlab进行lu分解操作l不为三角形的原理。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,057
精华内容 7,622
关键字:

对时法