POJ 1873 （枚舉子集+凸包）

很久以前的 world final 裏的水題。。

枚舉子集 + 凸包，有幾個地方特判一下。。

我的做法比較暴力。。應該有更好的算法，比如在 graham 算法的基礎上稍加修改。。

#include <cstdio>
#include <cmath>
#include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
const int MAXN=27;
const double eps = 1e-8;

int sgn(double x)
{
    if(fabs(x) < eps)return 0;
    if(x < 0)return -1;
    else return 1;
}

struct Point
{
    double x,y;
    Point(){}
    Point(double _x,double _y)
    {
        x = _x;y = _y;
    }
    //向量
    Point operator -(const Point &b)const
    {
        return Point(x - b.x,y - b.y);
    }
    //叉積
    double operator ^(const Point &b)const
    {
        return x*b.y - y*b.x;
    }
    //點積
    double operator *(const Point &b)const
    {
        return x*b.x + y*b.y;
    }
    bool operator ==(const Point &b)const
    {
        return !sgn(x - b.x) && !sgn(y - b.y);
    }
    bool operator !=(const Point &b)const
    {
        return sgn(x - b.x) || sgn(y - b.y);
    }
    void input()
    {
        scanf("%lf%lf",&x,&y);
    }
};

struct Line
{
    Point s,e;
    Line(){}
    Line(Point _s,Point _e)
    {
        s = _s;e = _e;
    }
    //兩直線相交求交點
    //第一個值爲0表示直線重合，爲1表示平行，爲0表示相交,爲2是相交
    //只有第一個值爲2時，交點纔有意義
    pair<int,Point> operator &(const Line &b)const
    {
        Point res = s;
        if(sgn((s-e)^(b.s-b.e)) == 0)
        {
            if(sgn((s-b.e)^(b.s-b.e)) == 0)
                return make_pair(0,res);//重合
            else return make_pair(1,res);//平行
        }
        double t = ((s-b.s)^(b.s-b.e))/((s-e)^(b.s-b.e));
        res.x += (e.x-s.x)*t;
        res.y += (e.y-s.y)*t;
        return make_pair(2,res);
    }
};

bool OnSeg(Point P,Line L)
{
    return
    sgn((L.s-P)^(L.e-P)) == 0 &&
    sgn((P.x - L.s.x) * (P.x - L.e.x)) <= 0 &&
    sgn((P.y - L.s.y) * (P.y - L.e.y)) <= 0;
}

Point list[MAXN], plist[MAXN];
int stack[MAXN],top;

int cross(Point p0,Point p1,Point p2) //計算叉積  p0p1 X p0p2
{
    return (p1.x-p0.x)*(p2.y-p0.y)-(p1.y-p0.y)*(p2.x-p0.x);
}

double dis(Point p1,Point p2)  //計算 p1p2的 距離
{
    return sqrt((double)(p2.x-p1.x)*(p2.x-p1.x)+(p2.y-p1.y)*(p2.y-p1.y));
}

bool cmp(Point p1,Point p2) //極角排序函數 ， 角度相同則距離小的在前面
{
    int tmp=cross(list[0],p1,p2);
    if(tmp>0) return true;
    else if(tmp==0&&dis(list[0],p1)<dis(list[0],p2)) return true;
    else return false;
}

void init(int n) //輸入，並把  最左下方的點放在 list[0]  。並且進行極角排序
{
    int i,k;
    Point p0;
    p0.x=list[0].x;
    p0.y=list[0].y;
    k=0;
    for(i=1;i<n;i++)
    {
        if( (p0.y>list[i].y) || ((p0.y==list[i].y)&&(p0.x>list[i].x)) )
        {
            p0.x=list[i].x;
            p0.y=list[i].y;
            k=i;
        }
    }
    list[k]=list[0];
    list[0]=p0;

    sort(list+1,list+n,cmp);
}

