JZOJ4117. lhxsb

最新推荐文章于 2021-01-07 21:35:33 发布
最新推荐文章于 2021-01-07 21:35:33 发布
阅读量234 收藏
点赞数
分类专栏： OJ题解 原创方法 计算几何 分治 二分 三分 分治-cdq分治
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gmh77/article/details/80480665
版权

题目描述

这里写图片描述
这里写图片描述
这里写图片描述

20%

暴力搞就行了……
每次用反正切(atan)来搞

100%

水法

cdq分治。
每次按照x来排序，左右各扫一遍。

可以通过感性理解来发现弧度最小的点一定在凸壳上
所以分别维护一个上凸壳，之后在上面暴力用叉积判方向即可

code


#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#define fo(a,b,c) for (a=b; a<=c; a++)
#define fd(a,b,c) for (a=b; a>=c; a--)
#define min(x,y) (x<y?x:y)
#define max(x,y) (x>y?x:y)
using namespace std;

double x[100001];
double y[100001];
int A[100001][2];
int a[200001][4];
bool bz[100001];
int d[200001];
double ans1[100001];
double ans2[100001];
int i,j,k,l,n,m,len;

inline int getint() { char c; int ret=0; for(c=getchar(); c<'0' || c>'9'; c=getchar()); for(; c>='0'&&c<='9'; c=getchar()) ret=ret*10+c-'0'; return ret; }
void swap(double &a,double &b) {double c=a;a=b;b=c;}
double cross(int i,int j,int k) {return (x[i]-x[k])*(y[j]-y[k])-(x[j]-x[k])*(y[i]-y[k]);}

void qsort(int l,int r)
{
    int i,j;
    double mid;

    i=l;
    j=r;
    mid=x[(l+r)/2];

    while (i<=j)
    {
        while (x[i]<mid) i++;
        while (x[j]>mid) j--;

        if (i<=j)
        {
            swap(x[i],x[j]);
            swap(y[i],y[j]);

            i++,j--;
        }
    }

    if (l<j) qsort(l,j);
    if (i<r) qsort(i,r);

    return;
}

void Qsort(int l,int r)
{
    int i,j,mid,Mid;

    i=l;
    j=r;
    mid=a[(l+r)/2][1];
    Mid=a[(l+r)/2][0];

    while (i<=j)
    {
        while (a[i][1]<mid || a[i][1]==mid && a[i][0]>Mid) i++;
        while (a[j][1]>mid || a[j][1]==mid && a[j][0]<Mid) j--;

        if (i<=j)
        {
            swap(a[i][0],a[j][0]);
            swap(a[i][1],a[j][1]);
            swap(a[i][2],a[j][2]);
            swap(a[i][3],a[j][3]);

            i++,j--;
        }
    }

    if (l<j) Qsort(l,j);
    if (i<r) Qsort(i,r);

    return;
}

double xl(int i,int j)
{
    if (y[i]==y[j]) return 0;
    return (y[j]-y[i])/(x[j]-x[i]);
}

double work(int X,int S,int R)
{
    int L,Mid,MMid;
    double m1,m2,s;

    for (L=R; L>1 && cross(d[L],d[L-1],X)*S<0; L--);

    if (y[d[L]]==y[X])
    s=M_PI_2;
    else
    s=atan(S*(x[X]-x[d[L]])/(y[d[L]]-y[X]));
    if (s<0) s+=M_PI;

    return s;
}

