codechef营养题 第二弹

第二弾が始まる！

codechef problems 第二弹

一、Backup Functions

题面

One unavoidable problem with running a restaurant is that occasionally a menu item cannot be prepared. This can be caused by a variety of reasons such as missing ingredients or malfunctioning equipment.

There is an additional problem with such situations. A customer who has spent many minutes deciding between menu items can get quite annoyed when they place the order and the server tells them the item is not available. To mitigate this effect, the Chef declares that all servers must have what he calls a "backup function". This is a function f from menu items to menu items. For each menu item x, f(x) is an alternative menu item that the server may suggest to the customer in the event the customer requests menu item x when x is not available.

Of course, if a given item is not available then some other items make better suggestions than others. So, for some pairs of items x and y the Chef has determined a numeric value describing the effectiveness of the assignment f(x) = y. Higher values indicate the proposed substitute is similar to the original and lower values indicate the proposed substitute is not very similar to the original. Such effectiveness values are symmetric meaning that if the effectiveness of assignment f(x) = y is v, then the effectiveness of the assignment f(y) = x is also v.

You will be given a list of pairs of menu items. Each such pair will come with an associated effectiveness value. You are to compute a backup function f from these pairs. However, there is one additional constraint. For personal reasons, the Chef is opposed to using two items as backups for each other. Thus, for any two menu items x and y, it cannot be that f(x) = y and f(y) = x. Your goal is to compute a backup function of maximum possible quality. The quality of the backup function is simply defined as the sum of the effectiveness values of the assignments f(a) for each item a.

Input

The first line contains a single integer T ≤ 30 indicating the number of test cases.

Each test case begins with two integers N and M where 3 ≤ N ≤ 10,000 and 3 ≤ M ≤ 50,000 where N is the number of items in the menu. The menu items will be numbered 1 through N.

M lines follow, each containing three integers a,b, and v. Here 1 ≤ a < b ≤ N and |v| ≤ 100,000. Such a triple indicates that f(a) = b or f(b) = a (but not both) may be used in a backup function. Setting either f(a) = b or f(b) = a has effectiveness v. Each pair 1 ≤ a < b ≤ N will occur at most once in the input.

Test cases will be separated by a single blank line (including a blank line preceding the first test case).

Output

The output for each test case consists of a single line containing the maximum possible quality of a backup function f that does not assign any pair of items to each other. To be explicit, the assignment f(a) = b has effectiveness v where v is the value associated with the a,b pair in the input. Then the quality of a backup function is just the sum of the effectiveness values of the assignment for each item. If no backup function can be constructed from the given input pairs, then simply output "impossible" (note the lowercase 'i').

We may only assign f(a) = b or f(b) = a if a,b is an input pair. Furthermore, a backup function defines a single item f(a) for every item a between 1 and n. Note that f(a) = a is not valid since f(a) is supposed to be an alternative item if menu item a is not available (and all input pairs a,b have a < b anyway). Finally, based on the Chef's additional constraint we cannot have a backup function with both f(a) = b and f(b) = a for any input pair a,b.

Example

Input:

  -

  -

  -

Output:

impossible

Note, one possible solution for the first test case is f(1) = 2, f(2) = 3, and f(3) = 1. The second is impossible since the only possiblity for f(5) is 6 and the only possiblity for f(6) is 5 and both cannot be used in a backup function. Finally, a possible solution for the last test case is f(1) = 2, f(2) = 3, f(3) = 1, and f(4) = 2.

Description

给定N道菜，M个替换关系

替换关系描述为三元组(a,b,c)，表示a和b两道菜可以相互作为备选菜，当a或b没法做时，b或a可以作为它的备用菜

定义函数f(x)=y，代表菜x的备选菜是y

特别地，不允许f(x)=y and f(y)=x

Solution

并查集，把关系排序后能加就加

