格林公式求圆并的面积及重心

最新推荐文章于 2023-09-17 13:20:47 发布
最新推荐文章于 2023-09-17 13:20:47 发布
阅读量4.2k 收藏 4
点赞数 5
分类专栏： ACM高等数学 文章标签： ACM 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012061345/article/details/124131562
版权

格林公式求圆并的面积及重心

格林公式

首先写下格林公式，省略了公式成立的条件。

∬ D ( ∂ Q ∂ x − ∂ P ∂ y ) d x d y = ∮ P d x + Q d y \iint_D\big(\frac{\partial{Q}}{\partial{x}}-\frac{\partial{P}}{\partial{y}}\big)dxdy=\oint{Pdx+Qdy} ∬D​(∂x∂Q​−∂y∂P​)dxdy=∮Pdx+Qdy

其中 D D D是一个面， L L L是其边缘曲线。借助格林公式可以将面积分转换为一维的路径积分。 P P P和 Q Q Q是关于 x , y x,y x,y的二元函数。

格林公式对面积及重心的推导

考虑面积公式: s = ∬ D d x d y s=\iint_D{dxdy} s=∬D​dxdy，套用格林公式，令 Q = x , P = − y Q=x,P=-y Q=x,P=−y，则有

s = ∬ D d x d y = 1 2 ∬ D ( ∂ Q ∂ x − ∂ P ∂ y ) d x d y = 1 2 ∮ x d y − y d x s=\iint_D{dxdy}=\frac{1}{2}\iint_D\big(\frac{\partial{Q}}{\partial{x}}-\frac{\partial{P}}{\partial{y}}\big)dxdy=\frac{1}{2}\oint{xdy-ydx} s=∬D​dxdy=21​∬D​(∂x∂Q​−∂y∂P​)dxdy=21​∮xdy−ydx

考虑重心坐标的公式，分别有

x g = ∬ D x d x d y ∬ D d x d y , y g = ∬ D y d x d y ∬ D d x d y x_g=\frac{\iint_D{xdxdy}}{\iint_Ddxdy}, y_g=\frac{\iint_D{ydxdy}}{\iint_Ddxdy} xg​=∬D​dxdy∬D​xdxdy​,yg​=∬D​dxdy∬D​ydxdy​

为了方便起见，将分子分别记作 z x , z y z_x,z_y zx​,zy​。首先考虑 z x z_x zx​，令 Q = 1 2 x 2 , P = 0 Q=\frac{1}{2}x^2,P=0 Q=21​x2,P=0，则

z x = ∬ D ( ∂ Q ∂ x − ∂ P ∂ y ) d x d y = ∬ D x d x d y = ∮ C 1 2 x 2 d y z_x=\iint_D\big(\frac{\partial{Q}}{\partial{x}}-\frac{\partial{P}}{\partial{y}}\big)dxdy = \iint_D{xdxdy} = \oint_C{\frac{1}{2}x^2}dy zx​=∬D​(∂x∂Q​−∂y∂P​)dxdy=∬D​xdxdy=∮C​21​x2dy

同理可得：

z y = − 1 2 ∮ C y 2 d x z_y=-{\frac{1}{2}}\oint_C{y^2dx} zy​=−21​∮C​y2dx

圆并的面积与重心计算

显然圆并的边界均是圆弧，因此可以描述为：

