精华内容
下载资源
问答
  • 在cad中利用lisp代码选择一个多段线,计算次选择点间长度
  • 线段长度

    2015-10-23 12:19:09
    1.一维空间之中(L),存在若干条线,表示为(l,r)[r>=l],指从l到r的线,这条线长度为r-l,给定n条这样的线,他们之间如果相交,那么长度就是最后的表现形式, 如: (2,8) (1,5) ,则长度为8-1+1=9。  (3,6) (3,4) ,...
    1.一维空间之中(L),存在若干条线,表示为(l,r)[r>=l],指从l到r的线,这条线长度为r-l,给定n条这样的线,他们之间如果相交,那么长度就是最后的表现形式,

    如:

    (2,8) (1,5) ,则长度为8-1+1=9。 

    (3,6) (3,4) ,侧长度为6-3+1=4。

    这样,求出所有的n条线的总长度。
    输入:
    n,以后有n个输入每一个为a,b (b>=a) 但是不保证两次输入间的位置关系。

    输出:

    线段总长度。

    我的思路:

    首先考虑两个线段的情况,发现可能分离,或者合并,但是还有可能有新的线段在这两个线段之间使得原本分离的两条线段合并。因此需要确定可能合并的线段要先给线段按

    起点排序,然后从前向后处理,这时分离的线段不能合并,而且合并线段只能和已处理的末尾点在最后的线段进行合并,然后替换最后的线段。重复直到所有线段处理完毕。

    排序好的线段有三种情况;


    (1)新的线段与最后线段分开,对于总长增加度则为新的线段长度,并且新的线段为最后的线段。

    (2)新的线段被最后线段包含,对于总长增加度则为新的线段长度。

    (3)新的线段起点被最后线段包含,终点超出原末尾点,对于总长增加度则为新的线段末尾-原线段末尾点。

    #include <iostream>
    #include <algorithm>
    using namespace std;
    const int maxn=1000;
    int s=-1,e=-1,total=0;
    struct line{
    	int s,e;
    };
    bool cmp(line l1, line l2){
    	return l1.s < l2.s;
    }
    int main(){
    	int m,n,i;
    	line lines[maxn];
    	s=0,e=0;
    	cin >> n;
    	for(i=0;i<n;i++){
    		cin >> lines[i].s >> lines[i].e;
    	}
    	sort(lines,lines+n,cmp);
    	if(n>0){
    		s=lines[0].s;
    		e=lines[0].e;
    	}
    	for(i=1;i<n;i++){
    		if(lines[i].s <= e){//需要合并最后一条线
    			if(lines[i].e > e){
    				e = lines[i].e;
    				total += (lines[i].e - e);
    			}
    		}else{//需要替换最后的线
    				total += (lines[i].e - lines[i].s);
    				s = lines[i].s;
    				e = lines[i].e;
    		}
    	}
    	cout << total << endl;
    	return 0;
    }



    展开全文
  • 1033 计算线段长度.cpp

    2020-04-29 21:14:17
    1033:计算线段长度 时间限制: 1000 ms 内存限制: 32768 KB 提交数: 32476 通过数: 18147 【题目描述】 已知线段的个端点的坐标A(Xa,Ya),B(Xb,Yb),求线段AB的长度,保留到小数点后3位。 【输入】 第一行是...
  • 线段长度问题

    千次阅读 2017-05-18 22:48:57
    线段长度问题 描述 在数轴X轴上有n条线段,线段之间可以有重叠,计算所有线段覆盖X轴的总长度。 输入 输入文件第一行为测试用例个数N(1 输出 对每个用例,用一行输出所计算的总长度,要求去掉...
    线段长度问题

    描述

    在数轴X轴上有n条线段,线段之间可以有重叠,计算所有线段覆盖X轴的总长度。

    输入

    输入文件第一行为测试用例个数N(1<=N<=100),每个测试用例的第一行为该用例是线段的条数n(1<=n<=10000),接下来n行每行由两个实数标识一条线段,其中第一个数为左端点,第二个数为右端点,端点取值范围(0-10000之内的实数,可以为小数),数据之间用空格隔开。

    输出

    对每个用例,用一行输出所计算的总长度,要求去掉小数点末尾多余的0

    样例输入

    2

    4

    2 5

    12 15

    6 10

    4 7

    3

    0 5

    5 10

    10 15

    样例输出

    11

    15

    思路:

    先排序!!! 第一种:一个一个的区间段去加起来。用一个数,去记录你加的区间的位置的末端,之后加的数,每一次都去与这个数去比较一下.

    主要就是几种情况如下:

    (1)记录的数比前端还要小,此时就记录的数变为区间的末端,sum加上区间的范围。

    (2)记录的数,在区间的范围之中,这样记录的数到末端的长度就加起来,前端不要了。

    (3)记录的数在区间的外面,这样就不需要去加上范围,跳过就可以了。

    第二种:两个两个的区间段加起来。思路差不多说了同上面。只不过要多几种输入的情况,比如只输入一个区间段的范围等等。

    第一种的代码如下:

     
    #include<iostream>
    #include<cstdio>
    #include<cstring>
    #include<algorithm>
    using namespace std;
    struct node
    {
        double n,m;
    }a[1000];
    bool cmp(node n,node m)
    {
     return n.n<m.n;
    }
    
    int main()
    {
    int n;
    scanf("%d",&n);
    while(n--)
    {
        int m;
        scanf("%d",&m);
        memset(a,0,sizeof(a));
        for(int i=0;i<m;i++)
            scanf("%lf%lf",&a[i].n,&a[i].m);
        sort(a,a+m,cmp);
        double sum=0;
        double sum1=0;
        int i;
        for(i=0;i<m;i++)
        {
            if(sum1<=a[i].n)
            {
                sum1=a[i].m;
                sum+=a[i].m-a[i].n;
            }
            else
            {
                if(sum1>a[i].n && a[i].m>sum1)
                {
                    sum+=a[i].m-sum1;
                    sum1=a[i].m;
                }
            }
        }
        cout<<sum<<endl;
    }
    return 0;
    }
    第二种代码如下:
       
    #include<iostream>
    #include<cstdio>
    #include<cstring>
    #include<algorithm>
    using namespace std;
    struct node
    {
       double n,m;
    }a[1000];
    bool cmp(node n,node m)
    {
       return n.n<m.n;
    }
    int main()
    {
    int n;
    scanf("%d",&n);
    while(n--)
    {
        int m;
        scanf("%d",&m);
        memset(a,0,sizeof(a));
        for(int i=0;i<m;i++)
            scanf("%lf%lf",&a[i].n,&a[i].m);
        sort(a,a+m,cmp);
        double sum=0;
        double sum1=0;
        int i;
        for( i=0;i<m;i++)
        {
            if(a[i].m<a[i+1].n && i+1<m)
            {
                if(a[i].n>sum1)
                {
                    sum1=a[i+1].n;
                    sum+=(a[i].m-a[i].n)+(a[i+1].m-a[i+1].n);        
                }
                else
                {
                    if(a[i].m>sum1)           
                    {
                        sum+=a[i].m-sum1+a[i+1].m-a[i+1].n;
                        sum1=a[i+1].m;
                    }
                }
                i+=1;
            }
            else
            {
                if(a[i].m>a[i+1].n && i+1<m)
                {
                  if(a[i+1].m>a[i].m &&  sum1<a[i].n)
                   {
                        sum+=a[i+1].m-a[i].n;
                     sum1=a[i+1].m;
                   }
                   else
                   {
                        if(sum1<a[i].n){
                            sum+=a[i].m-a[i].n;
                     sum1=a[i].m;
                        }
                     else
                     {
                         if(a[i].m>sum1){
                             sum+=a[i+1].m-sum1;
                            sum1=a[i+1].m;
                         }
                         else
                         {
                             if(sum1<a[i+1].n){
                                 sum+=a[i+1].m-sum1;
                            sum1=a[i+1].m;
                             }
                         }
                     }
                   }
                   i++;
                }
                else
                {
                    if(a[i].n>a[i-1].m && i-1>0)
                    {
                         sum+=a[i].m-a[i-1].m;
                    }
                    else{
                        if(i-1>0)    //判断是不是只是一个输入的区间端 
                         {
                             sum+=a[i].m-a[i].n;
                         }
                        else
                         sum+=a[i].m-a[i].n;
                    }
                }
            }
        }
        cout<<sum<<endl;
    }
    return 0;
    }

    展开全文
  • 计算线段长度

    2020-01-14 11:09:03
    已知线段个端点的坐标A(Xa,Ya)A(Xa,Ya),B(Xb,Yb)B(Xb,Yb),求线段ABAB的长度,保留到小数点后33位。 【输入】 第一行是个实数Xa,YaXa,Ya,即AA的坐标。 第二行是个实数Xb,YbXb,Yb,即BB的坐标。 输入...

    【题目描述】
    已知线段的两个端点的坐标A(Xa,Ya)A(Xa,Ya),B(Xb,Yb)B(Xb,Yb),求线段ABAB的长度,保留到小数点后33位。

    【输入】
    第一行是两个实数Xa,YaXa,Ya,即AA的坐标。

    第二行是两个实数Xb,YbXb,Yb,即BB的坐标。

    输入中所有实数的绝对值均不超过1000010000。

    【输出】
    一个实数,即线段ABAB的长度,保留到小数点后33位。

    【输入样例】
    1 1
    2 2
    【输出样例】
    1.414
    【参考程序】

    #include<iostream>
    #include<cstdio>
    #include<math.h>
    using namespace std;
    int main()
    {
    double xa,ya,xb,yb,n;
    scanf("%lf%lf%lf%lf",&xa,&ya,&xb,&yb);
    n=sqrt((xa-xb)*(xa-xb)+(ya-yb)*(ya-yb));
    printf("%.3lf",n);
    return 0;
    }
    
    展开全文
  • 变分法证明两点之间线段最短

    万次阅读 2019-01-08 16:27:33
    在Part 2., 我们会以用这次介绍的内容和上述方程解决两点之间直线最短的问题为开头,继续介绍变分法。 ----------------------------------------------------------------------------------------------------...

    传送门https://zhuanlan.zhihu.com/yueaptx

    变分法简介Part 1.(Calculus of Variations)

    Dr.Stein

    Dr.Stein

    计算力学

    ​关注他

    283 人赞了该文章

    1. 泛函数 (Functionals)

     

    简而言之,泛函数是函数的函数,即它的输入是函数,输出是实数。而这个输出值取决于一个或多个函数(输入)在一整个路径上的积分而非像一般函数一样取决于离散的变量。这样说可能还是比较抽象,不过坚持看到下文的Example 1就可以更好理解了。

    通常在变分法中,泛函数是一个积分,记做I

    I(y)=\int_{x1}^{x2}Fdx

    其中我们想要通过选择被积函数F来最大化或最小化泛函数I的值。同时我们称F为拉格朗日函数(Lagrange function)。F可以是函数y(x)y(x)各阶导数的函数(以下y(x)均简写成y)。为了说明方便,我们先姑且设Fyy'的函数,所以我们可以进一步将泛函数I写成:

    I(y)=\int_{x1}^{x2}F(y,y';x)dx

    积分里面我用分号;将x和前面的y隔开代表yy'x的函数。一般Fy的函数关系是已知的,所以想要最大或最小化泛函数,实际上是通过选择适当的函数y(x)

    为了透彻理解这个概念,我们可以来看一个简单的例子。

    Example 1.

    一个最简单直观的例子是求两个固定点之间的最短路径。当然大家都知道两点之间直线最短,这里可以用变分法做出解释。

    如上图所示路径是一任意路径,我们取区中一小段微元ds,可以容易计算微元断的长度为:

    ds^2=dx^2+dy^2=[1+(y')^2]dx^2,即:

    ds=\sqrt{1+(y')^2}dx

    积分得到总的路径长度为:

    L=\int_{x1}^{x2}ds=\int_{x1}^{x2}\sqrt{1+(y')^2}dx

    这个例子中,L是泛函数,\sqrt{1+(y')^2}是拉格朗日函数F,我们想要找一个函数y(x)使得泛函数L的值最小。这次Part 1.的任务就是为解决这个问题做准备。Part 2.中我们会用变分法证明这个y(x)确实是直线的方程。

    2. 泛函数的极值

     

    这里重申下,泛函数I在区间[x_1,x_2]上的值取决于积分路径的选择,即取决于函数y(x)的选择。我们有理由假设存在一个这样的y(x),可以使得泛函数I取到极值。而在这个y(x)附近的任意路径我们记做\tilde{y}(x)。另外,我们假设y(x)两阶可微。通过引入一个微小量\epsilon\ll 1和一个任意可微函数\eta(x),我们可以用y(x)表示\tilde{y}(x):

    \tilde{y}(x)=y(x)+\epsilon\eta(x)

    这样做的好处是对于一个给定的\eta(x),我们可以通过改变\epsilon的值来得到无穷多的路径,同时对于任何\eta(x),当\epsilon=0的时候,\tilde{y}(x)y(x)重合。

    图像直观表示如下图:

    由于在边界条件的限制,\eta(x_1)=\eta(x_2)=0。这样就能保证\tilde{y}(x)可以通过两个固定端点。

    这时我们可以说,y(x)所对应的泛函数I的值是泛函数\tilde{I}=\int_{x_1}^{x_2}F(\tilde{y},\tilde{y}';x)dx的极值。我们可以进一步用\epsilon表示\tilde{I}

    \tilde{I}=\int_{x_1}^{x_2}F(\tilde{y},\tilde{y}';x)dx=\int_{x1}^{x_2}F(y+\epsilon\eta,y'+\epsilon\eta';x)dx

    虽然y(x)未知,但是根据之前的合理假设,y(x)是一个存在的确定函数。所以根据上式,如果给定一个特定的\eta(x)\tilde{I}的变化只取决于\epsilon的变化。所以我们现在可以把\tilde{I}看做是\epsilon的函数。用泰勒展开公式将\tilde{I}\epsilon=0处展开得到:

    \tilde{I}(\epsilon)=\tilde{I}|_{\epsilon=0}+(\frac{d\tilde{I}}{d\epsilon})\Big|_{\epsilon=0}\cdot\epsilon+ (\frac{d^2\tilde{I}}{d\epsilon^2})\Big|_{\epsilon=0}\cdot\frac{\epsilon^2}{2!} +\cdot \cdot \cdot =\tilde{I}_0+\tilde{I}_1\epsilon+\tilde{I}_2\epsilon^2+\cdot \cdot \cdot

    很明显,当\epsilon=0时,\tilde{I}|_{\epsilon=0}=I,带入上式可得到:

    \tilde{I}-I=\tilde{I}_1\epsilon+\tilde{I}_2\epsilon^2+\cdot \cdot \cdot

    这里我们记\delta I=\tilde{I}_1\epsilon=\frac{d\tilde{I}}{d\epsilon}\Big|_{\epsilon=0}\cdot\epsilon,并称之为一阶变分。同理二阶变分为\delta I^2=\tilde{I}_2\epsilon^2

    (这里插一句变分和微分的区别。变分在上图的直观解释是\tilde{y}y在竖直方向上的距离,称之为\delta y,所以这个差是在同一个x上计算的。而微分则是由于x的微小变动引起的y的变动。)

    然后我们可以类比求函数极值时的做法。求函数极值时,我们会令函数的一阶导数为零。这里同样,为了求泛函数\tilde{I}的极值,我们令一阶变分\delta I=0。现在我们计算化简\delta I:

    \delta I=(\int_{x_1}^{x_2}\frac{d\tilde{F}}{d\epsilon}\Big|_{\epsilon=0} dx)\cdot\epsilon
    \frac{d\tilde{F}}{d\epsilon}\Big|_{\epsilon=0} \cdot\epsilon=(\frac{\partial\tilde{F}}{\partial\tilde{y}}\cdot\frac{d\tilde{y}}{d\epsilon}+  \frac{\partial\tilde{F}}{\partial\tilde{y'}}\cdot\frac{d\tilde{y'}}{d\epsilon})\Big|_{\epsilon=0}\cdot\epsilon

    因为 \tilde{y}(x)=y(x)+\epsilon\eta(x), 不难得到:\frac{d\tilde{y}}{d\epsilon}=\eta,\frac{d\tilde{y'}}{d\epsilon}=\eta',另外我们有\delta y=\epsilon \eta,\delta y'=\epsilon\eta'

    又因为当\epsilon\rightarrow 0时,\tilde{F}\rightarrow 0, \tilde{y}\rightarrow y,\tilde{y}'\rightarrow y',将这些式子带入原式可以得到:

    \delta I=\int_{x_1}^{x_2}(\frac{\partial F}{\partial y}\delta y+\frac{\partial F}{\partial y'}\delta y')dx

    终于到最后一步啦,分部积分一下得到:

    \delta I=\int_{x_1}^{x_2}(\frac{\partial F}{\partial y}-\frac{d}{dx}(\frac{\partial F}{\partial y'} ))\delta ydx+\frac{\partial F}{\partial y'}\delta y\Big|_{x_1}^{x_2}

    \delta I=0就可以解得最小化泛函数的y啦。我们注意到\delta I有两个部分。对于第一个积分部分,由于\delta y是任意的,所以要想使这个部分等于零,需要保证^{[1]}

    \frac{\partial F}{\partial y}-\frac{d}{dx}(\frac{\partial F}{\partial y'} )=0 (x_1\leq x\leq x_2)

    这就是传说中的欧拉-拉格朗日方程(E-L equation)。

    而第二部分等于零则是边界条件。

    在Part 2., 我们会以用这次介绍的内容和上述方程解决两点之间直线最短的问题为开头,继续介绍变分法。

    ---------------------------------------------------------------------------------------------------------------------------

    注[1]:

    假设x_1x_2是给定的常数,\phi(x)是一个特定的在x_1\leq x\leq x_2上连续的函数,那么如果对于任意连续可微的函数\eta(x)都成立\int_{x_1}^{x_2}\phi(x)\eta(x)dx=0,则\phi(x)=0 (x_1\leq x\leq x_2)。

    (任意函数和一个非零的特定函数的乘积仍是任意函数,由于无法保证任意函数的积分是零,所以这个特定函数必须在这个区间上恒等于零使得乘积为零,这样可以保证积分为零。)

    展开全文
  • 思路:要构成线段,即长度...//100个点,任意两点构成线段 //求在可以构成的所有线段中,长度最小的线段长度 #include<stdio.h> #include<math.h> #define n 3 int main(){ double a[n][2]={0},min,d; ...
  • 已知某一点坐标,旋转角度,长度,求另一点坐标 */ export const calculateCoordinatePoint = (originPoint, degree, len) => { let rotate = (degree - 90 + 360) % 360; //这里是因为一开始以y轴下方为0度的...
  • 1033:计算线段长度

    2021-07-01 18:59:47
    1033:计算线段长度 时间限制: 1000 ms 内存限制: 65536 KB 【题目描述】 已知线段的个端点的坐标A(Xa,Ya),B(Xb,Yb),求线段AB的长度,保留到小数点后3位。 【输入】 第一行是个实数Xa,Ya,即A的坐标。 第...
  • 题目:平面有100个点,任意两点可以构成一个线段,编一个程序,输出在构成的所有线段中,长度最长的线段长度两点之间的距离公式为:d=根号下(x1-x2平方+y1-y2平方) 思路:1.因为100个点输入起来很麻烦,我的想法...
  • JoyOI1021 线段长度

    2018-08-07 03:18:05
    数轴上有N个点,任意两点连线得到n(n-1)条线段,试求线段的总长。 输入格式 第一行,一个整数N,表示点数。 接下来N行,每行一个整数X_i,表示点的坐标。 输出格式 一个整数,表示线段的总长。 提示 N &...
  • 16:计算线段长度

    千次阅读 2019-03-05 21:58:10
    已知线段个端点的坐标A(Xa,Ya),B(Xb,Yb),求线段AB的长度。 输入 共行。 第一行是个实数Xa,Ya,即A的坐标。 第二行是个实数Xb,Yb,即B的坐标。 输入中所有实数的绝对值均不超过10000。 输出 ...
  • 【小韦同学@神犇营-21-计算线段长度】 题目: 描述 已知线段的个端点的坐标A(Xa,Ya),B(Xb,Yb),求线段AB的长度。 输入 共行。 第一行是个实数Xa,Ya,即A的坐标。 第二行是个实数Xb,Yb,即B的坐标。 ...
  • P1021 线段长度

    2015-01-05 12:59:33
    数轴上有N个点,任意两点连线得到n(n-1)条线段,试求线段的总长。 输入格式 InputFormat 第一行,一个整数N,表示点数。接下来N行,每行一个整数X_i,表示点的坐标。 输出格式 OutputFormat 一个整数,表示线段...
  • 本文给大家分享的是C (23)——计算线段长度的分析和相关内容,内含源码分析,遇到同样问题的朋友可以参考一下,如果有更好的解决方法,请留言分享帮助更多的程序员。总时间限制:1000ms内存限制:65536kB描述已知线段...
  • 已知线段个端点的坐标A(Xa,Ya),B(Xb,Yb),求线段AB的长度。 输入 共行。 第一行是个实数Xa,Ya,即A的坐标。 第二行是个实数Xb,Yb,即B的坐标。 输入中所有实数的绝对值均不超过10000。 输出 一个...
  • 1033:计算线段长度 时间限制: 1000 ms 内存限制: 32768 KB 提交数: 25909 通过数: 14589 【题目描述】 已知线段的个端点的坐标A(Xa,Ya)A(Xa,Ya),B(Xb,Yb)B(Xb,Yb),求线段ABAB的长度,保留到小数点后33位...
  • 在一条长度为1的线段上随机取,则以这为端点的线段的期望长度是1/3,为什么?
  • 线段覆盖长度

    2015-08-10 15:07:03
    给定一些线段线段有起点和终点,求这些线段的覆盖长度,重复的部分只计算一次。 这是在小桥流水博客中看到的一道面试题(小米科技),后来为了练习线段树这个数据结构,就做了一下这道题,本节给出种方法,一...
  • 提到平面图形的稳定性,大家...很简单,只需要添加一条线段,让它变成个三角形即可。在我们平常生活中,很多东西都是利用了三角形的稳定性,也随处可见,比如说我们自行车的车架、比如塔吊、人字梯、比如斜拉桥等...
  • 求坐标中的线段长度

    千次阅读 2018-05-06 16:15:10
    用c语言解决:顺次输入n个坐标(x,y),会形成n-1条线段,输出最长的长度;求大佬赐教
  • 已知线段个端点的坐标 A(Xa,Ya),B(Xb,Yb),求线段 AB 的长度。 蒜头君老师告诉了你计算公式如下:√(Xa−Xb)2+(Ya−Yb)2。 输入格式 共行。 第一行是个实数 Xa,Ya,即 A 的坐标。 第二行是个实数 Xb,Yb,...
  • 【OpenJudge】c语言_计算线段长度

    千次阅读 2016-07-28 09:55:45
    计算线段长度 查看提交统计提问 总时间限制: 1000ms 内存限制: 65536kB 描述 已知线段的个端点的坐标A(Xa,Ya),B(Xb,Yb),求线段AB的长度。 输入共行。 第一行是个实数Xa...
  • 线段长度问题 时间限制(普通/Java):5000MS/10000MS 运行内存限制:65536KByte 描述 在数轴X轴上有n条线段,线段之间可以有重叠,计算所有线段覆盖X轴的总长度。 输入 输入文件第一行为测试用例个数N(1...
  • System.out.println("线段长度为:"); System.out.printf("%.2f\n" ,line1.length()); System.out.println("线段平移(1,1)后位置为:"); line1.move(1,1); System.out.print(line1.location()); ...
  • (取自定位导航项目)哇!这不就是一道初中的数学题嘛!But... 已知三点 A(m,n),B(P,q),C(s,f),并且坐标都是已知的。通过直线方程 y=kx+b及A、B两点,可...则直线方程已知,通过两点间距离公式,可以求...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 37,007
精华内容 14,802
关键字:

两点之间线段长度