void graham(int n)
{
    int i;
    if(n==1) {top=0;stack[0]=0;}
    if(n==2)
    {
        top=1;
        stack[0]=0;
        stack[1]=1;
    }
    if(n>2)
    {
        for(i=0;i<=1;i++) stack[i]=i;
        top=1;

        for(i=2;i<n;i++)
        {
            while(top>0&&cross(list[stack[top-1]],list[stack[top]],list[i])<=0) top--;
            top++;
            stack[top]=i;
        }
    }
}

double dist(Point a,Point b)
{
    return sqrt((a-b)*(a-b));
}

Point tree[MAXN];
int val[MAXN];
double len[MAXN];
int n;

int main()
{
    int ca = 1;
    bool first = true;

    while (~scanf("%d", &n) && n) {
        if (first)
            first = false;
        else
            puts("");
        for (int i = 0; i < n; i++)
            scanf("%lf%lf%d%lf", &tree[i].x, &tree[i].y, &val[i], &len[i]);
        printf("Forest %d\n", ca++);
        if (n == 1) while (1) puts("AA");
        if (n == 2) {
            printf("Cut these trees: ");
            if (val[0] < val[1]) {
                printf("%d\n", 1);
                printf("Extra wood: %.2lf\n", len[0]);
            } else if (val[0] > val[1]) {
                printf("%d\n", 2);
                printf("Extra wood: %.2lf\n", len[1]);
            } else
                while(1) puts("AA");
            continue;
        }
        int all = 0, bst, lst = 0, bnum = n;
        double blen;
        for (int i = 0; i < n; i++) {
            all += 1 << i;
            lst += val[i];
            blen += len[i];
        }
        bst = all;
        for (int cur = all; cur; cur = (cur-1) & all) {
            if (cur == all) continue;
            int num = 0, tmp = cur, icnt = 0, tval = 0;
            double tlen = 0;
            bool cutted[MAXN];
            memset(cutted, false, sizeof(cutted));
            while (tmp) {
                if (tmp & 1) {
                    num++;
                    tval += val[icnt];
                    tlen += len[icnt];
                    cutted[icnt] = true;
                }
                icnt++;
                tmp >>= 1;
            }
            if (num == n-1) {
                if (tval < lst || (tval == lst && num < bnum)) {
                    bst = cur;
                    lst = tval;
                    bnum = num;
                    blen = tlen;
                }
            } else if (num == n-2) {
                int remain[2], rnum = 0;
                for (int i = 0; i < n; i++) {
                    if (!cutted[i])
                        remain[rnum++] = i;
                    if (rnum == 2)
                        break;
                }
                double extra = tlen - 2.0 * dist(tree[remain[0]], tree[remain[1]]);
                if (sgn(extra) >= 0 && (tval < lst || (tval == lst && num < bnum))) {
                    bst = cur;
                    lst = tval;
                    bnum = num;
                    blen = extra;
                }
            } else {
                int lnum = 0;
                for (int i = 0; i < n; i++)
                    if (!cutted[i])
                        list[lnum++] = tree[i];
                init(lnum);
                graham(lnum);
                double chlen = 0, extra;
                for (int i = 0; i <= top; i++)
                    chlen += dist(list[stack[i]], list[stack[(i+1) % (top+1)]]);
                extra = tlen - chlen;
                if (sgn(extra) >= 0 && (tval < lst || (tval == lst && num < bnum))) {
                    bst = cur;
                    lst = tval;
                    bnum = num;
                    blen = extra;
                }
            }
        }
        int index[MAXN], tmp = bst, inum = 0, icnt = 0;
        while (tmp) {
            if (tmp & 1)
                index[inum++] = icnt;
            icnt++;
            tmp >>= 1;
        }
        printf("Cut these trees:");
        for (int i = 0; i < inum; i++)
            printf(" %d", index[i]+1);
        printf("\nExtra wood: %.2lf\n", blen);
    }

    return 0;
}
/*

6
0 0
0 1
0 2
1 0
2 0
1 1

*/