cf Round 613

A.Peter and Snow Blower(计算几何)

给定一个点和一个多边形，求出这个多边形绕这个点旋转一圈后形成的面积。
保证这个点不在多边形内。

画个图能明白 这个图形是一个圆环，那么就是这个点距离多边形边缘最远的距离形成的圆面积减去这个点距离多边形边缘最近的距离形成的圆面积。
我们可以得出距离最远的点一定是多边形的顶点。
而距离最近的点不一定是多边形的顶点，但是在多边形的边上。
我们用勾股定理判断点与每条边形成的三角形的两边角。
如果有一个边角是钝角，则表示距离最近的点是顶点。
如果都是锐角，则表示距离最近的点在底边上。
我们用海伦公式求出三角形的面积，再除以底边*2，那么就得出了这个三角形的高。
此题得解。

# include <stdio.h>
# include <string.h>
# include <stdlib.h>
# include <iostream>
# include <vector>
# include <queue>
# include <stack>
# include <map>
# include <math.h>
# include <algorithm>
using namespace std;
# define lowbit(x) ((x)&(-x))
# define pi acos(-1.0)
# define MAXN
# define eps 1e-
# define MAXM
# define MOD
# define INF
# define mem(a,b) memset(a,b,sizeof(a))
# define FOR(i,a,n) for(int i=a; i<=n; ++i)
# define FO(i,a,n) for(int i=a; i<n; ++i)
# define bug puts("H");
# define lch p<<,l,mid
# define rch p<<|,mid+,r
# pragma comment(linker, "/STACK:1024000000,1024000000")
typedef long long LL;
typedef unsigned long long ULL;
int _MAX(int a, int b){return a>b?a:b;}
int _MIN(int a, int b){return a>b?b:a;}
int Scan() {
    int res=, flag=;
    char ch;
    if((ch=getchar())=='-') flag=;
    else if(ch>=''&&ch<='') res=ch-'';
    while((ch=getchar())>=''&&ch<='')  res=res*+(ch-'');
    return flag?-res:res;
}
void Out(int a) {
    if(a<) {putchar('-'); a=-a;}
    if(a>=) Out(a/);
    putchar(a%+'');
}

LL a[][];
LL dis(LL x1, LL y1, LL x2, LL y2)
{
    return (x2-x1)*(x2-x1)+(y2-y1)*(y2-y1);
}
int main ()
{
    LL n, px, py, ma=;
    double mi=1e16;
    scanf("%lld%lld%lld",&n,&px,&py);
    FOR(i,,n) {
        scanf("%lld%lld",&a[i][],&a[i][]);
        LL d = dis(a[i][],a[i][],px,py);
        mi=min(mi,(double)d); ma=max(ma,d);
    }
    a[n+][]=a[][], a[n+][]=a[][];
    FOR(i,,n) {
        LL A2=dis(px,py,a[i][],a[i][]);
        LL B2=dis(px,py,a[i+][],a[i+][]);
        LL C2=dis(a[i][],a[i][],a[i+][],a[i+][]);
        double A=sqrt(A2), B=sqrt(B2), C=sqrt(C2);
        if (C2+B2>A2&&C2+A2>B2) {
            double P=(A+B+C)/;
            double S=sqrt(P*(P-A)*(P-B)*(P-C));
            double H=S/C*;
            mi=min(mi,H*H);
        }
    }
    printf("%.10lf\n",pi*(ma-mi));
    return ;
}

B.Skills(贪心+枚举+二分)

给你n个数，可以花费1使得数字+1，最大加到A，最多花费m。最后，n个数里的最小值为min，为A的有k个，给你cm和cf，求force=min*cm+k*cf 的最大值，和n个数操作后的结果。

我们如果要让最小值增加，那它加到和第二小的一样时，就有两个最小值，接下来就要两个一起增加。到后来就要好多个一起增加了。
那么我们可以枚举加到A的有多少个，然后用二分的方法求剩下m元，可以使最小值最大为多少。

#include<bits/stdc++.h>
#define N 100005
#define ll long long
using namespace std;

struct data
{
    ll id,v;
} a[N];

bool cmp(data a,data b)
{
    return a.v<b.v||a.v==b.v&&a.id<b.id;
}

ll n,A,cf,cm,m;
ll L,ans[N],f,ansA,ansL;
ll s[N];