void dg(int l,int r)
{
    int i,j,L,R,Mid,MMid,mid=(l+r)/2;
    double s,m1,m2;

    if (l==r) return;

    dg(l,mid);
    dg(mid+1,r);

    len=0;
    Qsort(l,r);

    fo(i,l,r)
    if (!a[i][0] && a[i][2]<=mid)
    {
        while (len>1 && xl(d[len-1],d[len])<xl(d[len],a[i][1])) len--;
        d[++len]=a[i][1];
    }
    else
    if ( a[i][0] && a[i][2]> mid && len)
    {
        s=work(a[i][1],1,len);
        ans1[a[i][3]]=min(ans1[a[i][3]],s);
    }

    fo(i,l,r-1)
    if (a[i][1]==a[i+1][1] && a[i][0]>a[i+1][0])
    swap(a[i][0],a[i+1][0]),swap(a[i][1],a[i+1][1]),swap(a[i][2],a[i+1][2]),swap(a[i][3],a[i+1][3]);

    len=0;

    fd(i,r,l)
    if (!a[i][0] && a[i][2]<=mid)
    {
        while (len>1 && xl(d[len],d[len-1])>xl(a[i][1],d[len])) len--;
        d[++len]=a[i][1];
    }
    else
    if ( a[i][0] && a[i][2]> mid && len)
    {
        for (R=len; R && d[R]==a[i][1]; R--);

        s=work(a[i][1],-1,R);
        ans2[a[i][3]]=min(ans2[a[i][3]],s);
    }
}

int main()
{
//  freopen("lhxsb2.in","r",stdin);

    n=getint();
    m=getint();
    fo(i,1,n)
    x[i]=getint(),y[i]=getint();

    qsort(1,n);

    fo(i,1,m)
    {
        A[i][0]=getint();
        A[i][1]=getint();
        if (!A[i][0]) bz[A[i][1]]=1;
    }

    j=0;
    fo(i,1,n)
    if (!bz[i])
    {
        j++;
        a[j][0]=0;
        a[j][1]=i;
        a[j][2]=j;
    }

    l=0;
    fd(i,m,1)
    {
        j++;
        a[j][0]=A[i][0];
        a[j][1]=A[i][1];
        a[j][2]=j;

        if (a[j][0])
        {
            l++;
            ans1[l]=233;
            ans2[l]=233;
            a[j][3]=l;
        }
    }
    m=j;

    dg(1,m);

    fd(i,l,1)
    printf("%0.6lf\n",ans1[i]+ans2[i]);

    return 0;
}

正解(伪)

在凸壳上三分
因为是个凸壳，所以可以三分求极值
慢到爆炸
其实一开始是用O2卡过的
没错这是我自己想的SB方法

code


#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#define fo(a,b,c) for (a=b; a<=c; a++)
#define fd(a,b,c) for (a=b; a>=c; a--)
#define min(x,y) (x<y?x:y)
#define max(x,y) (x>y?x:y)
using namespace std;

double x[100001];
double y[100001];
int A[100001][2];
int a[200001][4];
bool bz[100001];
int d[200001];
double ans1[100001];
double ans2[100001];
int i,j,k,l,n,m;

inline int getint() { char c; int ret=0; for(c=getchar(); c<'0' || c>'9'; c=getchar()); for(; c>='0'&&c<='9'; c=getchar()) ret=ret*10+c-'0'; return ret; }
void swap(double &a,double &b) {double c=a;a=b;b=c;}

void qsort(int l,int r)
{
    int i,j;
    double mid;

    i=l;
    j=r;
    mid=x[(l+r)/2];

    while (i<=j)
    {
        while (x[i]<mid) i++;
        while (x[j]>mid) j--;

        if (i<=j)
        {
            swap(x[i],x[j]);
            swap(y[i],y[j]);

            i++,j--;
        }
    }

    if (l<j) qsort(l,j);
    if (i<r) qsort(i,r);

    return;
}

void Qsort(int l,int r)
{
    int i,j,mid,Mid;

    i=l;
    j=r;
    mid=a[(l+r)/2][1];
    Mid=a[(l+r)/2][0];

    while (i<=j)
    {
        while (a[i][1]<mid || a[i][1]==mid && a[i][0]>Mid) i++;
        while (a[j][1]>mid || a[j][1]==mid && a[j][0]<Mid) j--;

        if (i<=j)
        {
            swap(a[i][0],a[j][0]);
            swap(a[i][1],a[j][1]);
            swap(a[i][2],a[j][2]);
            swap(a[i][3],a[j][3]);

            i++,j--;
        }
    }

    if (l<j) Qsort(l,j);
    if (i<r) Qsort(i,r);

    return;
}

