99久久婷婷国产综合精品草原,久久久久人妻一区精品,97久久久久人妻精品专区

poj 2187 Beauty Contest

yx — Mon, 23 Jul 2012 14:18:00 GMT

�q�个题我是按照discussion里面的说法，先求凸包�Q�然后枚举过的。因为开始先把求凸包��法里面的用��C��(ji��n)数组名搞混了(ji��n)�Q�无故wa�?ji��n)�?br />多次。后面求凸包换了(ji��n)�U�算法过�?ji��n)。结果发现bug是搞混了(ji��n)数组名，然后把前面wa掉的代码下蝲下来�Q�改好之后也都过�?ji��n)�?br /> �q�个题�(sh��)��要是凸包��法需要处理有重复点，有多点共�U�之�cȝ��情况。那个按极角排序后，再求凸包的算法，对共点共�U�处理的不是很好�Q?br />不过那个��法也过�?ji��n)这个题。有个直接按坐标排序后，再求上凸包和下凸包的��法�Q�可以处理共点共�U�的情况。这个算法比较优��啊�Q�既�?br />需要找y坐标最��的点，也不需要按极角排序�Q�直接按坐标排序下，然后求凸包即可�?br /> �q�个��法的一点解释：(x��)http://www.algorithmist.com/index.php/Monotone_Chain_Convex_Hull
另外�Q�演��法�W�记�Q?a >http://www.csie.ntnu.edu.tw/~u91029/ConvexHull.html#a3上也有提到这个算法，我也是从�q�上面看到的�?br />�q�个��法可以假设是Graham排序基准点在无限�q�处�Q�于是夹角大��的比较可以直接按水�q�_��标比较�?br />
代码如下�Q?br />

#include
#include
#include
using namespace std;
struct Point
{
    int x, y;
    bool operator<(const Point& p) const
    {
        return x < p.x || x == p.x && y < p.y;
    }
};
Point pts[50100];
Point pcs[50100];
int nN;
int nM;
inline int SDis(const Point& a, const Point& b)
{
    return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
}

double Det(double fX1, double fY1, double fX2, double fY2)
{
    return fX1 * fY2 - fX2 * fY1;
}

double Cross(Point a, Point b, Point c)
{
    return Det(b.x - a.x, b.y - a.y, c.x - a.x, c.y - a.y);
}

void Convex()
{
    sort(pts, pts + nN);

    nM = 0;
    for (int i = 0; i < nN; ++i)
    {
        while(nM >= 2 && Cross(pcs[nM - 2], pcs[nM - 1], pts[i]) <= 0)
        {
            nM--;
        }
        pcs[nM++] = pts[i];
    }
    for (int i= nN - 2, t = nM + 1; i >= 0; --i)
    {
        while (nM >= t && Cross(pcs[nM - 2], pcs[nM - 1], pts[i]) <= 0)
        {
            nM--;
        }
        pcs[nM++] = pts[i];
    }
    nM--;//��L(f��ng)��?x��)被重复包�?/span>
}

int main()
{
    while (scanf("%d", &nN) == 1)
    {
        for (int i = 0; i < nN; ++i)
        {
            scanf("%d%d", &pts[i].x, &pts[i].y);
        }
        Convex();
        int nMax = -1;
        for (int i = 0; i < nM; ++i)
        {
            for (int j = i + 1; j < nM; ++j)
            {
                nMax = max(nMax, SDis(pcs[i], pcs[j]));
            }
        }
        printf("%d\n", nMax);
    }

    return 0;
}

