BZOJ 1027 合金

Description

某公司加工一种由铁、铝、锡组成的合金。他们的工作很简单。首先进口一些铁铝锡合金原材料，不同种类的原材料中铁铝锡的比重不同。然后，将每种原材料取出一定量，经过融解、混合，得到新的合金。新的合金的铁铝锡比重为用户所需要的比重。 现在，用户给出了n种他们需要的合金，以及每种合金中铁铝锡的比重。公司希望能够订购最少种类的原材料，并且使用这些原材料可以加工出用户需要的所有种类的合金。

Input

第一行两个整数m和n（m, n ≤ 500），分别表示原材料种数和用户需要的合金种数。第2到m + 1行，每行三个实数a, b, c（a, b, c ≥ 0 且 a + b + c = 1），分别表示铁铝锡在一种原材料中所占的比重。第m + 2到m + n + 1行，每行三个实数a, b, c（a, b, c ≥ 0 且 a + b + c = 1），分别表示铁铝锡在一种用户需要的合金中所占的比重。

Output

一个整数，表示最少需要的原材料种数。若无解，则输出–1。

Sample Input

3 2
0.25 0.25 0.5
0 0.6 0.5
1 0 0
0.7 0.1 0.2
0.85 0.05 0.1

Sample Output

2

HINT

 

Source

首先可以知道第三个比例是吃翔的(明显啊，1-前面两个就是第三个)。其次，我们再说一个结论：将合金的第一个比例看做x，第二个看做y，则n种合金所能形成的所有合金就是在这n种合金的凸包中(凸包的经典应用)。

因此，问题转换为对目标点求凸包，在从给定点中找出一个闭包将目标凸包包裹起来。问题再一次转换，对于所有合法的边，我们要求的就是一个边权最小的环，就是求floyed求最小环。

好，那么问题就来了。怎么连边呢，首先边不能穿过凸包，还有所有边的方向要跟凸包边的方向一致。(呵呵，慢慢写吧，我是不会告诉你有数据有鬼畜点的，WA了自己拍吧)。然后还有一点，有些特判不能省，详情见我code的spj。

#include<ctime>
#include<iostream>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
using namespace std;

#define rhl 100
#define inf (1<<29)
#define esp (1e-10)
#define maxn 510
int ans = inf,m,n,tot,dis[maxn][maxn];
bool in[maxn];

inline double equal(double a,double b) { return fabs(a-b) < esp; }

inline bool dd(double a,double b) { if (equal(a,b)) return true; return a >= b; }
inline bool dy(double a,double b) { if (equal(a,b)) return false; return a > b; }

inline bool xd(double a,double b) { if (equal(a,b)) return true; return a <= b; }

struct NODE
{
    double x,y;
    friend inline bool operator == (NODE a,NODE b) { return equal(a.x,b.x)&&equal(a.y,b.y); }
    friend inline bool operator < (NODE a,NODE b) { if (a.x == b.x) return a.y < b.y; return a.x < b.x; }
    friend inline NODE operator - (NODE a,NODE b) { return (NODE) {a.x - b.x,a.y - b.y}; }
    friend inline double operator / (NODE a,NODE b) { return a.x*b.y-a.y*b.x; }
    inline NODE ra()
    {
        int xx,yy;
        do xx = rand()%rhl,yy = rand()%rhl;
        while (equal(1.0*xx,x)||equal(1.0*yy,y));
        return (NODE) {1.0*xx,1.0*yy};
    }
    inline void read() { scanf("%lf %lf",&x,&y); }
}pri[maxn],aim[maxn],ch[maxn];
struct LINE
{
    double a,b,c;
    inline bool on(NODE p) { return equal(0,a*p.x+b*p.y+c); }
};
struct SEG
{
    NODE a,b;
    inline LINE extend() { return (LINE) {a.y-b.y,b.x-a.x,b.y*(a.x-b.x)-b.x*(a.y-b.y)}; }
    inline bool on(NODE p)
    {
        if (p == a) return true;
        if (p == b) return true;
        return (dd(p.x,min(a.x,b.x))&xd(p.x,max(a.x,b.x)))&&(dd(p.y,min(a.y,b.y))&xd(p.y,max(a.y,b.y)));
    }
};