double xl(int i,int j)
{
    if (y[i]==y[j]) return 0;
    return (y[j]-y[i])/(x[j]-x[i]);
}

double Xl(int i,int j)
{
    if (y[i]==y[j]) return 0;
    return (y[i]-y[j])/(x[j]-x[i]);
}

void dg(int l,int r)
{
    int i,j,L,R,Mid,MMid,mid=(l+r)/2;
    double s,m1,m2;

    if (l==r) return;

    dg(l,mid);
    dg(mid+1,r);

    int len=0;
    Qsort(l,r);

    fo(i,l,r)
    if (!a[i][0] && a[i][2]<=mid)
    {
        while (len>1 && xl(d[len-1],d[len])<xl(d[len],a[i][1])) len--;
        d[++len]=a[i][1];
    }
    else
    if ( a[i][0] && a[i][2]> mid && len)
    {
        L=1;
        R=len;
        while (L<R)
        {
            Mid=(L+R)/2;
            MMid=(Mid+R)/2;

            if (Mid==MMid)
            Mid--,MMid++;

            if (L+1==R)
            Mid=L,MMid=R;

            if (y[d[Mid]]==y[a[i][1]])
            m1=M_PI_2;
            else
            m1=atan((x[a[i][1]]-x[d[Mid]])/(y[d[Mid]]-y[a[i][1]]));
            if (m1<0) m1+=M_PI;

            if (y[d[MMid]]==y[a[i][1]])
            m2=M_PI_2;
            else
            m2=atan((x[a[i][1]]-x[d[MMid]])/(y[d[MMid]]-y[a[i][1]]));
            if (m2<0) m2+=M_PI;

            if (L+1==R)
            {
                if (m1>m2)
                L++; else R--;
                break;
            }

            if (m1<=m2)
            {
                if (R==MMid)
                R--;else R=MMid;
            }
            else
            {
                if (L==Mid)
                L++;else L=Mid;
            }
        }

        if (y[d[L]]==y[a[i][1]])
        s=M_PI_2;
        else
        s=atan((x[a[i][1]]-x[d[L]])/(y[d[L]]-y[a[i][1]]));
        if (s<0) s+=M_PI;

        ans1[a[i][3]]=min(ans1[a[i][3]],s);
    }

    fo(i,l,r-1)
    if (a[i][1]==a[i+1][1] && a[i][0]>a[i+1][0])
    swap(a[i][0],a[i+1][0]),swap(a[i][1],a[i+1][1]),swap(a[i][2],a[i+1][2]),swap(a[i][3],a[i+1][3]);

    len=0;
    fd(i,r,l)
    if (!a[i][0] && a[i][2]<=mid)
    {
        while (len>1 && Xl(d[len],d[len-1])<Xl(a[i][1],d[len])) len--;
        d[++len]=a[i][1];
    }
    else
    if ( a[i][0] && a[i][2]> mid && len)
    {
        L=1;
        for (R=len; R && d[R]==a[i][1]; R--);

        while (L<R)
        {
            Mid=(L+R)/2;
            MMid=(Mid+R)/2;

            if (Mid==MMid)
            Mid--,MMid++;

            if (L+1==R)
            Mid=L,MMid=R;

            if (y[d[Mid]]==y[a[i][1]])
            m1=M_PI_2;
            else
            m1=atan((x[d[Mid]]-x[a[i][1]])/(y[d[Mid]]-y[a[i][1]]));
            if (m1<0) m1+=M_PI;

            if (y[d[MMid]]==y[a[i][1]])
            m2=M_PI_2;
            else
            m2=atan((x[d[MMid]]-x[a[i][1]])/(y[d[MMid]]-y[a[i][1]]));
            if (m2<0) m2+=M_PI;

            if (L+1==R)
            {
                if (m1>m2)
                L++; else R--;
                break;
            }

            if (m1<=m2)
            {
                if (R==MMid)
                R--;else R=MMid;
            }
            else
            {
                if (L==Mid)
                L++;else L=Mid;
            }
        }

        if (y[d[L]]==y[a[i][1]])
        s=M_PI_2;
        else
        s=atan((x[d[L]]-x[a[i][1]])/(y[d[L]]-y[a[i][1]]));
        if (s<0) s+=M_PI;

        ans2[a[i][3]]=min(ans2[a[i][3]],s);
    }
}