也可以用旋�{卡壳��法来求最�q�点对，此题的完整代码如下：(x��)

#include
#include <string.h>
#include
#include
#include
using namespace std;

struct Point
{
    int x, y;
    bool operator < (const Point& p)const
    {
        return x < p.x || x == p.x && y < p.y;
    }
};

double Det(double fX1, double fY1, double fX2, double fY2)
{
    return fX1 * fY2 - fX2 * fY1;
}

double Cross(Point a, Point b, Point c)
{
    return Det(b.x - a.x, b.y - a.y, c.x - a.x, c.y - a.y);
}

//输入炚w��?输出凸包
void Convex(vector& in, vector& out)
{
    int nN = in.size();
    int nM = 0;

    sort(in.begin(), in.end());
    out.resize(nN);

    for (int i = 0; i < nN; ++i)
    {
        while (nM >= 2 && Cross(out[nM - 2], out[nM - 1], in[i]) <= 0)
        {
            nM--;
        }
        out[nM++] = in[i];
    }

    for (int i = nN - 2, t = nM + 1; i >= 0; --i)
    {
        while (nM >= t && Cross(out[nM - 2], out[nM - 1], in[i]) <= 0)
        {
            nM--;
        }
        out[nM++] = in[i];
    }
    out.resize(nM);
    out.pop_back();//起始炚w��?/span>
}

int SDis(Point a,Point b)
{
    return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
}

int RC(vector& vp)
{
    int nP = 1;
    int nN = vp.size();
    vp.push_back(vp[0]);
    int nAns = 0;
    for (int i = 0; i < nN; ++i)
    {
        while (Cross(vp[i], vp[i + 1], vp[nP + 1]) > Cross(vp[i], vp[i + 1], vp[nP]))
        {
            nP = (nP + 1) % nN;
        }
        nAns = max(nAns, max(SDis(vp[i], vp[nP]), SDis(vp[i + 1], vp[nP + 1])));
    }
    vp.pop_back();
    return nAns;
}

int main()
{
    int nN;
    vector in, out;
    Point p;
    while (scanf("%d", &nN) == 1)
    {
        in.clear(), out.clear();
        while (nN--)
        {
            scanf("%d%d", &p.x, &p.y);
            in.push_back(p);
        }
        Convex(in, out);

        printf("%d\n", RC(out));
    }

    return 0;
}

关于旋�{卡壳的算法描�q�ͼ��|�上有很多资料，比如�Q?a href="http://www.shnenglu.com/staryjy/archive/2010/09/25/101412.html">http://www.shnenglu.com/staryjy/archive/2010/09/25/101412.html
��其关于�q�个求最�q�点对的�?span id="Code_Closed_Text_130220" style="border: 1px solid #808080; background-color: #ffffff; display: none; ">
#include
#include <string.h>
#include
#include
#include
using namespace std;

struct Point
{
    int x, y;
    bool operator < (const Point& p)const
    {
        return x < p.x || x == p.x && y < p.y;
    }
};

double Det(double fX1, double fY1, double fX2, double fY2)
{
    return fX1 * fY2 - fX2 * fY1;
}

double Cross(Point a, Point b, Point c)
{
    return Det(b.x - a.x, b.y - a.y, c.x - a.x, c.y - a.y);
}

//输入炚w��?输出凸包
void Convex(vector& in, vector& out)
{
    int nN = in.size();
    int nM = 0;

    sort(in.begin(), in.end());
    out.resize(nN);

    for (int i = 0; i < nN; ++i)
    {
        while (nM >= 2 && Cross(out[nM - 2], out[nM - 1], in[i]) <= 0)
        {
            nM--;
        }
        out[nM++] = in[i];
    }

    for (int i = nN - 2, t = nM + 1; i >= 0; --i)
    {
        while (nM >= t && Cross(out[nM - 2], out[nM - 1], in[i]) <= 0)
        {
            nM--;
        }
        out[nM++] = in[i];
    }
    out.resize(nM);
    out.pop_back();//起始炚w��?/span>
}

int SDis(Point a,Point b)
{
    return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
}

int RC(vector& vp)
{
    int nP = 1;
    int nN = vp.size();
    vp.push_back(vp[0]);
    int nAns = 0;
    for (int i = 0; i < nN; ++i)
    {
        while (Cross(vp[i], vp[i + 1], vp[nP + 1]) > Cross(vp[i], vp[i + 1], vp[nP]))
        {
            nP = (nP + 1) % nN;
        }
        nAns = max(nAns, max(SDis(vp[i], vp[nP]), SDis(vp[i + 1], vp[nP + 1])));
    }
    vp.pop_back();
    return nAns;
}

int main()
{
    int nN;
    vector in, out;
    Point p;
    while (scanf("%d", &nN) == 1)
    {
        in.clear(), out.clear();
        while (nN--)
        {
            scanf("%d%d", &p.x, &p.y);
            in.push_back(p);
        }
        Convex(in, out);

        printf("%d\n", RC(out));
    }

    return 0;
}

yx 2012-07-23 22:18 发表评论

poj 3525 Most Distant Point from the Sea

yx — Mon, 23 Jul 2012 08:45:00 GMT

�q�个题的题意是给定一个凸多边形表�C�的��岛�Q�求��岛��d��h��q�的距离。可以�{化�ؓ(f��)一个凸多边形内部最多能够放入一个多大的圆�?br />昄��可以对圆的半径进行二分，但是怎么��定圆心(j��)�?ji��n)。确定是否存在圆�?j��)，可以把原来的凸多边�Ş往内部�U�d��r�Q�圆的半径）(j��)的距��M��后，
再对新的多边形求半��^面交�Q�如果半�q�面交存在（是个点即可）(j��)�Q�那么当前大��的圆能够放入�?br /> 求半�q�面交的��法可以用上一��中的N*N复杂度的基本��法。本题还涉及(qi��ng)��C��个知识，��是如何把一条直�U�往逆时针方向或者顺旉��方向
�U�d��R的距��R��其实，可以�Ҏ(gu��)��单位圆那�U�思�\计算。因为相当于以原来直�U�上的一点�ؓ(f��)圆心(j��)�Q�以r为半径做圆，而且与原来的直线�?0的夹
角，那么后来点的坐标是（(x0 + cos(PI / 2 +θ ))�Q�（y0 + sin(PI / 2 + θ))�Q�，转化一下就�?x0 - sinθ�Q�y0 + cosθ)。那么直接可�?br />求出dx = / (vp[i].y - vp[(i + 1) % nN].y) * fR / fDis�Q�dy = (vp[(i + 1) % nN].x - vp[i].x) * fR / fDis�Q�fDis是线�D늚�长度�?br />
代码如下�Q?br />

#include
#include <string.h>
#include
#include
#include
using namespace std;

const double fPre = 1e-8;

struct Point
{
    double x,y;
    Point(){}
    Point(const Point& p){x = p.x, y = p.y;}
    Point(double fX, double fY):x(fX), y(fY){}
    Point& operator+(const Point& p)
    {
        x += p.x;
        y += p.y;
        return *this;
    }
    Point& operator+=(const Point& p)
    {
        return *this = *this + p;
    }

    Point& operator-(const Point& p)
    {
        x -= p.x;
        y -= p.y;
        return *this;
    }
    Point& operator*(double fD)
    {
        x *= fD;
        y *= fD;
        return *this;
    }
};
typedef vector Polygon;
int DblCmp(double fD)
{
    return fabs(fD) < fPre ? 0 : (fD > 0 ? 1 : -1);
}

double Cross(Point a, Point b)
{
    return a.x * b.y - a.y * b.x;
}

double Det(double fX1, double fY1, double fX2, double fY2)
{
    return fX1 * fY2 - fX2 * fY1;
}

double Cross(Point a, Point b, Point c)
{
    return Det(b.x - a.x, b.y - a.y, c.x - a.x, c.y - a.y);
}

Point Intersection(Point a1, Point a2, Point b1, Point b2)
{
    Point a = a2 - a1;
    Point b = b2 - b1;
    Point s = b1 - a1;
    return a1 + a * (Cross(b, s) / Cross(b, a));
}

Polygon Cut(Polygon& pg, Point a, Point b)
{
    Polygon pgRet;
    int nN = pg.size();

    for (int i = 0; i < nN; ++i)
    {
        double fC = Cross(a, b, pg[i]);
        double fD = Cross(a, b, pg[(i + 1) % nN]);

        if (DblCmp(fC) >= 0)
        {
            pgRet.push_back(pg[i]);
        }
        if (DblCmp(fC * fD) < 0)
        {
            pgRet.push_back(Intersection(a, b, pg[i], pg[(i + 1) % nN]));
        }
    }
    //printf("pgRet number:%d\n", pgRet.size());
    return pgRet;
}