inline bool para(LINE l1,LINE l2) { return equal(l1.a * l2.b,l1.b * l2.a); }

inline NODE cp(LINE l1,LINE l2)
{
    double a1 = l1.a,b1 = l1.b,c1 = l1.c;
    double a2 = l2.a,b2 = l2.b,c2 = l2.c;
    double ry = (c2*a1-c1*a2)/(b1*a2-b2*a1),rx = (c1*b2-c2*b1)/(b1*a2-b2*a1);
    return (NODE) {rx,ry};
}

inline void convex()
{
    sort(aim+1,aim+n+1);
    n = unique(aim+1,aim+n+1) - aim - 1;
    for (int i = 1;i <= n;++i)
    {
        while (tot > 1 &&(ch[tot] - ch[tot - 1])/(aim[i] - ch[tot-1]) <= 0) --tot;
        ch[++tot] = aim[i];
    }
    int k = tot;
    for (int i = n-1;i;--i)
    {
        while (tot > k &&(ch[tot] - ch[tot - 1])/(aim[i] - ch[tot-1]) <= 0) --tot;
        ch[++tot] = aim[i];
    }
    if (n > 1) --tot;
    ch[0] = ch[tot];
}

inline int find(NODE p)
{
    NODE q = p.ra(); SEG s = (SEG) {p,q},t; LINE l = s.extend(),l1; int cnt;
    cnt = 0;
    for (int i = 1;i <= tot;++i)
    {
        t = (SEG) {ch[i],ch[i-1]};
        if ((t.extend()).on(p)&&t.on(p)) return false;
        l1 = t.extend();
        if (para(l,l1)) continue;
        q = cp(l,l1);
        if (dd(q.x,p.x)&&t.on(q)) ++cnt;
    }
    if (cnt & 1) return true;
    return false;
}

inline bool cross(NODE p,NODE q)
{
    for (int i = 1;i <= tot;++i) 
        if (dy((q - p) / (ch[i] - p),0)) return false;   
    return true;
}

inline void ready()
{
    sort(pri+1,pri+m+1);
    m = unique(pri+1,pri+m+1) - pri - 1;
    for (int i = 1;i <= m;++i) in[i] = find(pri[i]);
    memset(dis,0x7,sizeof(dis));
    for (int i = 1;i <= m;++i) if (!in[i])
        for (int j = 1;j <= m;++j)
            if (i != j && !in[j] &&dis[j][i] > maxn)
                if (cross(pri[i],pri[j]))
                    dis[i][j] = 1;
}

inline void floyd()
{
    for (int k = 1;k <= m;++k)
        for (int i = 1;i <= m;++i)
            if (dis[i][k] < maxn)
                for (int j = 1;j <= m;++j)
                    dis[i][j] = min(dis[i][j],dis[i][k]+dis[k][j]);
    for (int i = 1;i <= m;++i) ans = min(dis[i][i],ans);
    if (ans > maxn) ans = -1;
    for (int i = 1;i <= m;++i)
        for (int j = i+1;j <= m;++j)
        {
            SEG s = (SEG) {pri[i],pri[j]}; int k;
            for (k = 1;k <= n;++k)
                if (!(equal((aim[k]-pri[i])/(aim[k]-pri[j]),0)&&s.on(aim[k]))) break;
            if (k == n + 1) { ans = 2; break; }
        }
    printf("%d",ans);
}

inline void spj() { if (n == 1) for (int i = 1;i <= m;++i) if (pri[i] == aim[1]) puts("1"),exit(0);  }

int main()
{
    freopen("1027.in","r",stdin);
    freopen("1027.out","w",stdout);
    srand(233);
    scanf("%d %d",&m,&n); double w;
    for (int i = 1;i <= m;++i)
        pri[i].read(),scanf("%lf",&w);
    for (int i = 1;i <= n;++i)
        aim[i].read(),scanf("%lf",&w);
    convex();
    spj();
    ready();
    floyd();
    fclose(stdin); fclose(stdout);
    return 0;
}