int main()
{
    n=getint();
    m=getint();
    fo(i,1,n)
    x[i]=getint(),y[i]=getint();

    qsort(1,n);

    fo(i,1,m)
    {
        A[i][0]=getint();
        A[i][1]=getint();
        if (!A[i][0]) bz[A[i][1]]=1;
    }

    j=0;
    fo(i,1,n)
    if (!bz[i])
    {
        j++;
        a[j][0]=0;
        a[j][1]=i;
        a[j][2]=j;
    }

    l=0;
    fd(i,m,1)
    {
        j++;
        a[j][0]=A[i][0];
        a[j][1]=A[i][1];
        a[j][2]=j;

        if (a[j][0])
        {
            l++;
            ans1[l]=233;
            ans2[l]=233;
            a[j][3]=l;
        }
    }
    m=j;

    dg(1,m);

    fd(i,l,1)
    printf("%0.6lf\n",ans1[i]+ans2[i]);

    return 0;
}

正解

直接二分就ok了
二分判叉积

code

无奇怪的优化


#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#define fo(a,b,c) for (a=b; a<=c; a++)
#define fd(a,b,c) for (a=b; a>=c; a--)
#define min(x,y) (x<y?x:y)
#define max(x,y) (x>y?x:y)
using namespace std;

struct BND{int s0,s1,s2,s3;};
struct DDF{double x,y;};

DDF z[100001];
int A[100001][2];
BND a[200001];
bool bz[100001];
int d[200001];
double Xl[200001];
double ans1[100001];
double ans2[100001];
int i,j,k,l,n,m,len;

inline int gt() { char c; int ret=0; for(c=getchar(); c<'0' || c>'9'; c=getchar()); for(; c>='0'&&c<='9'; c=getchar()) ret=ret*10+c-'0'; return ret; }
inline double cross(int i,int j,int k) {return (z[i].x-z[k].x)*(z[j].y-z[k].y)-(z[j].x-z[k].x)*(z[i].y-z[k].y);}
inline void swap(BND &a,BND &b) {BND c=a;a=b;b=c;}

bool cmp(DDF a,DDF b) {return a.x<b.x;}
bool Cmp(BND a,BND b) {return a.s1<b.s1;}

double xl(int i,int j)
{
    if (z[i].y==z[j].y) return 0;
    return (z[j].y-z[i].y)/(z[j].x-z[i].x);
}

double work(int X,int S,int R)
{
    int L,Mid;
    double m1,m2,s;

    L=1;
    R--;
    while (L<R)
    {
        Mid=(L+R)>>1;

        if (cross(d[Mid],d[Mid+1],X)*S<0)
        L=Mid+1; else R=Mid;
    }
    if (L==R && cross(d[L],d[L+1],X)*S<0) L++;

    if (z[d[L]].y==z[X].y)
    s=M_PI_2;
    else
    s=atan(S*(z[X].x-z[d[L]].x)/(z[d[L]].y-z[X].y));
    if (s<0) s+=M_PI;

    return s;
}