double Dis(Point a, Point b)
{
    return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
//�q�回半��^面的��点个数
int HalfPlane(Polygon& vp, double fR)
{
    Polygon pg;
    pg.push_back(Point(-1e9, -1e9));
    pg.push_back(Point(1e9, -1e9));
    pg.push_back(Point(1e9, 1e9));
    pg.push_back(Point(-1e9, 1e9));
    int nN = vp.size();
    for (int i = 0; i < nN; ++i)
    {
        double fDis = Dis(vp[i], vp[(i + 1) % nN]);
        double dx = (vp[i].y - vp[(i + 1) % nN].y) * fR / fDis;
        double dy = (vp[(i + 1) % nN].x - vp[i].x) * fR / fDis;
        Point a = vp[i], b = vp[(i + 1) % nN], c(dx, dy);
        a += c;
        b += c;
        //printf("%f %f %f %f\n", a.x, a.y, b.x, b.y);
        pg = Cut(pg, a, b);
        if (pg.size() == 0)
        {
            return 0;
        }
    }
    return pg.size();
}

int main()
{
    int nN;
    vector vp;

    while (scanf("%d", &nN), nN)
    {
        vp.clear();
        Point p;
        for (int i = 0; i < nN; ++i)
        {
            scanf("%lf%lf", &p.x, &p.y);
            vp.push_back(p);
        }
        double fMin = 0.0, fMax = 10000.0;
        while (DblCmp(fMin - fMax))
        {
            double fMid = (fMin + fMax) / 2;
            int nRet = HalfPlane(vp, fMid);
            //printf("fMid:%f, nRet:%d\n", fMid, nRet);
            if (nRet == 0)
            {
                fMax = fMid;
            }
            else
            {
                fMin = fMid;
            }
        }
        printf("%.6f\n", fMax);
    }

    return 0;
}

yx 2012-07-23 16:45 发表评论

poj 3130 How I Mathematician Wonder What You Are!

yx — Mon, 23 Jul 2012 02:41:00 GMT

半��^面交的一个题�Q�也是求多边形的核心(j��)。求�?gu��)��个好像也可以用于解决一些线性规划问题。我用的是N*N的基本算法，每加入一条直�U�，
��对原来求出的半�q�面交进行处理，产生新的核心(j��)�?br /> 代码参照台湾的一个网站演��法�W�记上的内容和代码。表�C��个网站巨不错�Q�求凸包的算法也参照�?ji��n)这个网站上的内容和代码�?br />半��^面交的地址�Q?a >http://www.csie.ntnu.edu.tw/~u91029/Half-planeIntersection.html#a4

代码思�\主要是：(x��)先读入所有的多边形顶点，攑օ�一个vector�Q�vp�Q�里面，然后对多边�Ş的每条边求一个半�q�面。刚开始的时候，用一�?br />vector�Q�Polygon�Q�保存�(sh��)��表上下左叛_��个无限远角的四个点，表示原始的半�q�面。然后，用读入的多边形的每条边去切割原来的半�q�面�?br />切割的过�E�是�Q�如果原来（Polygon�Q�中的点在当前直�U�的指定一侧，那么原来的点�q�是有效的。如果原来的点和它相�?c��)��下一个点与当�?br />直线�怺��Q�那么还需要把交点加入Polygon集合�?br /> �q�有求交点的�Ҏ(gu��)��比较奇葩�Q�类��g��黑书上面的那�U�根据面�U�等分的�Ҏ(gu��)��?br />
代码如下�Q?br />

#include
#include <string.h>
#include
#include
#include
using namespace std;

double fPre = 1e-8;
struct Point
{
    double x;
    double y;
    Point(){}
    Point(double fX, double fY)
    {
        x = fX, y = fY;
    }
};
typedef vector Polygon;
typedef pair Line;
Point operator+(const Point& a, const Point& b)
{
    Point t;
    t.x = a.x + b.x;
    t.y = a.y + b.y;
    return t;
}

Point operator-(const Point& a, const Point& b)
{
    Point t;
    t.x = a.x - b.x;
    t.y = a.y - b.y;
    return t;
}

Point operator*(Point a, double fD)
{
    Point t;
    t.x = a.x * fD;
    t.y = a.y * fD;
    return t;
}

int DblCmp(double fD)
{
    return fabs(fD) < fPre ? 0 : (fD > 0 ? 1 : -1);
}

double Det(double fX1, double fY1, double fX2, double fY2)
{
    return fX1 * fY2 - fX2 * fY1;
}
//3点叉�U?/span>
double Cross(Point a, Point b, Point c)
{
    return Det(b.x - a.x, b.y - a.y, c.x - a.x, c.y - a.y);
}
//向量叉积
double Cross(Point a, Point b)
{
    return a.x * b.y - a.y * b.x;
}

//求直�U�交点的一�U�简便方�?br />//�q��四边形面�U�的比例�{�于高的比例
Point Intersection(Point a1, Point a2, Point b1, Point b2)
{
    Point a = a2 - a1;
    Point b = b2 - b1;
    Point s = b1 - a1;

    return a1 + a * (Cross(b, s) / Cross(b, a));
}

Polygon HalfPlane(Polygon& pg, Point a, Point b)
{
    Polygon pgTmp;
    int nN = pg.size();
    for (int i = 0; i < nN; ++i)
    {
        double fC = Cross(a, b, pg[i]);
        double fD = Cross(a, b, pg[(i + 1) % nN]);
        if (DblCmp(fC) >= 0)
        {
            pgTmp.push_back(pg[i]);
        }
        if (fC * fD < 0)
        {
            pgTmp.push_back(Intersection(a, b, pg[i], pg[(i + 1) % nN]));
        }
    }
    return pgTmp;
}

int main()
{
    int nN;
    Point p;
    vector vp;
    Polygon pg;

    while (scanf("%d", &nN), nN)
    {
        vp.clear();
        for (int i = 0; i < nN; ++i)
        {
            scanf("%lf%lf", &p.x, &p.y);
            vp.push_back(p);
        }
        pg.clear();
        pg.push_back(Point(-1e9, 1e9));
        pg.push_back(Point(-1e9, -1e9));
        pg.push_back(Point(1e9, -1e9));
        pg.push_back(Point(1e9, 1e9));
        for (int i = 0; i < nN; ++i)
        {
            pg = HalfPlane(pg, vp[i], vp[(i + 1) % nN]);
            if (pg.size() == 0)
            {
                printf("0\n");
                break;
            }
        }
        if (pg.size())
        {
            printf("1\n");
        }
    }

    return 0;
}

yx 2012-07-23 10:41 发表评论

poj 1584 A Round Peg in a Ground Hole

yx — Fri, 20 Jul 2012 13:41:00 GMT

�q�个题需要多个计��几何算法。第一个是判断一�p�d��Ҏ(gu��)��否能够构成凸多边形，�W�二个是判断一个点是否在一个简单多边�Ş内部�Q?br />�W�三个是求一个点��C��条线�D�（或者说直线�Q�的距离�Q�第四个是判断一个圆是否则一个凸多边形内部�?br /> 其实�Q�我是要判断一个圆是否则一个凸多边形内部而用到算法二和三。其实，有不需要判断圆�?j��)是否则多边形内部的��法�?br /> ��法一的思想�Q�求所有边的偏转方向，必须都是逆时针或者顺旉��偏�{。算法二则是我前面发的那��改�q�弧长法判断点和多边形的关系�Q?br />��法三尤其简单，直线上面�?点，用叉�U�求�?gu��)��三点构成的三角�Ş面积�?倍，再除以底辏V��算法四则是先判断圆�?j��)在多边形内部，然�?br />判断圆心(j��)到所有边的距��要大于圆的半径�?br /> 贴出代码�Q�纯�_��ؓ(f��)�?ji��n)以后作为模版��用等�Q�防止遗忘，方便查找�Q�其实现在也能手敲出来了(ji��n)�?br />
代码如下�Q?div style="background-color:#eeeeee;font-size:13px;border:1px solid #CCCCCC;padding-right: 5px;padding-bottom: 4px;padding-left: 4px;padding-top: 4px;width: 98%;word-break:break-all">