ll findL(ll m,ll R)//还剩多少m，右端点是什么
{
    ll l=,r=A,ans=;//二分确定最小值的值

    while(l<=r)
    {

        ll mid=(r+l)>>;

        //二分确定有多少个比这个值小，然后计算需要的花费
        int p=lower_bound(a+,a++n,(data){,mid},cmp)-a-;
        if(p>R)p=R;
        if(p*mid-s[p]<=m)
        {
            ans=mid;
            l=mid+;
        }
        else
            r=mid-;
    }
    return ans;
}
int main()
{
    scanf("%lld%lld%lld%lld%lld",&n,&A,&cf,&cm,&m);
    for(int i=; i<=n; i++)
    {
        scanf("%lld",&a[i].v);
        a[i].id=i;
    }

    sort(a+,a+n+,cmp);//先排序再求前缀和
    for(int i=; i<=n; i++)
        s[i]=s[i-]+a[i].v;

    for(int i=; i<=n; i++) //如果有i个设置为A的话
    {

        ll p=A*i-s[n]+s[n-i];//花费
        if(p<=m)
        {
            L=findL(m-p,n-i);//那最小值可以达到多少
            if(cm*L+cf*i>f) //更新答案
            {
                f=cm*L+cf*i;
                ansA=i;//储存有几个变成A
                ansL=L;//储存最小值要达到多少
            }
        }
    }
    printf("%lld\n",f);
    for(int j=; j<=n; j++)
    {
        if(j>n-ansA)
            ans[a[j].id]=A;
        else if(a[j].v<=ansL)
            ans[a[j].id]=ansL;
        else
            ans[a[j].id]=a[j].v;
    }
    for(int i=; i<=n; i++)
        printf("%lld ",ans[i]);
    return ;
}

C.Necklace(构造)

给你n种字符，每种有ai个，构造一个环，要求刨开环之后形成回文串，且种数最多。

显然当ai中有两个奇数，答案为0.
我们可以把这n个字符分成x个部分，且每个部分中每个字符的个数一样。
这样x<=gcd(a1,a2...ai).
我们证明答案一定能取到gcd(a1,a2...ai).
首先如果ai中有一个奇数，我们可以令每个部分都形成一个回文串。
如果ai中没有奇数，我们可以令每个部分与相邻的部分成为一个回文串。可以证明第一个部分
同样可以与最后一个部分成为回文串。
所以答案就是x

# include <stdio.h>
# include <string.h>
# include <stdlib.h>
# include <iostream>
# include <vector>
# include <queue>
# include <stack>
# include <map>
# include <math.h>
# include <algorithm>
using namespace std;
# define lowbit(x) ((x)&(-x))
# define pi acos(-1.0)
# define MAXN
# define eps 1e-
# define MAXM
# define MOD
# define INF
# define mem(a,b) memset(a,b,sizeof(a))
# define FOR(i,a,n) for(int i=a; i<=n; ++i)
# define FO(i,a,n) for(int i=a; i<n; ++i)
# define bug puts("H");
# define lch p<<,l,mid
# define rch p<<|,mid+,r
# pragma comment(linker, "/STACK:1024000000,1024000000")
typedef long long LL;
typedef unsigned long long ULL;
int _MAX(int a, int b){return a>b?a:b;}
int _MIN(int a, int b){return a>b?b:a;}
int Scan() {
    int res=, flag=;
    char ch;
    if((ch=getchar())=='-') flag=;
    else if(ch>=''&&ch<='') res=ch-'';
    while((ch=getchar())>=''&&ch<='')  res=res*+(ch-'');
    return flag?-res:res;
}
void Out(int a) {
    if(a<) {putchar('-'); a=-a;}
    if(a>=) Out(a/);
    putchar(a%+'');
}

int a[];

int gcd(int x, int y){y==?x:gcd(y,x%y);}
int main ()
{
    int n, cnt=;
    scanf("%d",&n);
    FOR(i,,n) scanf("%d",a+i), cnt+=a[i]&;
    int G=a[];
    FOR(i,,n) G=gcd(G,a[i]);
    if (n==) {
        printf("%d\n",a[]);
        FOR(i,,a[]) putchar('a');
        putchar('\n');
        return ;
    }
    if (cnt>=) {
        puts("");
        FOR(i,,n) FOR(j,,a[i]) putchar('a'+i-);
        putchar('\n');
    }
    else if (cnt==) {
        printf("%d\n",G);
        FOR(k,,G) {
            FOR(i,,n) if (a[i]%==) FOR(j,,a[i]/G/) putchar('a'+i-);
            FOR(i,,n) if (a[i]&) FOR(j,,a[i]/G) putchar('a'+i-);
            for (int i=n; i>=; --i) if (a[i]%==) FOR(j,,a[i]/G/) putchar('a'+i-);
        }
    }
    else {
        printf("%d\n",G);
        FOR(k,,G/) {
            FOR(i,,n) FOR(j,,a[i]/G) putchar('a'+i-);
            for (int i=n; i>=; --i) FOR(j,,a[i]/G) putchar('a'+i-);
        }
        putchar('\n');
    }
    return ;
}

D.Kingdom and its Cities(虚树)

题意:给出n个节点的树，询问q次，每次询问mi个点，问将这mi个点分离开来
至少需要割掉多少个点。
(n<=1e5,sigma(mi)<=1e5)