void dg(int l,int r)
{
    int i,j,R,Mid,MMid,mid=(l+r)>>1;
    double s,m1,m2;

    if (l==r) return;

    dg(l,mid);
    dg(mid+1,r);

    stable_sort(a+l,a+r+1,Cmp);

    len=0;
    fo(i,l,r)
    if (!a[i].s0 && a[i].s2<=mid)
    {
        while (len>1 && Xl[len-1]<xl(d[len],a[i].s1)) len--;
        d[++len]=a[i].s1;

        if (len>1) Xl[len-1]=xl(d[len-1],d[len]);
    }
    else
    if ( a[i].s0 && a[i].s2> mid && len)
    {
        for (R=len; R && d[R]==a[i].s1; R--);

        if (R)
        {
            s=work(a[i].s1,1,R);
            ans1[a[i].s3]=min(ans1[a[i].s3],s);
        }
    }

    len=0;
    fd(i,r,l)
    if (!a[i].s0 && a[i].s2<=mid)
    {
        while (len>1 && Xl[len-1]>xl(a[i].s1,d[len])) len--; 
        d[++len]=a[i].s1;

        if (len>1) Xl[len-1]=xl(d[len-1],d[len]);
    }
    else
    if ( a[i].s0 && a[i].s2> mid && len)
    {
        for (R=len; R && d[R]==a[i].s1; R--);

        if (R)
        {
            s=work(a[i].s1,-1,R);
            ans2[a[i].s3]=min(ans2[a[i].s3],s);
        }
    }
}