#include

#include <string.h>
#include
#include
#include
using namespace std;

const double fPre = 1e-8;
int DblCmp(double fD)
{
    if (fabs(fD) < fPre)
    {
        return 0;
    }
    else
    {
        return fD > 0 ? 1 : -1;
    }
}

struct Point
{
    double x, y;
    bool operator == (const Point& p)
    {
        return DblCmp(x - p.x) == 0 && DblCmp(y - p.y) == 0;
    }
};

Point operator-(const Point& a, const Point& b)
{
    Point p;
    p.x = a.x - b.x;
    p.y = a.y - b.y;
    return p;
}

double Det(double fX1, double fY1, double fX2, double fY2)
{
    return fX1 * fY2 - fX2 * fY1;
}

double Cross(Point a, Point b, Point c)
{
    return Det(b.x - a.x, b.y - a.y, c.x - a.x, c.y - a.y);
}

bool IsConvexPolygon(vector& vp)
{
    int nN = vp.size();
    int nDirection = 0;
    bool bLine = true;//避免所有点��q��
    for (int i = 0; i < nN; ++i)
    {
        int nTemp = DblCmp(Cross(vp[i], vp[(i + 1) % nN], vp[(i + 2) % nN]));
        if (nTemp)
        {
            bLine = false;
        }
        //�q�次的方向和上次的方向必��L��相同的或者是3点和3点以上共�U�的情况
        if (nDirection * nTemp < 0)
        {
            return false;
        }
        nDirection = nTemp;
    }
    return bLine == false;
}

int GetQuadrant(Point p)
{
    return p.x >= 0 ? (p.y >= 0 ? 0 : 3) : (p.y >= 0 ? 1 : 2);
}

bool IsPtInPolygon(vector& vp, Point p)
{
    int nN = vp.size();
    int nA1, nA2, nSum = 0;
    int i;

    nA1 = GetQuadrant(vp[0] - p);
    for (i = 0; i < nN; ++i)
    {
        int j = (i + 1) % nN;
        if (vp[i] == p)
        {
            break;
        }
        int nC = DblCmp(Cross(p, vp[i], vp[j]));
        int nT1 = DblCmp((vp[i].x - p.x) * (vp[j].x - p.x));
        int nT2 = DblCmp((vp[i].y - p.y) * (vp[j].y - p.y));
        if (!nC && nT1 <= 0 && nT2 <= 0)
        {
            break;
        }
        nA2 = GetQuadrant(vp[j] - p);
        switch ((nA2 - nA1 + 4) % 4)
        {
            case 1:
                nSum++;
                break;
            case 2:
                if (nC > 0)
                {
                    nSum += 2;
                }
                else
                {
                    nSum -= 2;
                }
                break;
            case 3:
                nSum--;
                break;
        }
        nA1 = nA2;
    }

    if (i < nN || nSum)
    {
        return true;
    }
    return false;
}

double PtDis(Point a, Point b)
{
    return sqrt((a.x - b.x) * (a.x - b.x) + (b.y - a.y) * (b.y - a.y));
}
//点p到直�U�ab的距��?br />//h = (2 * Spab) / |ab|
double GetDis(Point a, Point b, Point p)
{
    return fabs(Cross(a, b, p)) / PtDis(a, b);
}

bool IsCircleInPolygon(vector& vp, Point p, double fR)
{
    if (!IsPtInPolygon(vp, p))
    {
        return false;
    }

    int nN = vp.size();
    for (int i = 0; i < nN; ++i)
    {
        if (GetDis(vp[i], vp[(i + 1) % nN], p) < fR)
        {
            return false;
        }
    }
    return true;
}

int main()
{
    int nN;
    double fR, fPx, fPy;
    vector vp;
    Point p;

    while (scanf("%d%lf%lf%lf", &nN, &fR, &fPx, &fPy), nN >= 3)
    {
        vp.clear();
        for (int i = 0; i < nN; ++i)
        {
            scanf("%lf%lf", &p.x, &p.y);
            vp.push_back(p);
        }

        if (IsConvexPolygon(vp))
        {
            p.x = fPx;
            p.y = fPy;
            if (IsCircleInPolygon(vp, p, fR))
            {
                printf("PEG WILL FIT\n");
            }
            else
            {
                printf("PEG WILL NOT FIT\n");
            }
        }
        else
        {
            printf("HOLE IS ILL-FORMED\n");
        }
    }

    return 0;
}

yx 2012-07-20 21:41 发表评论

poj 1265 Area

yx — Fri, 20 Jul 2012 07:36:00 GMT

此题用到�?ji��n)几个知识，一个是求多边�Ş面积的公式。然后是�Q�根据顶炚w��在整点上求多边�Ş边界上的��点数目的方法。最后一个是pick
定理。根据前�?个信息和pick定理��出在多边�Ş内部的整点的个数�?br /> 求多边�Ş面积的方法还是叉�U�代表有向面�U�的原理�Q�把原点看做另外的一个点��d��割原来的多边形�ؓ(f��)N个三角�Ş�Q�然后把它们的有向面
�U�加��h��?br /> 判断边界上点的个数是�Ҏ(gu��)��Gcd�Q�dx,dy)代表当前边上整数点的个数的结论。这个结论的证明其实也比较简单，假设dx = a�Q�dy = b�?br />初始�Ҏ(gu��)��x0�Q�y0�Q�假设d = Gcd�Q�a�Q�b�Q�。那么边上的点可以被表示为（x0 + k * (a / d)�Q�y0 + k * �Q�b / d))。�ؓ(f��)�?ji��n)��?gu��)��整数点，
k必须是整敎ͼ�而且0<= k <=d�Q�所以最多有d个这个的炏V�?br /> 求多边�Ş内部点的个数用的是pick定理。面�U?= 内部�?+ 边界�?/ 2 - 1�?br />
代码如下�Q?br />

#include
#include <string.h>
#include
#include
using namespace std;
#define MAX (100 + 10)

struct Point
{
    double x, y;
};
Point pts[MAX];

int nN;
const int IN = 1;
const int EAGE = 2;
const int OUT = 3;
const double fPre = 1e-8;

double Det(double fX1, double fY1, double fX2, double fY2)
{
    return fX1 * fY2 - fX2 * fY1;
}

double Cross(Point a, Point b, Point c)
{
    return Det(b.x - a.x, b.y - a.y, c.x - a.x, c.y - a.y);
}

double GetArea()
{
    double fArea = 0.0;
    Point ori = {0.0, 0.0};

    for (int i = 0; i < nN; ++i)
    {
        fArea += Cross(ori, pts[i], pts[(i + 1) % nN]);
    }
    return fabs(fArea) * 0.5;
}

