ZOJ 3720 Magnet Darts (计算几何，概率，判点是否在多边形内)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3720

题意：

在一个矩形区域投掷飞镖，因此飞镖只会落在整点上，投到每个点的得分是Ax+By。矩形区域里面有个多边形，如果飞镖投在多边形里面则得分，求最终的得分期望。

即：给定一个矩形内的所有整数点，判断这些点是否在一个多边形内

方法：

计算几何的判点是否在多边形内（几何模板），如果在，则令得分加(Ax+By)*以此点为中心边长为1的正方形面积

void solve()
{
    double ans = 0;
    for (int i = p.x; i <= q.x; i++)
    {
        for (int j = p.y; j <= q.y; j++)
        {
            if (PointInPolygon(Point2D(i, j), poly.v, poly.n))
                ans += (a * i + b * j) * (min(i + 0.5, q.x) - max(i - 0.5, p.x)) * (min(j + 0.5, q.y) - max(j - 0.5, p.y));
        }
    }
    printf("%.3f
", ans / (q.x - p.x) / (q.y - p.y));
}

代码：

// #pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <iostream>
#include <cstring>
#include <string>
#include <cmath>
#include <set>
#include <list>
#include <map>
#include <iterator>
#include <cstdlib>
#include <vector>
#include <queue>
#include <stack>
#include <algorithm>
#include <functional>
using namespace std;
typedef long long LL;
#define ROUND(x) round(x)
#define FLOOR(x) floor(x)
#define CEIL(x) ceil(x)
const int maxn = 0;
const int maxm = 0;
const int inf = 0x3f3f3f3f;
const LL inf64 = 0x3f3f3f3f3f3f3f3fLL;
// const double INF = 1e30;
// const double eps = 1e-6;
const int P[4] = {0, 0, -1, 1};
const int Q[4] = {1, -1, 0, 0};
const int PP[8] = { -1, -1, -1, 0, 0, 1, 1, 1};
const int QQ[8] = { -1, 0, 1, -1, 1, -1, 0, 1};

typedef double db;
const double eps = 1e-7;
const double PI = acos(-1.0);
const double INF = 1e50;

const int POLYGON_MAX_POINT = 1024;

db dmin(db a, db b)
{
    return a > b ? b : a;
}
db dmax(db a, db b)
{
    return a > b ? a : b;
}
int sgn(db a)
{
    return a < -eps ? -1 : a > eps;    //返回double型的符号
}

struct Point2D
{
    db x, y;
    int id;
    Point2D(db _x = 0, db _y = 0): x(_x), y(_y) {}
    void input()
    {
        scanf("%lf%lf" , &x, &y);
    }
    void output()
    {
        printf("%.2f %.2f
" , x, y);
    }
    //
    db len2()
    {
        return x * x + y * y;
    }
    //到原点距离
    double len()
    {
        return sqrt(len2());
    }
    //逆时针转90度
    Point2D rotLeft90()
    {
        return Point2D(-y, x);
    }
    //顺时针转90度
    Point2D rotRight90()
    {
        return Point2D(y, -x);
    }
    //绕原点逆时针旋转arc_u
    Point2D rot(double arc_u)
    {
        return Point2D( x * cos(arc_u) - y * sin(arc_u),
                        x * sin(arc_u) + y * cos(arc_u) );
    }
    //绕某点逆时针旋转arc_u
    Point2D rotByPoint(Point2D &center, db arc_u)
    {
        Point2D tmp( x - center.x, y - center.y );
        Point2D ans = tmp.rot(arc_u);
        ans = ans + center;
        return ans;
    }

    bool operator == (const Point2D &t) const
    {
        return sgn(x - t.x) == 0 && sgn(y - t.y) == 0;
    }
    bool operator < (const Point2D &t) const
    {
        if ( sgn(x - t.x) == 0 ) return y < t.y;
        else return x < t.x;
    }
    Point2D operator + (const Point2D &t) const
    {
        return Point2D(x + t.x, y + t.y);
    }

    Point2D operator - (const Point2D &t) const
    {
        return Point2D(x - t.x, y - t.y);
    }

    Point2D operator * (const db &t)const
    {
        return Point2D( t * x, t * y );
    }

    Point2D operator / (const db &t) const
    {
        return Point2D( x / t, y / t );
    }
    //点乘
    db operator ^ (const Point2D &t) const
    {
        return x * t.x + y * t.y;
    }
    //叉乘
    db operator * (const Point2D &t) const
    {
        return x * t.y - y * t.x;
    }
    //两点之间的角度(-PI , PI]
    double rotArc(Point2D &t)
    {
        double perp_product = rotLeft90()^t;
        double dot_product = (*this)^t;
        if ( sgn(perp_product) == 0 && sgn(dot_product) == -1) return PI;
        return sgn(perp_product) * acos( dot_product / len() / t.len() );
    }
    //标准化
    Point2D normalize()
    {
        return Point2D(x / len(), y / len());
    }
};

struct POLYGON
{
    Point2D v[POLYGON_MAX_POINT];
    int n;
};
struct Segment2D
{
    Point2D s , e;
    Segment2D() {}
    Segment2D( Point2D _s, Point2D _e ): s(_s), e(_e) {}
};
//0: 点在多边形外
//1: 点在多边形内
bool PonSegment2D(Point2D p, Segment2D seg)
{
    return sgn((seg.s - p) * (p - seg.e)) == 0 && sgn((seg.s - p) ^ (p - seg.e)) >= 0;
}

/**** 判断线段在内部相交***/
bool SegIntersect2D(Segment2D a, Segment2D b)
{
    //必须在线段内相交
    int d1 = sgn((a.e - a.s) * (b.s - a.s));
    int d2 = sgn((a.e - a.s) * (b.e - a.s));
    int d3 = sgn((b.e - b.s) * (a.s - b.s));
    int d4 = sgn((b.e - b.s) * (a.e - b.s));
    if (d1 * d2 < 0 && d3 * d4 < 0) return true;
    return false;
}

int PointInPolygon(Point2D p, Point2D poly[], int n)
{
    Segment2D l, seg;
    l.s = p;
    l.e = p;
    l.e.x = INF;//作射线
    int i, cnt = 0;
    Point2D p1, p2, p3, p4;
    for (i = 0; i < n; i++)
    {
        seg.s = poly[i], seg.e = poly[(i + 1) % n];
        if (PonSegment2D(p, seg)) return 2; //点在多边形上
        p1 = seg.s, p2 = seg.e , p3 = poly[(i + 2) % n], p4 = poly[(i + 3) % n];
        if (SegIntersect2D(l, seg) ||
                PonSegment2D(p2, l) && sgn((p2 - p1) * (p - p1))*sgn((p3 - p2) * (p - p2)) > 0 ||
                PonSegment2D(p2, l) && PonSegment2D(p3, l) &&
                sgn((p2 - p1) * (p - p1))*sgn((p4 - p3) * (p - p3)) > 0 )
            cnt++;
    }
    if (cnt % 2 == 1) return 1; //点在多边形内
    return 0;//点在多边形外
}

POLYGON poly;
Point2D p, q;
db a, b;
void init()
{
    //
}
void input()
{
    scanf("%d%lf%lf", &poly.n, &a, &b);
    for (int i = 0; i < poly.n; i++)
    {
        scanf("%lf%lf", &poly.v[i].x, &poly.v[i].y);
    }
}
void debug()
{
    //
}
void solve()
{
    double ans = 0;
    for (int i = p.x; i <= q.x; i++)
    {
        for (int j = p.y; j <= q.y; j++)
        {
            if (PointInPolygon(Point2D(i, j), poly.v, poly.n))
                ans += (a * i + b * j) * (min(i + 0.5, q.x) - max(i - 0.5, p.x)) * (min(j + 0.5, q.y) - max(j - 0.5, p.y));
        }
    }
    printf("%.3f
", ans / (q.x - p.x) / (q.y - p.y));
}
void output()
{
    //
}
int main()
{
    // std::ios_base::sync_with_stdio(false);
    // #ifndef ONLINE_JUDGE
    //     freopen("in.cpp", "r", stdin);
    // #endif

    while (~scanf("%lf%lf%lf%lf", &p.x, &p.y, &q.x, &q.y))
    {
        init();
        input();
        solve();
        output();
    }
    return 0;
}