{ x = x 0 + r c o s θ y = y 0 + r s i n θ   α ≤ θ ≤ β \left\{ \begin{aligned} x & = x_0+rcos\theta \\ y & = y_0 + rsin\theta \end{aligned} \right. \, {\rm}{\rm} \alpha\le\theta\le\beta {xy​=x0​+rcosθ=y0​+rsinθ​α≤θ≤β

分别代入上述公式，可以求得：

s = ∮ C x d y − y d x = ∮ C ( x 0 + r c o s θ ) d ( y 0 + r s i n θ ) − ( y 0 + r s i n θ ) d ( x 0 + r c o s θ ) = ∮ C r x 0 d s i n θ + r 2 c o s 2 θ d θ − r y 0 d c o s θ + r 2 s i n 2 θ d θ = r ( x 0 s i n θ − y 0 c o s θ + r θ ) ∣ α β s=\oint_C{xdy-ydx}=\oint_C{(x_0+rcos\theta)d(y_0+rsin\theta)}-(y_0+rsin\theta)d(x_0+rcos\theta) \\ = \oint_C{rx_0dsin\theta+r^2cos^2{\theta}d\theta-ry_0dcos\theta+r^2sin^2{\theta}d\theta} \\ = r(x_0sin\theta-y_0cos\theta+r\theta)|_\alpha^\beta s=∮C​xdy−ydx=∮C​(x0​+rcosθ)d(y0​+rsinθ)−(y0​+rsinθ)d(x0​+rcosθ)=∮C​rx0​dsinθ+r2cos2θdθ−ry0​dcosθ+r2sin2θdθ=r(x0​sinθ−y0​cosθ+rθ)∣αβ​

z x = ∮ C 1 2 x 2 d y = 1 2 ∮ C ( x 0 2 + 2 r x 0 c o s θ + r 2 c o s 2 θ ) d ( y 0 + r s i n θ ) = r 2 ∮ C x 0 2 d s i n θ + 2 r x 0 c o s 2 θ d θ + r 2 c o s 3 θ d θ = r 2 ( ( x 0 2 + r 2 ) s i n θ + r x 0 θ + r x 0 s i n 2 θ 2 − r 2 s i n 3 θ 3 ) ∣ α β z_x = \oint_C{\frac{1}{2}x^2}dy = \frac{1}{2}\oint_C{(x_0^2+2rx_0cos\theta+r^2cos^2\theta)d(y_0 + rsin\theta)} \\ = \frac{r}{2}\oint_C{x_0^2dsin\theta+2rx_0cos^2{\theta}d\theta+r^2cos^3{\theta}d\theta} \\ =\frac{r}{2}\big((x_0^2+r^2)sin\theta+rx_0\theta+\frac{rx_0sin2{\theta}}{2}-\frac{r^2sin^3\theta}{3}\big)|_\alpha^\beta zx​=∮C​21​x2dy=21​∮C​(x02​+2rx0​cosθ+r2cos2θ)d(y0​+rsinθ)=2r​∮C​x02​dsinθ+2rx0​cos2θdθ+r2cos3θdθ=2r​((x02​+r2)sinθ+rx0​θ+2rx0​sin2θ​−3r2sin3θ​)∣αβ​

z y = − 1 2 ∮ C y 2 d x = − 1 2 ∮ C ( y 0 2 + 2 r y 0 s i n θ + r 2 s i n 2 θ ) d ( r c o s θ ) = − r 2 ∮ C y 0 2 d c o s θ + r y 0 2 d s i n 2 θ − r y 0 d θ + r 2 d c o s θ − r 2 3 d c o s 3 θ = r 2 ( r 2 c o s 3 θ 3 + r y 0 θ − ( r 2 + y 0 2 ) c o s θ − r y 0 s i n 2 θ 2 ) ∣ α β z_y=-{\frac{1}{2}}\oint_C{y^2dx}=-{\frac{1}{2}}\oint_C{(y_0^2+2ry_0sin\theta+r^2sin^2\theta)d(rcos\theta)} \\ = -{\frac{r}{2}}\oint_C{y_0^2dcos\theta+\frac{ry_0}{2}dsin2\theta-ry_0d\theta+r^2dcos\theta-\frac{r^2}{3}dcos^3\theta} \\ =\frac{r}{2}\big(\frac{r^2cos^3\theta}{3}+ry_0\theta-(r^2+y_0^2)cos\theta-\frac{ry_0sin2\theta}{2}\big)|_\alpha^\beta zy​=−21​∮C​y2dx=−21​∮C​(y02​+2ry0​sinθ+r2sin2θ)d(rcosθ)=−2r​∮C​y02​dcosθ+2ry0​​dsin2θ−ry0​dθ+r2dcosθ−3r2​dcos3θ=2r​(3r2cos3θ​+ry0​θ−(r2+y02​)cosθ−2ry0​sin2θ​)∣αβ​

所以只需求出圆并的每一段边界圆弧，计算即可。

SPOJ CIRU圆并的面积

最多有1000个圆，求并的面积。被覆盖的圆要剔除，不能参与运算。退化的圆也可以剃掉。简单而言就是对每一个圆，求其他圆覆盖该圆的圆弧角度区间 [ α , β ] [\alpha, \beta] [α,β]，最多有 N − 1 N-1 N−1段区间，然后对这些区间排序，对不在这些区间范围内的区间引用上述公式进行计算即可。时间复杂度为 O ( N 2 l o g N ) O(N^2logN) O(N2logN)。

#include <bits/stdc++.h>
using namespace std;

char *__abc147, *__xyz258, __ma369[100000];
#define __hv007() ((__abc147==__xyz258) && (__xyz258=(__abc147=__ma369)+fread(__ma369,1,100000,stdin),__abc147==__xyz258) ? EOF : *__abc147++)

int getInt(){
	int sgn = 1;
	char ch = __hv007();
	while( ch != '-' && ( ch < '0' || ch > '9' ) ) ch = __hv007();
	if ( '-' == ch ) {sgn = 0;ch=__hv007();}

	int ret = (int)(ch-'0');
	while( '0' <= (ch=__hv007()) && ch <= '9' ) ret = ret * 10 + (int)(ch-'0');
	return sgn ? ret : -ret;
}

#ifndef ONLINE_JUDGE
int const SIZE = 7;
#else
int const SIZE = 2010;
#endif

using Real = double;
using vi = vector<int>;
using vvi = vector<vi>;
using pii = pair<Real, Real>;
using vpii = vector<pii>;

Real const EPS = 1E-8;
Real const PI = acos(-1.0);
inline int sgn(Real x){return x>EPS?1:(x<-EPS?-1:0);}
inline bool is0(Real x){return 0 == sgn(x);} 
inline Real myacos(Real x){
    if(x > 1) x = 1.0;
    if(x < -1) x = -1.0;
    return acos(x);
}

struct Point{
    Real x, y;
    Real dist(const Point &b)const{
        Real u = x - b.x, v = y - b.y;
        return sqrt(u*u+v*v);
    }
};

struct Circle{
    Point center;
    Real radius;
    /// 两个圆相交，返回圆弧角度的区间,可能是一段，也可能是两段
    /// 角度范围为[-Pi, Pi)
    vpii inter(const Circle &b)const{
        Real d123 = center.dist(b.center);
        Real u111 = fabs(radius - b.radius);
        Real u222 = radius + b.radius;
        assert(sgn(u222-d123) > 0 && sgn(d123 - u111) > 0);

        Real cosvalue = (radius * radius + d123 * d123 - b.radius * b.radius) / (2.0 * radius * d123);
        Real jiao = myacos(cosvalue);
        Real anchor = atan2(b.center.y - center.y, b.center.x - center.x);
        Real from = anchor - jiao, to = anchor + jiao;

        vpii ans;
        if(sgn(to - PI) >= 0){ // 分两段
            ans.emplace_back(-PI, to-PI-PI);
            ans.emplace_back(from, PI);
            return ans;
        }
        if(sgn(from+PI) < 0){ // 分两段
            ans.emplace_back(-PI, to);
            ans.emplace_back(from+PI+PI, PI);
            return ans;
        }
        ans.emplace_back(from, to);
        return ans;
    }
};

Real cross(const Point &O, const Point &A, const Point &B){
    Real xoa = A.x - O.x, yoa = A.y - O.y;
    Real xob = B.x - O.x, yob = B.y - O.y;
    return xoa * yob - xob * yoa;
}

/// 原函数求差值
inline Real diff(Real (*f)(const Circle&, Real), const Circle&c, Real alpha, Real beta){
    return  f(c, beta) - f(c, alpha); 
}

/// 求面积的函数，缺一个0.5的因子
Real f(const Circle &c, Real theta){
    return c.radius * (c.radius * theta + c.center.x * sin(theta) - c.center.y * cos(theta));
}

/// 求圆并，索引从0开始
Real unite_circles(const Circle c[], int n){
    /// 首先求各圆相交的情况
    vvi status(n, vi());
    vi han(n, 0);
    for(int i=0;i<n;++i){
        if(han[i]) continue; // i被包含
        auto ci = c + i;
        if(is0(ci->radius)){
            han[i] = 1; continue;
        }

        for(int j=i+1;j<n;++j){
            auto cj = c + j;
            if(is0(cj->radius)){
                han[j] = 1; continue;
            }
            Real u = ci->center.dist(cj->center);
            Real v1 = fabs(ci->radius - cj->radius);
            Real v2 = ci->radius + cj->radius;
            if(sgn(v1-u) >= 0){ // 包含
                if(sgn(ci->radius - cj->radius) >= 0){
                    han[j] = 1; // j被包含
                }else{
                    han[i] = 1; // i被j包含，i就不用再算了
                    break;
                }
            }else if(sgn(v2-u) > 0){ // 相交
                status[i].push_back(j);
                status[j].push_back(i);
            }
        }        
    }
    /// 处理每个圆
    Real ans = 0;
    vpii vec;
    for(int i=0;i<n;++i){
        if(han[i]) continue; // 说明是被包含的
        const Circle * ci = c + i;
        const vi & st = status[i];
        if(st.empty()){ // 说明整个圆都是边界
            ans += diff(f, *ci, -PI, PI);
            continue;
        }
        vec.clear(); 
        vec.reserve(st.size());
        /// 对每个相交的圆求相交区间
        for(int j: st){
            auto tmp = ci->inter(c[j]);
            vec.insert(vec.end(), tmp.begin(), tmp.end());
        }
        /// 相交区间排序
        sort(vec.begin(), vec.end());
        /// 对每一段露在外面的圆弧做积分
        Real left = -PI;
        for(const auto &p: vec){
            if(left < p.first){ // 说明有一段边缘
                ans += diff(f, *ci, left, p.first);  
                left = p.second;
            }else if(left < p.second){ // 更新边界的起点
                left = p.second;
            }
        }
        /// 最后再加上一段，无论有没有
        ans += diff(f, *ci, left, PI);
    }
    return 0.5 * ans; // 最后乘0.5
}

int N;
Circle C[SIZE];

Real proc(){
    Real ans = unite_circles(C, N);
    return ans;
}

int main(){
#ifndef ONLINE_JUDGE
    freopen("1.txt", "r", stdin);
#endif
    N = getInt();
    for(int i=0;i<N;++i) C[i].center.x = getInt(), C[i].center.y = getInt(), C[i].radius = getInt();
    printf("%.3f\n", proc());
    return 0;
}

圆并的重心

Battle Mage，题目大意是：给定一个凸多边形形状的薄木板，上面有很多圆洞，圆洞可能会重叠。薄木板初始位于竖直平面内，给定每个点的坐标，给定圆洞的圆心和半径。现在将薄木板的第V个点固定住，然后让其在重力作用下达到平衡位置，问此时凸多边形的N个顶点的坐标。只需求出重心坐标，再做一个坐标变换即可。首先可以求出完整凸多边形的重心，再可以求出圆并的重心，最后可以求出薄木板的重心坐标。

#include <bits/stdc++.h>
using namespace std;

char *__abc147, *__xyz258, __ma369[100000];
#define __hv007() ((__abc147==__xyz258) && (__xyz258=(__abc147=__ma369)+fread(__ma369,1,100000,stdin),__abc147==__xyz258) ? EOF : *__abc147++)

int getInt(){
	int sgn = 1;
	char ch = __hv007();
	while( ch != '-' && ( ch < '0' || ch > '9' ) ) ch = __hv007();
	if ( '-' == ch ) {sgn = 0;ch=__hv007();}

	int ret = (int)(ch-'0');
	while( '0' <= (ch=__hv007()) && ch <= '9' ) ret = ret * 10 + (int)(ch-'0');
	return sgn ? ret : -ret;
}

#ifndef ONLINE_JUDGE
int const SIZE = 7;
#else
int const SIZE = 2010;
#endif

using Real = double;
using vi = vector<int>;
using vvi = vector<vi>;
using pii = pair<Real, Real>;
using vpii = vector<pii>;

Real const EPS = 1E-8;
Real const PI = acos(-1.0);
inline int sgn(Real x){return x>EPS?1:(x<-EPS?-1:0);}
inline bool is0(Real x){return 0 == sgn(x);} 
inline Real sqr(Real x){return x * x;}
inline Real cub(Real x){return x * x * x;}
inline Real myacos(Real x){
    if(x > 1) x = 1.0;
    if(x < -1) x = -1.0;
    return acos(x);
}

struct Point{
    Real x, y;
    Real dist(const Point &b)const{
        Real u = x - b.x, v = y - b.y;
        return sqrt(u*u+v*v);
    }
};

struct Circle{
    Point center;
    Real radius;
    /// 两个圆相交，返回圆弧角度的区间,可能是一段，也可能是两段
    /// 角度范围为[-Pi, Pi)
    vpii inter(const Circle &b)const{
        Real d123 = center.dist(b.center);
        Real u111 = fabs(radius - b.radius);
        Real u222 = radius + b.radius;
        assert(sgn(u222-d123) > 0 && sgn(d123 - u111) > 0);

        Real cosvalue = (radius * radius + d123 * d123 - b.radius * b.radius) / (2.0 * radius * d123);
        Real jiao = myacos(cosvalue);
        Real anchor = atan2(b.center.y - center.y, b.center.x - center.x);
        Real from = anchor - jiao, to = anchor + jiao;

        vpii ans;
        if(sgn(to - PI) >= 0){ // 分两段
            ans.emplace_back(-PI, to-PI-PI);
            ans.emplace_back(from, PI);
            return ans;
        }
        if(sgn(from+PI) < 0){ // 分两段
            ans.emplace_back(-PI, to);
            ans.emplace_back(from+PI+PI, PI);
            return ans;
        }
        ans.emplace_back(from, to);
        return ans;
    }
};

Real cross(const Point &O, const Point &A, const Point &B){
    Real xoa = A.x - O.x, yoa = A.y - O.y;
    Real xob = B.x - O.x, yob = B.y - O.y;
    return xoa * yob - xob * yoa;
}

/// 原函数求差值
inline Real diff(Real (*f)(const Circle&, Real), const Circle&c, Real alpha, Real beta){
    return  f(c, beta) - f(c, alpha); 
}

/// 求面积的函数，缺一个0.5的因子
Real f(const Circle &c, Real theta){
    return c.radius * (c.radius * theta + c.center.x * sin(theta) - c.center.y * cos(theta));
}

/// 求重心的x坐标的原函数，缺一个0.5的因子
Real fx(const Circle &c, Real theta){
    Real sint = sin(theta);
    Real r2 = sqr(c.radius);
    return c.radius * ((sqr(c.center.x)+r2)*sint + c.radius*c.center.x*(theta+0.5*sin(theta+theta)) - r2*cub(sint)/3.0);
}

/// 求重心的y坐标的原函数，缺一个0.5的因子
Real fy(const Circle &c, Real theta){
    Real cost = cos(theta);
    Real r2 = sqr(c.radius);
    return c.radius * (r2*cub(cost)/3.0 + c.radius*c.center.y*(theta-0.5*sin(theta+theta)) - (r2+sqr(c.center.y))*cost);
}

/// 求圆并，索引从0开始
tuple<Real, Real, Real> unite_circles(const Circle c[], int n){
    /// 首先求各圆相交的情况
    vvi status(n, vi());
    vi han(n, 0);
    for(int i=0;i<n;++i){
        if(han[i]) continue; // i被包含
        auto ci = c + i;
        if(is0(ci->radius)){
            han[i] = 1; continue;
        }

        for(int j=i+1;j<n;++j){
            auto cj = c + j;
            if(is0(cj->radius)){
                han[j] = 1; continue;
            }
            Real u = ci->center.dist(cj->center);
            Real v1 = fabs(ci->radius - cj->radius);
            Real v2 = ci->radius + cj->radius;
            if(sgn(v1-u) >= 0){ // 包含
                if(sgn(ci->radius - cj->radius) >= 0){
                    han[j] = 1; // j被包含
                }else{
                    han[i] = 1; // i被j包含，i就不用再算了
                    break;
                }
            }else if(sgn(v2-u) > 0){ // 相交
                status[i].push_back(j);
                status[j].push_back(i);
            }
        }        
    }
    /// 处理每个圆
    Real ans = 0, ansx = 0, ansy = 0;
    vpii vec;
    for(int i=0;i<n;++i){
        if(han[i]) continue; // 说明是被包含的
        const Circle * ci = c + i;
        const vi & st = status[i];
        if(st.empty()){ // 说明整个圆都是边界
            ans += diff(f, *ci, -PI, PI);
            ansx += diff(fx, *ci, -PI, PI);
            ansy += diff(fy, *ci, -PI, PI);
            continue;
        }
        vec.clear(); 
        vec.reserve(st.size());
        /// 对每个相交的圆求相交区间
        for(int j: st){
            auto tmp = ci->inter(c[j]);
            vec.insert(vec.end(), tmp.begin(), tmp.end());
        }
        /// 相交区间排序
        sort(vec.begin(), vec.end());
        /// 对每一段露在外面的圆弧做积分
        Real left = -PI;
        for(const auto &p: vec){
            if(left < p.first){ // 说明有一段边缘
                ans += diff(f, *ci, left, p.first);  
                ansx += diff(fx, *ci, left, p.first);
                ansy += diff(fy, *ci, left, p.first);
                left = p.second;
            }else if(left < p.second){ // 更新边界的起点
                left = p.second;
            }
        }
        /// 最后再加上一段，无论有没有
        ans += diff(f, *ci, left, PI);
        ansx += diff(fx, *ci, left, PI);
        ansy += diff(fy, *ci, left, PI);
    }
    return {ans, ansx, ansy}; // 都不用0.5，会抵消
}

int N, C, V;
Circle Cir[SIZE];
Point P[SIZE];

void proc(){
    /// 求圆并的重心
    auto ans = unite_circles(Cir, C);
    /// 求多边形的重心和面积
    Real cgx = 0, cgy = 0, area = 0;
    for(int i=2;i<N;++i){
        Real tmp = cross(P[0], P[i-1], P[i]);
        area += tmp;
        cgx += tmp * (P[0].x+P[i-1].x+P[i].x)/3.0;
        cgy += tmp * (P[0].y+P[i-1].y+P[i].y)/3.0;
    }
    /// 求薄木板的重心
    Real leftarea = area - get<0>(ans);
    Real leftx = (cgx - get<1>(ans)) / leftarea;
    Real lefty = (cgy - get<2>(ans)) / leftarea;
    /// 凸多边形做一个坐标平移
    Point origin = P[V];
    for(int i=0;i<N;++i) P[i].x -= origin.x, P[i].y -= origin.y;
    leftx -= origin.x, lefty -= origin.y;
    /// 旋转
    Real theta = atan2(lefty, leftx);
    theta = -0.5 * PI - theta;
    Real ca = cos(theta), sa = sin(theta);
    for(int i=0;i<N;++i){
        Real x = P[i].x, y = P[i].y;
		P[i].x = x * ca - y * sa + origin.x;
		P[i].y = y * ca + x * sa + origin.y; 
    }
}

int main(){
#ifndef ONLINE_JUDGE
    freopen("1.txt", "r", stdin);
#endif
    N = getInt(); C = getInt(); V = getInt() - 1;
    for(int i=0;i<N;++i) P[i].x = getInt(), P[i].y = getInt();
    for(int i=0;i<C;++i) Cir[i].center.x = getInt(), Cir[i].center.y = getInt(), Cir[i].radius = getInt();
    proc();
    for(int i=0;i<N;++i) printf("%.7f %.7f\n", P[i].x, P[i].y);
    return 0;
}
罗博士
关注
  • 5
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
格林公式计算多边形的面积
qq_27151549的博客
04-25 1万+
算法导论第31章第一节第8题。只要是边不相交的简单多边形，也就是说，不仅凸多边形，还有各种奇形怪状的凹多边形，都可以用格林公式求出面积。格林公式：若函数P(x,y), Q(x,y)在由一条或几条光滑曲线所围成的闭区域D上连续，且有连续的一阶偏导数，则有L为区域D的边界曲线，并取正方向。边不相交的简单多边形正好是由数条线段围成的闭区域，所以可以使用格林公式。令P=0, Q=x,则面积S = 设第i个...
BZOJ2178: 圆的面积并（格林公式）
weixin_34124939的博客
04-22 741
题面 传送门 题解 好神仙…… 先给几个定义 平面单连通区域：设\(D\)是平面内一区域，若属于\(D\)内任一简单闭曲线的内部都属于\(D\)，则称\(D\)为单连通区域。通俗地说，单连通区域是没有“洞”的区域。 正方向：当\(xOy\)平面上的曲线起点与终点重合时，则称曲线为闭曲线。设平面的闭曲线L围成平面区域\(D\)，并规定当一个人沿闭曲线\(L\)环行时，区域\(D\)总是位于此人的左侧...
UOJ#419. 【集训队作业2018】圆形（格林公式）
weixin_34245169的博客
04-22 219
题面 传送门 题解 首先您得会用格林公式计算圆的面积并 这里只需要动态维护一下圆弧就可以了 时间复杂度\(O(n^2\log n)\) //minamoto #include<bits/stdc++.h> #define R register #define inline __inline__ __attribute__((always_inline)) #define fp(i,a,...
用格林定理求Jordan曲线包围的封闭区域的面积
stereohomology
06-30 8725
背景发现很多教材讲微积分中的格林定理忽略其引申，显得粗糙。看了不同版本教材比对之后，这种感受更深了。Green′stheorem\rm Green's\; theorem 联系着二重积分和第二类平面曲线积分,是个漂亮的结果.对原始定理稍作引申，不仅加深理解，在计算几何的某些算法实现中灵活应用起来也很方便。不但格林定理，散度定理也有类似的应用，让人惊讶。定理和引申定理 (Green's theorem
多边形面积和重心计算
u012486727的专栏
04-18 838
任意多边形A1，A2，A3....An;
格林公式与GPS面积测量仪.pdf
09-08
格林公式与GPS面积测量仪.pdf
高等数学曲线面积及格林公式习题PPT课件.pptx
10-25
"高等数学曲线面积及格林公式习题PPT课件" 本资源摘要信息是关于高等数学曲线面积及格林公式的习题PPT课件，旨在帮助学生学习和掌握高等数学中曲线面积及格林公式的计算方法和技巧。本资源摘要信息涵盖了曲线积分的...
格林公式证明
01-25
很有用的一个公式证明，详细证明了数学中一个极为重要的定理
格林公式(1).
05-31
对于大家，高等数学2的格林公式的学习应该会有一定的帮助
曲线积分及格林公式总结.doc
09-27
曲线积分及格林公式总结 一、 曲线积分的概念与性质 曲线积分是研究曲线形构件的质量和性质的重要概念。设 L 为 xOy 面内的一条光滑曲线弧，函数 f(x,y) 在 L 上有界。在 L 上任意插入一点列 M1, M2, …, Mn，把 L...
格林公式推导
最新发布
要把所有那些负面的信息当做对自身行为的评价，而不是对自身价值的评判。
09-17 567
从等式左右两边的计算结果可以看出，等式两边相等。
高等数学学习笔记——第八十五讲——格林公式
预见未来to50的专栏
05-19 3358
一、问题的引入——如何测量梯田与湖泊的面积？ 二、简单区域的格林公式 1. 简单区域：既是X型区域也是Y型区域 2. 简单区域上的格林公式 3. 格林公式的条件 4. 计算示例 三、一般区域的格林公式 1. 单连通区域与多连通区域 2. 单连通区域上的格林公式 3. 计算示例 四、区域面积的计算——GPS面积测量仪的数学原理 ...
模糊推理控制系统——python
weixin_45902276的博客
05-06 1万+
模糊推理系统———python原理及说明设计洗衣洗涤时间模糊控制题目分析做题步骤及相应代码面积重心法解模糊总结 原理及说明 模糊推理所处理的事物自身是模糊的，概念本身没有明确的外延，一个对象是否符合这个概念难以明确地确定模糊推理是对这种不确定性，即模糊性的表示与处理。模糊逻辑推理是基于模糊性知识(模糊规则)的一种近似推理，一般采用Zadeh提出的语言变量、语言值、模糊集和模糊关系合成的方法进行推理。 设计洗衣洗涤时间模糊控制 已知人的操作经验为： “污泥越多，油脂越多，洗涤时间越长”； “污泥适中，油脂适中
用曲线积分（格林公式）求双纽线（r^2=a^2*cos2Θ）的面积
weixin_61333208的博客
05-10 1万+
用曲线积分（格林公式推导的求的公式面积）求双纽线（r^2=a^2*cos2Θ）的面积
SPOJ CIRU SPOJ VCIRCLE 圆的面积并问题
zjy2015302395的博客
06-09 1057
给出若干圆 求面积并 找到所有边界，然后格林公式，就是里面的面积。tip:正方向为逆时针,对于所给的N个圆，我们可以进行去冗杂，表现为: (1) 去掉被包含(内含 or 内切)的小圆 () (2) 去掉相同的圆枚举每个圆，并对于剩下的所有圆和它求交点，对于所求的的交点，可以得到一个角度区间 [A,B], 当然区间如果跨越了(例如 [1.5PI, 0.5PI],注意这里是有方向的) 2PI那么需
格林公式、高斯公式及斯托克斯公式的理解及相互关系
热门推荐
yu132563的专栏
11-28 16万+
最近要推倒波动方程积分解，要对散度、旋度以及他们之间的相互关系有一个理解。看了两天，自己认为理解的差不多了，现在写在这个地方，作为笔记，以后忘记了拿过来看一下，加深一下印象。 前面已经在从知乎几个大神那里转载了一些比较通俗易懂的三个公式的推导，现在着重讲一下本人所理解的几个公式之间的相互关系及物理意义。 格林公式其实表达的是能量守恒的关系，比较详细的解释可以参照知乎的这篇文章（https...
求任意多边形面积与重心的算法
wonder13579的博客
07-15 8471
题目地址http://acm.nyist.edu.cn/JudgeOnline/problem.php?pid=3多边形重心问题时间限制：3000 ms  |  内存限制：65535 KB难度：5描述在某个多边形上，取n个点，这n个点顺序给出，按照给出顺序将相邻的点用直线连接， （第一个和最后一个连接），所有线段不和其他线段相交，但是可以重合，可得到一个多边形或一条线段或一个多边形和一个线段的...
灰度重心法公式大全
分享的滋味
08-15 1万+
1．型心法        可理解为灰度重心法的特例，用于二值图像。   2．灰度重心法 version 1   3.灰度重心法 version 2
实心多边形重心的计算公式及推导
zdi1997的博客
05-27 2777
先上结果： 假设是某个多边形的顶点且逆时针排列，则 推导过程： 对于平面上一般区域，其重心计算公式为 利用散度定理： 先计算： 注意恰好是顺时针旋转90度得到的向量，于是他的横坐标为，于是有 对i进行求和并注意到，于是有 在和式中第一项指标减一，得到和式的值为 于是是的横坐标为 ， 同理可得到纵坐标为 剩下的就是计算面积了...
利用格林公式计算半径为a的圆盘面积
06-10
根据格林公式，对于一个平面区域D，其边界曲线为C，且在该区域内的偏导数存在且连续，那么该区域的面积可以表示为： $$ \iint_D \frac{\partial Q}{\partial x}-\frac{\partial P}{\partial y} dxdy=\oint_C Pdx+Qdy $$ 其中P和Q是平面区域D内的连续可导函数，且$\frac{\partial Q}{\partial x}$和$\frac{\partial P}{\partial y}$在D内存在且连续。 对于半径为a的圆盘D，其边界曲线为圆周C，可以用极坐标表示为$r=a$，$0\leq\theta\leq 2\pi$。取P=0，Q=x，那么： $$ \frac{\partial Q}{\partial x}=1,\frac{\partial P}{\partial y}=0 $$ 因此，根据格林公式，圆盘面积可以表示为： $$ \begin{aligned} \iint_D \frac{\partial Q}{\partial x}-\frac{\partial P}{\partial y} dxdy&=\oint_C Pdx+Qdy\\ &=\int_0^{2\pi}adx\\ &=2\pi a^2 \end{aligned} $$ 因此，半径为a的圆盘面积为2πa²。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值