int gcd(int nX, int nY)
{
    if (nX < 0)
    {
        nX = -nX;
    }
    if (nY < 0)
    {
        nY = -nY;
    }
    if (nX < nY)
    {
        swap(nX, nY);
    }
    while (nY)
    {
        int nT = nY;
        nY = nX % nY;
        nX = nT;
    }
    return nX;
}

int main()
{
    int nT;
    int nI, nE;
    double fArea;

    scanf("%d", &nT);
    int dx ,dy;

    for (int i = 1; i <= nT; ++i)
    {
        scanf("%d", &nN);
        nI = nE = 0;
        pts[0].x = pts[0].y = 0;
        for (int j = 1; j <= nN; ++j)
        {
            scanf("%d%d", &dx, &dy);
            pts[j].x = pts[j - 1].x + dx;
            pts[j].y = pts[j - 1].y + dy;
            nE += gcd(dx, dy);
        }
        fArea = GetArea();
        nI = (fArea + 1) - nE / 2;
        printf("Scenario #%d:\n%d %d %.1f\n\n", i, nI, nE, fArea);
    }

    return 0;
}

yx 2012-07-20 15:36 发表评论

yx — Fri, 20 Jul 2012 02:30:00 GMT

转角法判断点和多边�Ş的关�p�d��安��知道�Q�原理比较简单，在多边�Ş内扫�q�的转角一定是360度，在边界上和外面则不一定�?br /> 实现��h��也比较麻�?ch��)，��点误差比较大，而且�q�要考虑些特�D�情��c(di��n)�?br /> 在网上找��C��U�叫做改�q�弧长法的算法，原理和�{角法�c�M��Q�但是做�?ji��n)很多重要的改进。比如，计算转角�Ҏ(gu��)��?ji��n)计��叉�U�，�Ҏ(gu��)��叉积军_��
旋�{方向�Q�还要根据计��下一个点的象限决定偏转多��，每次偏�{的都�?0度的倍数�?br /> 该算法可以方便判断出点在多边形内�Q�还是边界上�Q�还是在多边形外面�?br />
摘自别�h对该��法的描�q�如下：(x��)
首先从该书中摘抄一�D�弧长法的介�l�：(x��)“弧长法要求多边�Ş是有向多边�Ş�Q�一般规定沿多边形的正向�Q�边的左侧�ؓ(f��)多边形的内侧域�?br />以被��点为圆�?j��)作单位圆，��全部有�?/span>边向单位圆作径向投媄(ji��ng)�Q��ƈ计算其中单位圆上弧长的代数和。若代数和�ؓ(f��)0�Q�则点在多边�?/span>外部�Q?br />若代数和�?π则点在多边�Ş内部�Q�若代数和�ؓ(f��)π�Q�则点在多边形上�?#8221;
按书上的�q�个介绍�Q�其实弧长法��是转角法。但它的改进�Ҏ(gu��)��比较厉害�Q�将坐标�?/span>点��^�U�d��被测点P�Q�这个新坐标�p�d��q�面划分�?�?br />象限�Q�对每个多边形顶点P �Q�只考虑其所在的象限�Q�然后按��L��序讉K��多边形的各个��点P�Q�分析P和P[i+1]�Q�有下列三种情况�Q?/span>
�Q?�Q�P[i+1]在P的下一象限。此时弧长和�?#960;/2�Q?/span>
�Q?�Q�P[i+1]在P的上一象限。此时弧长和�?#960;/2�Q?/span>
�Q?�Q�P[i+1]在Pi的相对象限。首先计��f=y[i+1]*x-x[i+1]*y�Q�叉�U�）(j��)�Q�若f=0�Q�则点在多边形上�Q�若f<0�Q�弧长和�?#960;�Q�若f>0�Q�弧长和�?#960;�?/span>
最后对��出的代数和和上�q�的情况一样判断即可�?/span>
实现的时候还有两点要注意�Q�第一个是若P的某个坐标�ؓ(f��)0�Ӟ��一律当正号处理�Q?/span>�W�二�Ҏ(gu��)��若被��点和多边�Ş的顶炚w��合时要特�D�处理�?br />
以上��是书上讲解的内容，其实�q�存在一个问题。那��是当多边�Ş的某条边在坐�?/span>轴上而且两个��点分别在原点的两侧时会(x��)出错�?br />如边(3,0)-(-3,0)�Q�按以上的处理，象限分别是第一和第二，�q�样�?x��)��代数和�?#960;/2�Q�有可能��D��最后结果是被测点在多边形外�?/span>而实际上
被测�Ҏ(gu��)��在多边�Ş上（该边�I�过该点�Q��?/span>
对于�q�点�Q�我的处理办法是�Q�每�ơ算P和P[i+1]�Ӟ��p��叉�U�和点积�Q�判断该�Ҏ(gu��)��否在该边上，是则判断�l�束�Q�否则��(h��)�l�上�q�过�E��?br />�q�样牺牲�?ji��n)时��_(d��)��但保证了(ji��n)正确�?/span>�?/span>
具体实现的时候，�׃��只需知道当前点和上一点的象限位置�Q�所以附加空间只需O(1)。实现的时候可以把上述�?#8220;π/2”�Ҏ(gu��)��1�Q?#8220;π”�Ҏ(gu��)��2�Q?br />�q�样便可以完全��用整数进行计��。不必考虑��点的顺序，逆时针和��时针都可以处理�Q�只是最后的代数和符号不�?/span>而已。整个算法编�?br />��h��非常�Ҏ(gu��)��?br />
代码如下�Q?br />

#include
#include

#define MAX (100 + 10)
struct Point
{
    double x,y;
};

Point pts[MAX];
const int OUT = 0;
const int IN = 1;
const int EDGE = 2;
const double fPre = 1e-8;

int DblCmp(double fD)
{
    if (fabs(fD) < fPre)
    {
        return 0;
    }
    else
    {
        return fD > 0 ? 1 : -1;
    }
}

int GetQuadrant(Point p)
{
    return DblCmp(p.x) >= 0 ? (DblCmp(p.y) >= 0 ? 0 : 3) :
               (DblCmp(p.y) >= 0 ? 1 : 2);
}

double Det(double fX1, double fY1, double fX2, double fY2)
{
    return fX1 * fY2 - fX2 * fY1;
}