int main()
{
    n=gt();m=gt();
    fo(i,1,n)
    z[i].x=gt(),z[i].y=gt();

    stable_sort(z+1,z+n+1,cmp);

    fo(i,1,m)
    {
        A[i][0]=gt();A[i][1]=gt();
        if (!A[i][0]) bz[A[i][1]]=1;
    }

    j=0;
    fo(i,1,n)
    if (!bz[i])
    {
        j++;
        a[j].s0=0;
        a[j].s1=i;
        a[j].s2=j;
    }

    l=0;
    fd(i,m,1)
    {
        j++;
        a[j].s0=A[i][0];
        a[j].s1=A[i][1];
        a[j].s2=j;

        if (a[j].s0)
        {
            l++;
            ans1[l]=233;
            ans2[l]=233;
            a[j].s3=l;
        }
    }
    m=j;

    dg(1,m);

    fd(i,l,1)
    printf("%0.6lf\n",ans1[i]+ans2[i]);

    return 0;
}
gmh77
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JZOJ 6873. 【2020.11.19提高组模拟】飞翔的鸟（矩阵乘法）
ZSJZ_liuzian的博客
01-07 302
JZOJ 6873. 【2020.11.19提高组模拟】飞翔的鸟 题解 n,kn,kn,k的数据范围看起来就知道要用矩乘，但障碍的位置是不确定的。 如果暴力枚举n−2n-2n−2次障碍的位置，分别计算每种情况障碍左右两边的方案数，再左右相乘起来，每种情况相加求平均数，可以通过部分的数据。 这样显然过不了，考虑能否一次做完？ 其实可以每个位置设两个状态0/10/10/1分别表示是否经过障碍，然后分三种情况，000转移到000，111转移到111，000转移到111， 其中前两种可以直接按题意从xxx转移到x
1005. 【USACO题库】1.3.2 Barn Repair修理牛棚
最新发布
03-17
题目描述 在一个暴风雨的夜晚,农民约翰的牛棚的屋顶、门被吹飞了。 好在许多牛正在度假，所以牛棚没有住满。 剩下的牛一个紧挨着另一个被排成一行来过夜。 有些牛棚里有牛，有些没有。 所有的牛棚有相同的宽度。...
【JZOJ4117】lhxsb（三角函数+凸壳+CDQ分治）
qq_36551189的博客
05-24 319
Problem 　　给定一个山脉，把山脉的下部看作xOy平面直角坐标系中y=0的直线，用N个来顶点表示山脉。如图： 　　Lwins_Y uki有Q个操作，操作有两种：对某个点用魔法（即删点）或询问某个点对空视野的张角（可以超过180°）。譬如上图第3个点的张角是： Input 第一行包含两个正整数N;Q，分别表示刚开始的时候山的顶点个数以及Lwins_Y uki 的行动个数。 ...
JZOJ 6307. 安排（归并排序+分治）
ZSJZ_liuzian的博客
08-20 195
JZOJ6307. 安排 题目 Description Input Output Sample Input 6 1 3 5 6 4 2 1 2 3 4 5 6 Sample Output 4 2 3 3 6 2 5 4 5 Data Constraint Hint 题解 这是一道奇妙的题！！！！！ 定义：交换两个数时，若这两个数分别是这段区间的最大值和最小值，则称此交换为合法的。 最暴...
JZOJ4896. 兔子
Akakii的博客
11-15 682
题目大意 给定一个n个点m条边的无向图。 保证图中最多只有一个点度数大于2。 现在可以设置不超过k个关键点，求最大的每个点到关键点的距离最小是多少。 Data Constraint k≤n≤1000,m≤1500
JZOJ1238. 自行车比赛
qq_43410154的博客
08-11 124
Description 自行车赛在一个很大的地方举行，有N个镇，用1到N编号，镇与镇之间有M条单行道相连，起点设在镇1，终点设在镇2。 问从起点到终点一共有多少种不同的路线。两条路线只要不使用完全相同的道路就被认为是不同的。 Input 第一行两个整数：N和M(1<=N<=10000,1<=M<=100000)，表示镇的数量和道路的数量。 接下来M行，每行包含两个不同的整数...
jzoj6101. 【GDOI2019模拟2019.4.2】Path
adfa4535的博客
04-02 154
题目链接：https://jzoj.net/senior/#main/show/6101 记\(f_i\)为从\(i\)号点走到\(n\)号点所花天数的期望 那么根据\(m\)条边等可能的出现一条和一定会往期望值较小的点走的贪心策略我们可以得到 \[ f_i=\frac{1}{m}\sum min(f_i,f_j)+1 \] 其中当\(i,j\)不相连的时候可将\(f_j\)看做无限大 ...
JZOJ 6943. 【2020.01.05冬令营模拟】社会实践（线段树）
ZSJZ_liuzian的博客
01-07 152
JZOJ 6943. 【2020.01.05冬令营模拟】社会实践 题解 题目的原型还是汉诺塔问题，操作规则和普通汉诺塔问题是一样的，先考虑对于某个单独询问如何计算最优答案。 按普通汉诺塔，考虑还原的过程，发现根本不知道下一步该如何移动，无法解决， 但如果从还原好的状态倒推，每一步移动都是自然的，初始所有圆盘都在最大圆盘应回到的柱子，然后从大到小，如果第iii个已复位则忽略， 否则将剩下i−1i-1i−1个移到第三根柱，再移动第iii个，步数为2i−12^{i-1}2i−1。这样移动可以保证时刻都是合法的。
JZOJ3238. 超空间旅行
Deep_Thinking的博客
07-11 218
Description 有向图有些边的的边权都为未知的x，求当x为正整数时S到T的最短路有多少种取值，并求不同最短路长度之和。 n<=500,m<=10000,Q<=10 Solution 设dis[x][i]表示到S出发到x点，经过i调未知边时已知边的最小代价。 SPFA求出即可。 发现最短路为未知边权为x时，y=i*x+dis[T][i]，即一次函数。 维护上凸壳取最小...
JZOJ5010. 编码
Akakii的博客
03-14 699
题目大意 给定n个01串，有一些串中有一个位置未确定。现在要判断，能否找到一种方案，使得任意一个串都不是其他任一串的前缀。 Data Constraint n,总长≤500000
JZOJ 5602. 【NOI2018模拟3.26】Cti & JZOJ 5057. 【GDSOI2017模拟4.13】炮塔
Felix-Lee的博客
03-27 523
Description 有一个 n × m 的地图, 地图上的每一个位置可以是空地, 炮塔或是敌人. 你需要操纵炮塔消灭敌人. 对于每个炮塔都有一个它可以瞄准的方向, 你需要在它的瞄准方向上确定一个它的攻击位置,当然也可以不进行攻击. 一旦一个位置被攻击, 则在这个位置上的所有敌人都会被消灭. 保证对于任意一个炮塔, 它所有可能的攻击位置上不存在另外一个炮塔. 定义炮弹的运行轨迹为炮弹的起...
1060. For循环结构习题：上机练习4（n!）
03-17
题目描述 计算n！，其中n由键盘输入。 输入 输入一行，只有一个整数n(0) 输出 输出只有一行（这意味着末尾有一个回车符号），包括1个整数。 样例输入 复制 4 样例输出 复制 24
线性规划问题
03-06
以代码类的新式，把数学问题化成图形来进行解决
jzoj难题,AC了，代码正确
07-10
点个赞，关注我不迷路
jzoj循环题目放大的x题解
07-10
很难，我就编了个1小时而已，一言难尽，只供参考，不能恶意抄袭
关于菱形转换成矩形的问题
某司机的黑车
01-23 1622
最近两次遇到这类问题（数列、信号塔），其中的转换感觉很奇妙 就是把比♂例放大2√\sqrt2倍，然后旋转45°。 (x,y) => (x-y,x+y) 证明 红边表示x，蓝边表示y 显然可以这样连，易得两三角全等，则中间为等腰直角三角。 则(x,y)、(x-y,x+y)间的夹角为45°，根据勾股定理可得斜边为直角边的2√\sqrt2倍 综上，从(x,y)到(x-y,x
计算几何小结
某司机的黑车
04-12 750
定义 计算几何区别于传统解析几何，是用点和向量之类的与坐标有关的东西来乱搞 点：坐标为(x,y) 向量/线段/直线：两个点，向量有方向，直线无边界 （其实写起来都一样） 其它以后再说 叉积 向量l1、l2（l2在l1顺时针方向且夹角<180°）的叉积为x2y1-x1y2，几何意义是l1、l2构成的平行四边形面积 证明随便yy一下其实我也不会 求三角形面积 平行四边形面积/2=叉积/2 判...
【USACO题库】3.4.3 Electric Fence电网
某司机的黑车
03-29 613
经过观察可以发现，坐标x,y只保留了一位小数。 所以可以直接把坐标系放大10倍，找出结果最小的点，再把该点的x,y坐标除以10。 但是因为放大后再枚举可能会超时，所以要修改一下算法。先通过枚举原坐标系，找出结果最小的点。 那么答案一定在该点附近。 于是选定一块以该点为中心，边长为2的正方形，把里面的坐标扩大10倍再找。 这样可以少很多枚举次数。关于如何计算距离比如这样： 那么距离就是
高中OJ3517. 【NOIP2013模拟11.6B组】空间航行
某司机的黑车
02-11 557
这道题第一眼看上去有些难，但想想可以发现其实很简单。 假设题目要求的是一个二维平面图。 很明显走红线比走蓝线要更短。 所以我们可以求出两两星系间的距离，然后用最短路计算。 为了方便计算，可以把起点和终点设为半径为0的星系。 很显然，这两个星系的距离为s-r1-r2。最重要的一点：如何计算三维空间中两坐标间的长度？ 为方便观看，省略了x轴 假设有这两个坐标要求距离，可以先忽略
C++【jzoj】判断四边形
07-15
对于给定的四个点的坐标，可以使用以下方法来判断它们是否构成一个四边形： 1. 确保四个点不共线。可以通过计算三个点的斜率来判断它们是否共线。如果斜率相等，则说明这三个点共线。 2. 检查四个角的角度和是否为...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值