#include <stdio.h>
#include <algorithm>
#define N 10010
#define M 50010
#define Buf 1<<22
#define RG register
#define Blue() ((S==T&&(T=(S=B)+fread(B,1,Buf,stdin),S==T))?0:*S++)
char B[Buf],*S=B,*T=B;
template<class Type>inline void Rin(RG Type &x)
{
 x=;RG int c=Blue();RG bool b=false;
 for(;c<||c>;c=Blue())
  if(c==)b=true;
 for(;c>&&c<;c=Blue())
  x=(x<<)+(x<<)+c-;
 x=b?-x:x;
}
bool r[N];
int k,n,m,f[N],a,c,tx,ty;
struct L
{
 int u,v,w;
 bool operator < (const L &o) const
  {
    return w<o.w;
  }
}e[M];
inline int fd(RG int x)
{
 for(;x!=f[x];x=f[x]=f[f[x]]);
  return x;
}
#define FO(x) {freopen(#x".in","r",stdin);}
int main(){
 FO(cc backup func);
 Rin(k);
 while(k--)
  {
    Rin(n),Rin(m);
    for(RG int i=;i<=m;i++)
     Rin(e[i].u),Rin(e[i].v),Rin(e[i].w);
    std::sort(e+,e++m);
    for(RG int i=;i<=n;i++)
     f[i]=i,r[i]=;
    a=c=;
    while(c<n&&m)
     {
      tx=fd(e[m].u),ty=fd(e[m].v);
      if(tx!=ty)
       {
        if(r[tx]|r[ty])
         ++c,
         f[tx]=ty,
         r[ty]&=r[tx],
         a+=e[m].w;
       }
      else if(r[ty])
            ++c,
            r[ty]=,
            a+=e[m].w;
      m--;
     }
     c==n?printf("%d\n",a):puts("impossible");
 }
 return ;
}

二、magic hull

题面

You are given a set of N two-dimensional non-zero vectors (X₁, Y₁), (X₂, Y₂), ..., (X_N, Y_N) with integer coordinates. You can choose no more than 6 vectors from this set to form a non-strictly convex polygon that have sides equal to these vectors (see paragraph below for more detailed explanation). Non-strictly convex polygon is the polygon that can have flat angles (angles of 180 degrees). You can select each vector several times if needed. Your goal is to maximize the area of this polygon. It is guaranteed that at least one such convex polygon can be constructed.

How exactly we construct a polygon from the given sequence of vectors? Suppose you've chosen the sequence of vectors (U₁, V₁), (U₂, V₂), ..., (U_K, V_K), where 3 ≤ K ≤ 6. Each vector here should be equal to one of the given N vectors but some vectors in this sequence can coincide. At first, you take some point (A₁, B₁) at the plane as the first vertex of your polygon. Then you put your first vector (U₁, V₁) to this point to obtain the second vertex (A₂, B₂) = (A₁ + U₁, B₁ + V₁). Next you take the second vector and put it to the second vertex to obtain the third vertex and so on. Finally, at the last step you put vector (U_K, V_K) to the K^thvertex (A_K, B_K) to obtain the point (A_{K + 1}, B_{K + 1}) = (A_K + U_K, B_K + V_K) that should coincide with the first vertex (A₁, B₁), otherwise we should reject this sequence of vectors. Hence in the end we obtain a polygon with vertexes (A₁, B₁), (A₂, B₂), ..., (A_K, B_K). If this polygon is simple (without self-intersections) and non-strictly convex, we should consider its area as the candidate for the answer. By self-intersection we mean that either some non-consecutive sides (considered with their ends) have common point or two consecutive sides have more than one common point.

Input

The first line of the input file contains an integer N, the number of the given vectors. Each of the following N lines contains two space separated integers X_i, Y_i, coordinates of the corresponding vector.

Output

In the only line of the output file print the maximal possible area of the convex polygon that can be constructed by the rules described in the problem statement with exactly one digit after the decimal point.

Constraints

3 ≤ N ≤ 150

|X_i|, |Y_i| ≤ 1000000

All vectors are non-zero: |X_i| + |Y_i| > 0

There exists at least one sequence of at most 6 vectors from this set that forms a convex polygon.

Example

Input:

-
-
- -