int PtInPolygon(Point* pts, int nN, Point p)
{
    int i, j, k;
    for (j = 0; j < nN; ++j)
    {
        pts[j].x -= p.x;
        pts[j].y -= p.y;
    }
    int nA1, nA2;
    int nSum = 0;
    nA1 = GetQuadrant(pts[0]);
    for (i = 0; i < nN; ++i)
    {
        k = (i + 1) % nN;
        if (DblCmp(pts[k].x) == 0 && DblCmp(pts[k].y) == 0)
        {
            break;//与顶炚w��?/span>
        }
        int nC = DblCmp(Det(pts[i].x, pts[i].y,
                            pts[k].x, pts[k].y));
        if (!nC && DblCmp(pts[i].x * pts[k].x) <= 0
                && DblCmp(pts[i].y * pts[k].y) <= 0)
        {
            break;//边上
        }
        nA2 = GetQuadrant(pts[k]);
        if ((nA1 + 1) % 4 == nA2)
        {
            nSum += 1;
        }
        else if ((nA1 + 2) % 4 == nA2)
        {
            if (nC > 0)
            {
                nSum += 2;
            }
            else
            {
                nSum -= 2;
            }
        }
        else if ((nA1 + 3) % 4 == nA2)
        {
            nSum -= 1;
        }
        nA1 = nA2;
    }

    for (j = 0; j < nN; ++j)
    {
        pts[j].x += p.x;
        pts[j].y += p.y;
    }

    if (i < nN)
    {
        return EDGE;
    }
    else if (nSum)//逆时针nSum == 4, ��时针nSum == -4
    {
        return IN;
    }
    else
    {
        return OUT;
    }
}

int main()
{
    int nN, nM;
    int nCase = 1;

    while (scanf("%d%d", &nN, &nM), nN)
    {
        if (nCase > 1)
        {
            printf("\n");
        }

        for (int i = 0; i < nN; ++i)
        {
            scanf("%lf%lf", &pts[i].x, &pts[i].y);
        }
        printf("Problem %d:\n", nCase++);
        for (int i = 0; i < nM; ++i)
        {
            Point p;
            scanf("%lf%lf", &p.x, &p.y);
            if (PtInPolygon(pts, nN, p))
            {
                printf("Within\n");
            }
            else
            {
                printf("Outside\n");
            }
        }
    }

    return 0;
}

yx 2012-07-20 10:30 发表评论

poj 3348 Cows

yx — Wed, 18 Jul 2012 12:28:00 GMT

�q�个题用�?个计��几何算法。求解凸包和��单多边�Ş面积。凸包算法详�l�解释见��法��D��。求解多边�Ş面积的思想是将多边形分解�ؓ(f��)三角
形，一般是假设按顺序取多边形上面连�l�的2点与原点�l�合成一个三角�Ş�Q�依�ơ下�ȝ��叉积求有向面�U�之和，最后取�l�对值即可。注意，�q�些
点必��L��在多边�Ş上逆时针或者顺旉��l�出的，而求出凸包刚好给�?ji��n)这��L(f��ng)��一�p�d��炏V�?br /> 凸包代码�Q�其实先扑և�一个y坐标最��的点，再对剩下的所有点按极角排序。然后对排序后的点进行一个二�l��@环即可。二�l��@环的解释�?br />当加入新的点�q�入凸包集合时候，如果与以前加入的点�Ş成的偏�{方向不一��_(d��)��那么前面那些炚w��需要弹出集合�?br />
代码如下�Q?br />

#include
#include <string.h>
#include
#include
using namespace std;
#define MAX_N (10000 + 10)

struct Point
{
    double x, y;
    bool operator <(const Point& p) const
    {
        return y < p.y || y == p.y && x < p.x;
    }
};

Point pts[MAX_N];
int nN;
Point ans[MAX_N];
int nM;

double Det(double fX1, double fY1, double fX2, double fY2)
{
    return fX1 * fY2 - fX2 * fY1;
}

double Cross(Point a, Point b, Point c)
{
    return Det(b.x - a.x, b.y - a.y, c.x - a.x, c.y - a.y);
}

bool CrossCmp(const Point& a, const Point& b)
{
    double cs = Cross(pts[0], a, b);
    return cs > 0 || cs == 0 && a.x < b.x;
}

void Scan()
{
    nM = 0;
    sort(pts + 1, pts + nN, CrossCmp);//�Ҏ(gu��)��有点按极角排�?逆时针偏�?br />
    //�W?-2个点�Q�其实不�?x��)进入第二重循环�?br />    //从第3个点开始，��׃��ơ检查与凸包中前面点形成的边的偏转方�?br />    //如果不是逆时针偏转，则弹�?gu��)��?/span>
    for (int i = 0; i < nN; ++i)
    {
        while (nM >= 2 && Cross(ans[nM - 2], ans[nM - 1], pts[i]) <= 0)
        {
            nM--;
        }
        ans[nM++] = pts[i];
    }
}

double GetArea()
{
    double fAns = 0.0;
    Point ori = {0.0, 0.0};
    for (int i = 0; i < nM; ++i)
    {
        fAns += Cross(ori, ans[i], ans[(i + 1) % nM]);
    }
    return fabs(fAns) * 0.5;
}

int main()
{
    while (scanf("%d", &nN) == 1)
    {
        for (int i = 0; i < nN; ++i)
        {
            scanf("%lf%lf", &pts[i].x, &pts[i].y);
            if (pts[i] < pts[0])
            {
                swap(pts[i], pts[0]);//pts[0]是y坐标最��的�?/span>
            }
        }

        Scan();//扫描出凸�?/span>
        double fArea = GetArea();
        printf("%d\n", (int)(fArea / 50));
    }

    return 0;
}

yx 2012-07-18 20:28 发表评论

poj 3714 Raid and hdu 1007 Quoit Design

yx — Wed, 18 Jul 2012 05:53:00 GMT

典型的最�q�点对算法的应用�Q�不�q�这个题多了(ji��n)个限制条�Ӟ��是点分�?�c�，最短距��d��d��不同的类之间。�ؓ(f��)�?ji��n)满��个限�Ӟ��只需�?br />把同�c�d��点直接的距离都当作INF处理卛_��?br /> 最�q�点对的��法�Q�算��g��面说是nlogn的。但是这个复杂度实现��h��略微�ȝ��(ch��)点，有一�U�实现方法是n*logn*logn的，其只对x坐标�q�行
�?ji��n)排序。n*logn的算法需要对x和y分量分别�q�行排序�Q�还需要用到其它的辅助数组�?br /> �W�一个题我用�?ji��n)n*logn��法实现�?ji��n)，�W�二个题则用�?ji��n)n*logn*logn��法实现�?ji��n)。但是时间上相差不大�Q�因为第一个算法每�ơ进行分��L��
候消耗的O(n)旉��也有几次。第二个��法分治时候，需要再�ơ排序的旉��也不一定很多，因�ؓ(f��)可能数据量不够大�?br /> ��法的本质就是二分按照X排序好的�Ҏ(gu��)��l�，n*logn*logn变成n*logn的关键是预先对y也排序好一个点数组�Q�因为按y排序好的�Ҏ(gu��)��l�，
在分��d��的合�q�中要用到。算法更详细的解释请参照��法��D��?br />