显然无解的情况是存在两个点相邻。
我们先来考虑每次询问。从树的底层往高层看，
如果一个节点是询问点，那么它的子树中有询问点的就删掉它的子树。
如果一个节点是非询问点，那么它的有询问点的子树超过1个的时候，
就需要把这个节点为根的树给删了。
所以一遍dfs即可。复杂度O(n).对于q个询问，复杂度O(n*q).

因为sigma(mi)<=1e5.
我们把询问点单独拉出来建立一颗虚树。
复杂度O((n+sigma(m))*logn).

# include <stdio.h>
# include <string.h>
# include <stdlib.h>
# include <iostream>
# include <vector>
# include <queue>
# include <stack>
# include <map>
# include <math.h>
# include <algorithm>
using namespace std;
# define lowbit(x) ((x)&(-x))
# define pi acos(-1.0)
# define MAXN
# define eps 1e-
# define MAXM
# define MOD
# define INF
# define mem(a,b) memset(a,b,sizeof(a))
# define FOR(i,a,n) for(int i=a; i<=n; ++i)
# define FO(i,a,n) for(int i=a; i<n; ++i)
# define bug puts("H");
typedef long long LL;
typedef unsigned long long ULL;
int _MAX(int a, int b){return a>b?a:b;}
int _MIN(int a, int b){return a>b?b:a;}
int Scan() {
    int res=, flag=;
    char ch;
    if((ch=getchar())=='-') flag=;
    else if(ch>=''&&ch<='') res=ch-'';
    while((ch=getchar())>=''&&ch<='')  res=res*+(ch-'');
    return flag?-res:res;
}
void Out(int a) {
    if(a<) {putchar('-'); a=-a;}
    if(a>=) Out(a/);
    putchar(a%+'');
}

struct Edge{int p, next;}edge[MAXN<<];
int head[MAXN], cnt=, mark, top, ans;
int bin[], dep[MAXN], id[MAXN], fa[MAXN][], h[MAXN], st[MAXN], vis[MAXN];

bool comp(int a, int b){return id[a]<id[b];}
void bin_init(){bin[]=; FO(i,,) bin[i]=bin[i-]<<;}
void add_edge(int u, int v)
{
    if (u==v) return ;
    edge[cnt].p=v; edge[cnt].next=head[u]; head[u]=cnt++;
}
void dfs(int x, int fat)
{
    id[x]=++mark;
    fa[x][]=fat;
    for (int i=; bin[i]<=dep[x]; ++i) fa[x][i]=fa[fa[x][i-]][i-];
    for (int i=head[x]; i; i=edge[i].next) {
        int v=edge[i].p;
        if (v==fat) continue;
        dep[v]=dep[x]+;
        dfs(v,x);
    }
}
int dp_dfs(int x)
{
    if (vis[x]) {
        for (int i=head[x]; i; i=edge[i].next) {
            int v=edge[i].p;
            if (dp_dfs(v)) ans++;
        }
        head[x]=vis[x]=;
        return ;
    }
    else {
        int tot=;
        for (int i=head[x]; i; i=edge[i].next) {
            int v=edge[i].p;
            tot+=dp_dfs(v);
        }
        head[x]=vis[x]=;
        if (tot>) {ans++; return ;}
        else return tot;
    }
}
int lca(int x, int y)
{
    if (dep[x]<dep[y]) swap(x,y);
    int t=dep[x]-dep[y];
    for (int i=; bin[i]<=t; ++i) if (bin[i]&t) x=fa[x][i];
    if (x==y) return x;
    for (int i=; i>=; --i) if (fa[x][i]!=fa[y][i]) x=fa[x][i], y=fa[y][i];
    return fa[x][];
}
void sol()
{
    int m=Scan();
    cnt=; top=, ans=;
    FOR(i,,m) h[i]=Scan(), vis[h[i]]=;
    sort(h+,h+m+,comp);
    FOR(i,,m) if (vis[fa[h[i]][]]) {
        puts("-1");
        FOR(i,,m) vis[h[i]]=;
        return ;
    }
    st[++top]=;
    int P=h[]==?:;
    FOR(i,P,m) {
        int f=lca(h[i],st[top]);
        while (dep[f]<dep[st[top-]]) add_edge(st[top-],st[top]), top--;
        add_edge(f,st[top--]);
        if (f!=st[top]) st[++top]=f;
        st[++top]=h[i];
     }
     while (top>) add_edge(st[top-],st[top]), top--;
     dp_dfs();
     printf("%d\n",ans);
}
int main ()
{
    bin_init();
    int n, q, u, v;
    n=Scan();
    FO(i,,n) u=Scan(), v=Scan(), add_edge(u,v), add_edge(v,u);
    dfs(,);
    q=Scan(); mem(head,);
    while (q--) sol();
    return ;
}

E.Puzzle Lover(待填坑)