Output:

2.0

Explanation

The only non-strictly convex polygon you can construct from these vectors by the rules described in the problem statement is the isosceles trapezoid that has height of length 1 and bases of length 1 and 3. It has area 2.0.

Description

给你一堆向量，求k个向量组成凸包的最大面积

其中k<=6

Solution

O(n^3)建凸壳

满足和向量互为相反向量的就可以组合成一个凸包

二分+排序

最差时间复杂度(n^3 * log n)

目前codechef上rank1最快，归功于简单短小的变量名

#include <math.h>
#include <stdio.h>
#include <algorithm>
#define L long long
#define N 155
#define U 1<<22
#define dmax(a,b) ((a)>(b)?(a):(b))
#define dabs(a) ((a)<(0)?(-a):(a))
#define F()((I==J&&(J=(I=B)+fread(B,1,U,stdin),I==J))?0:*I++)
char B[U],*I=B,*J=B;
template<class T>inline void Rin(T &x)
{
    x=;int c=F();bool b=;
    for(;c<||c>;c=F())
        if(c==)b=;
    for(;c>&&c<;c=F())
        x=(x<<)+(x<<)+c-;
    x=b?-x:x;
}
struct VV
{
    int x,y;
    VV(int _=,int __=)
        {
        x=_;
        y=__;
        }
    bool operator < (VV o) const
        {
        return x<o.x||x==o.x&&y<o.y;
        }
    bool operator == (VV o) const
        {
        return x==o.x&&y==o.y;
        }
    L operator ^ (VV o) const
        {
        return (L)x*o.y-(L)y*o.x;
        }
    VV operator + (VV o) const
        {
        return VV(x+o.x,y+o.y);
        }
    VV operator - () const
        {
        return VV(-x,-y);
        }
    int p()
        {
        return y>||y==&&x>;
        }
}V[N];
struct PP
{
    VV f;
    L s;
    PP(VV _=,L __=)
        {
        f=_;
        s=__;
        }
    bool operator < (PP o) const
        {
        return f<o.f||f==o.f&&s<o.s;
        }
    bool operator == (PP o) const
        {
        return f==o.f&&s==o.s;
        }
}P[N*N*N/];
bool A(VV a,VV b)
{
    int p=a.p();
    int q=b.p();
    if(p!=q)
        {
        return p>q;
        }
    return (a^b)>;
}
int n,_t,_k;
L ans;
#define FO(x) {freopen(#x".in","r",stdin);}
int main()
{
    FO(cc magic hull);
    Rin(n);
    for(int i=;i<n;i++)
        {
        Rin(V[i].x);
        Rin(V[i].y);
        }
    std::sort(V,V+n,A);
    //按角度大小排序,不用atan2等库函数防止浮点误差,本题没有这样的特殊要求;
    for(int i=;i<n;i++)
        {
        for(int j=i;j<n;j++)
            {
            L m=V[i]^V[j];
            if(m<)
                {
                break;
                }
            m=dabs(m);
            P[_t++]=PP(V[i]+V[j],m);
            //P数组用于存储和向量及面积,多边形面积并直接叉积就行;
            for(int k=j;k<n;k++)
                {
                if((V[j]^V[k])<)
                    {
                    break;
                    }
                VV t=V[i]+V[j]+V[k];
                if((V[i]^t)>=)
                    {
                    P[_t++]=PP(t,m+dabs(V[k]^t));
                    }
                }
            }
        }
    std::sort(P,P+_t);
    for(int i=;i<_t;)
        {
        int j=i;
        for(;j<_t&&P[i].f==P[j].f;j++)
            ;
        P[_k++]=P[j-];
        i=j;
        }
    for(int i=;i<_k;i++)
        {
        VV t=-P[i].f;
        int j=std::lower_bound(P,P+_k,PP(t,-1LL))-P;
        if(j<_k&&P[j].f==t)
            {
            ans=dmax(ans,P[i].s+P[j].s);
            }
        }
    printf("%lld.%lld\n",ans/,ans%*);
    return ;
}