poj 3714 代码如下�Q?/span>

#include
#include <string.h>
#include
#include
using namespace std;
#define MAX_N (100000 * 2 + 10)
const double FINF = 1LL << 60;
struct Point
{
    double x, y;
    int nKind;
};
Point pts[MAX_N], ptsY[MAX_N], ptsTemp[MAX_N];
Point ptsSave[MAX_N];
int nNum;
bool CmpX(const Point& a, const Point& b)
{
    return a.x < b.x;
}

bool CmpY(const Point& a, const Point& b)
{
    return a.y < b.y;
}

double Dis(Point a, Point b)
{
    if (a.nKind == b.nKind)
    {
        return FINF;
    }
    else
    {
        return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
    }
}

double FindMinDis(Point pts[], Point ptsY[], Point ptsTemp[], int nBeg, int nEnd)
{
    if (nBeg == nEnd)
    {
        return FINF;
    }
    else if (nBeg + 1 == nEnd)
    {
        return Dis(pts[nBeg], pts[nEnd]);
    }
    else if (nBeg + 2 == nEnd)
    {
        return min(min(Dis(pts[nBeg], pts[nBeg + 1]), Dis(pts[nBeg], pts[nEnd])),
                   Dis(pts[nBeg + 1], pts[nEnd]));
    }
    else
    {
        memcpy(ptsSave + nBeg, ptsY + nBeg, sizeof(Point) * (nEnd - nBeg + 1));//保存当前的Y坐标��序
        int nMid = (nBeg + nEnd) / 2;
        int nL = nBeg;
        int nR = nMid + 1;
        for (int i = nBeg; i <= nEnd; ++i)
        {
            if (ptsY[i].x - pts[nMid].x <= 0)
            {
                ptsTemp[nL++] = ptsY[i];
            }
            else
            {
                ptsTemp[nR++] = ptsY[i];
            }
        }

        double fAns = min(FindMinDis(pts, ptsTemp, ptsY, nBeg, nMid),
                          FindMinDis(pts, ptsTemp, ptsY, nMid + 1, nEnd));
        int nK = 1;

        for (int i = nBeg; i <= nEnd; ++i)
        {
            if (fabs(ptsSave[i].x - pts[nMid].x) <= fAns)
            {
                ptsTemp[nK++] = ptsSave[i];
            }
        }
        for (int i = 1; i < nK; ++i)
        {
            for (int j = i + 1; j < nK; ++j)
            {
                if (ptsTemp[j].y - ptsTemp[i].y > fAns)
                {
                    break;
                }
                fAns = min(fAns, Dis(ptsTemp[i], ptsTemp[j]));
            }
        }
        return fAns;
    }
}

int main()
{
    int nT;
    int nN;

    //printf("%f", FINF);
    scanf("%d", &nT);
    while (nT--)
    {
        scanf("%d", &nN);
        nNum = nN * 2;
        for (int i = 0; i < nN; ++i)
        {
            scanf("%lf%lf", &pts[i].x, &pts[i].y);
            pts[i].nKind = 1;
        }
        for (int i = nN; i < nNum; ++i)
        {
            scanf("%lf%lf", &pts[i].x, &pts[i].y);
            pts[i].nKind = 2;
        }
        memcpy(ptsY, pts, sizeof(Point) * nNum);
        sort(pts, pts + nNum, CmpX);
        sort(ptsY, ptsY + nNum, CmpY);
        printf("%.3f\n", FindMinDis(pts, ptsY, ptsTemp, 0, nNum - 1));
    }

    return 0;
}

hdu 1007 代码如下�Q?br />

#include
#include
#include
using namespace std;
#define MAX (100000 + 10)
struct Point
{
    double x, y;
};
Point pts[MAX];
Point ptsTemp[MAX];
const double FINF = 1LL << 60;
bool CmpX(const Point& a, const Point& b)
{
    return a.x < b.x;
}

bool CmpY(const Point& a, const Point& b)
{
    return a.y < b.y;
}

double Dis(Point a, Point b)
{
    return sqrt((a.x - b.x) * (a.x - b.x) + (b.y - a.y) * (b.y - a.y));
}

double Find(int nL, int nH)
{
    if (nL == nH)
    {
        return FINF;
    }
    else if (nL + 1 == nH)
    {
        return Dis(pts[nL], pts[nH]);
    }
    else if (nL + 2 == nH)
    {
        return min(Dis(pts[nL], pts[nL + 1]),
                   min(Dis(pts[nL], pts[nH]), Dis(pts[nH], pts[nL + 1])));
    }
    else
    {
        int nMid = (nL + nH) / 2;
        double fAns = min(Find(nL, nMid), Find(nMid + 1, nH));
        int nK = 0;
        for (int i = nL; i <= nH; ++i)
        {
            if (fabs(pts[i].x - pts[nMid].x) <= fAns)
            {
                ptsTemp[nK++] = pts[i];
            }
        }
        sort(ptsTemp, ptsTemp + nK, CmpY);
        for (int i = 0; i < nK; ++i)
        {
            for (int j = i + 1; j < nK; ++j)
            {
                if (ptsTemp[j].y - ptsTemp[i].y >= fAns)
                {
                    break;
                }
                fAns = min(fAns, Dis(ptsTemp[j], ptsTemp[i]));
            }
        }

        return fAns;
    }
}

int main()
{
    int nN;

    while (scanf("%d", &nN), nN)
    {
        for (int i = 0; i < nN; ++i)
        {
            scanf("%lf%lf", &pts[i].x, &pts[i].y);
        }
        sort(pts, pts + nN, CmpX);
        printf("%.2f\n", Find(0, nN -1) * 0.5);
    }

    return 0;
}

yx 2012-07-18 13:53 发表评论

poj 1269 Intersecting Lines

yx — Tue, 17 Jul 2012 07:20:00 GMT

题目意思是�l�出2条直�U�，然后判断其是否相交，�q��Q�还是重合。刚开始以为是判断2条线�D늚�关系�Q�用�?ji��n)黑书的模板写�?ji��n)�Q�发现连样例
都过不了(ji��n)。后面改�?ji��n)很多才�q�了(ji��n)。先判断2条直�U�所在的向量是否�q��Q�这个可以判断这2个向量的叉积是否�?�Q�然后再判断�U�段是否重合�Q?br />可以�?点判断叉�U�是否�ؓ(f��)0。如果向量不�q��的话�Q�直接求交点。求交点的公式是用了(ji��n)黑书里面的方法，先求�?个叉�U�代�?个三角�Ş�?br />有向面积�Q�然后根据定比分点的关系�Q�面�U�的比例�{�于交点分其中一条线�D늚�比例�Q�可以推�?gu��)��公式�?br /> 有叉�U�和点积�q?个工��L(f��ng)��实能方便的解军_��多问题�?br />
代码如下�Q?br />

#include
#include <string.h>
#include
struct Point
{
    double fX;
    double fY;
};
Point beg[2], end[2];
int nN;
const double fPrecision = 1e-8;

double Det(double fX1, double fY1, double fX2, double fY2)
{
    return fX1 * fY2 - fX2 * fY1;
}

double Cross(Point a, Point b, Point c)
{
    return Det(b.fX - a.fX, b.fY - a.fY, c.fX - a.fX, c.fY - a.fY);
}

int DblCmp(double fD)
{
    if (fabs(fD) < fPrecision)
    {
        return 0;
    }
    else
    {
        return (fD > 0 ? 1 : -1);
    }
}

double DotDet(double fX1, double fY1, double fX2, double fY2)
{
    return fX1 * fX2 + fY1 * fY2;
}

double Dot(Point a, Point b, Point c)
{
    return DotDet(b.fX - a.fX, b.fY - a.fY, c.fX - a.fX, c.fY - a.fY);
}

int BetweenCmp(Point a, Point b, Point c)
{
    return DblCmp(Dot(a, b, c));
}

int SegCross(Point a, Point b, Point c, Point d, Point& p)
{
    double s1, s2, s3, s4;
    int d1, d2, d3, d4;
    d1 = DblCmp(s1 = Cross(a, b, c));
    d2 = DblCmp(s2 = Cross(a, b, d));
    d3 = DblCmp(s3 = Cross(c, d, a));
    d4 = DblCmp(s4 = Cross(c, d, b));

    Point e, f;
    e.fX = a.fX - b.fX;
    e.fY = a.fY - b.fY;
    f.fX = c.fX - d.fX;
    f.fY = c.fY - d.fY;
    if (DblCmp(Det(e.fX, e.fY, f.fX, f.fY)) == 0)//2个向量共�U?/span>
    {
        if (d1 * d2 > 0 && d3 * d4 > 0)//不在同一条直�U�上
        {
            return 0;
        }
        else
        {
            return 2;
        }
    }

    //2条直�U�相�?/span>
    p.fX = (c.fX * s2 - d.fX * s1) / (s2 - s1);
    p.fY = (c.fY * s2 - d.fY * s1) / (s2 - s1);
    return 1;
}

int main()
{
    //freopen("out.txt", "w", stdout);
    while (scanf("%d", &nN) == 1)
    {
        printf("INTERSECTING LINES OUTPUT\n");
        Point p;
        for (int i = 0; i < nN; ++i)
        {
            scanf("%lf%lf%lf%lf", &beg[0].fX, &beg[0].fY, &end[0].fX, &end[0].fY);
            scanf("%lf%lf%lf%lf", &beg[1].fX, &beg[1].fY, &end[1].fX, &end[1].fY);
            int nRet = SegCross(beg[0], end[0], beg[1], end[1], p);
            if (nRet == 0)
            {
                printf("NONE\n");
            }
            else if (nRet == 1)
            {
                printf("POINT %.2f %.2f\n", p.fX, p.fY);
            }
            else
            {
                printf("LINE\n");
            }
        }
        printf("END OF OUTPUT\n");
    }

    return 0;
}

yx 2012-07-17 15:20 发表评论

poj 2653 Pick-up sticks

yx — Sun, 15 Jul 2012 09:06:00 GMT

�q�是一个计��几何的题目。题意是�Q�按��序�l�一�p�d��的线�D�，问最�l�哪些线�D�处在顶端�?br /> 只需要穷丑ֈ�断，当前的线�D�会(x��)与哪些线�D�|��交点卛_��。也��是暴力求解�Q�但是线�D�|��目N�?0�?�ơ方�Q��^方算法是不能�q�的。这个题
能过的原因是题目描述里面说了(ji��n)�Q�top的stick不会(x��)��过1000个。那么修改下暴力的方式题目就能过�?ji��n)�?br /> 从小到大枚�D每个��子�Q�判断它是否与后面的��子�怺��Q�如果相交直接把当前��子的top属性置为false�Q�然后break内层循环。这样就�?br />�?x��)超时�?ji��n)�Q�暴力也是需要技巧的�Q�这句话说的很对啊�?br /> 判断2条线�D�|��否相交的��法直接按照黑书上的模板代码写了(ji��n)�Q�那个模板代码还?sh��)��错吧。。�?br />
代码如下�Q?br />

#include

#include <string.h>
#include
#define MAX_N (100000 + 10)
struct POS
{
    double fX;
    double fY;
};

POS begs[MAX_N], ends[MAX_N];
bool bAns[MAX_N];
int nN;
const double fPrecision = 1e-8;

double Det(double fX1, double fY1, double fX2, double fY2)
{
    return fX1 * fY2 - fX2 * fY1;
}

//以a作�ؓ(f��)公共�?计算叉积
double Cross(POS& a, POS& b, POS& c)
{
    return Det(b.fX - a.fX, b.fY - a.fY, c.fX - a.fX, c.fY - a.fY);
}

int DblCmp(double fD)
{
    if (fabs(fD) < fPrecision)
    {
        return 0;
    }
    else
    {
        return fD > 0 ? 1 : -1;
    }
}
//
bool IsSegCross(int nI, int nJ)
{
    return (DblCmp(Cross(begs[nI], ends[nI], begs[nJ]))
            ^ DblCmp(Cross(begs[nI], ends[nI], ends[nJ]))) == -2
        && (DblCmp(Cross(begs[nJ], ends[nJ], begs[nI]))
            ^ DblCmp(Cross(begs[nJ], ends[nJ], ends[nI]))) == -2;
}

int main()
{
    while (scanf("%d", &nN), nN)
    {
        for (int i = 1; i <= nN; ++i)
        {
            scanf("%lf%lf%lf%lf", &begs[i].fX, &begs[i].fY,
                  &ends[i].fX, &ends[i].fY);
        }

        memset(bAns, true, sizeof(bAns));

        //暴力也是需要技巧的
        for (int i = 1; i < nN; ++i)
        {
            for (int j = i + 1; j <= nN; ++j)
            {
                if (IsSegCross(i, j))
                {
                    bAns[i] = false;
                    break;
                }
            }
        }

        printf("Top sticks:");
        bool bPre = false;
        for (int i = 1; i <= nN; ++i)
        {
            if (bAns[i])
            {
                if (bPre)
                {
                    printf(",");
                }
                bPre = true;
                printf(" %d", i);
            }
        }
        printf(".\n");
    }

    return 0;
}

yx 2012-07-15 17:06 发表评论