Codeforces Round #635 (Div. 2) （C. Linova and Kingdom）/（D. Xenia and Colorful Gems）

好久没打了，手很生，但是想法还有一些

写了四题后面的题没看，也不想补，毕竟现在比赛基本上也是娱乐

A. Ichihime and Triangle

水题，给出一个几个范围，我们能发现，只要两条长的边取相等，小的无论怎么取都能构成三角形

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int a,b,c,d;
        scanf("%d%d%d%d",&a,&b,&c,&d);
        printf("%d %d %d\n",b,c,c);
    }
}

B. Kana and Dragon Quest game

直接写，没啥说的

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int x,n,m;
        scanf("%d %d %d",&x,&m,&n);
        while(x>17&&m)
        {
            m--;
            x=x/2+10;
        }
        while(x>0&&n)
        {
            n--;
            x-=10;
        }
        if(x>0) printf("NO\n");
        else printf("YES\n");
    }
}

C. Linova and Kingdom

比较好的一道题，开始读错了题，后来发现是工业国派出大臣，想了一会，发现了策略

考虑取工业国，那么一定是从最长的链上的叶子节点开始取，对吧

取完最长链叶子节点 我们有两种选择，要么取次长链的叶子节点，要么取最长链的叶子节点的父节点

那么我们就可以推出取每个节点的权值了

权值=据跟节点距离-儿子数

很简单呀，我们假设取某个节点那么他的儿子们一定被取了，那么我们就损失了儿子节点数的高兴值，但是增加了该节点本身的高兴值

然后贪心取最优

#include<bits/stdc++.h>
using namespace std;
int child[200005];
int len[200005];
int vis[200005];
int num[200005];
vector<int>ve[200005];
int dfs(int x,int step)
{
    vis[x]=1;
    len[x]=step;
    int tmp=0;
    for(int i=0;i<ve[x].size();i++)
    {
        int v=ve[x][i];
        if(vis[v]==0)
        {
            tmp+=dfs(v,step+1);
        }
    }
    child[x]=tmp;
    return tmp+1;
}
int cmp(int p,int q)
{
    return p>q;
}
int main()
{
    int n,k;
    scanf("%d%d",&n,&k);
    for(int i=1;i<=n-1;i++)
    {
        int tmp1,tmp2;
        scanf("%d%d",&tmp1,&tmp2);
        ve[tmp1].push_back(tmp2);
        ve[tmp2].push_back(tmp1);
    }
    dfs(1,0);
    for(int i=1;i<=n;i++)
    {
        //printf("%d %d",len[i],child[i]);
        num[i]=len[i]-child[i];
    }
    sort(num+1,num+1+n,cmp);
    long long ans=0;
    for(int i=1;i<=k;i++)
    {
        ans+=num[i];
    }
    printf("%I64d\n",ans);
}

D. Xenia and Colorful Gems

比较明显的二分，

但是细节之处我也没考虑吧太严谨，但是过了

例如一个点左右两边的点跟它距离相等时，我随便取一个，然后分别枚举了三次

#include<bits/stdc++.h>
using namespace std;
int a[100005];
int b[100005];
int c[100005];
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int na,nb,nc;
        scanf("%d%d%d",&na,&nb,&nc);
        for(int i=1; i<=na; i++) scanf("%d",&a[i]);
        for(int i=1; i<=nb; i++) scanf("%d",&b[i]);
        for(int i=1; i<=nc; i++) scanf("%d",&c[i]);
        sort(a+1,a+1+na);
        sort(b+1,b+1+nb);
        sort(c+1,c+1+nc);
        long long numa,numb,numc;
        long long ans=3e18;
        for(int i=1; i<=na; i++)
        {
            int posb=lower_bound(b,b+1+nb,a[i])-b;
            int posc=lower_bound(c,c+1+nc,a[i])-c;
            if(posb==nb+1)
            {
                numb = b[nb];
            }
            else if(posb==1)
            {
                numb = b[1];
            }
            else
            {
                if(b[posb]-a[i]<a[i]-b[posb-1]) numb=b[posb];
                else numb = b[posb-1];
            }
            if(posc==nc+1)
            {
                numc = c[nc];
            }
            else if(posc==1)
            {
                numc = c[1];
            }
            else
            {
                if(c[posc]-a[i]<a[i]-c[posc-1]) numc=c[posc];
                else numc = c[posc-1];
            }
            numa= a[i];
            ans=min(ans,(numa-numb)*(numa-numb)+(numa-numc)*(numa-numc)+(numb-numc)*(numb-numc));
        }
        for(int i=1; i<=nb; i++)
        {
            int posa=lower_bound(a,a+1+na,b[i])-a;
            int posc=lower_bound(c,c+1+nc,b[i])-c;
            if(posa==na+1)
            {
                numa = a[na];
            }
            else if(posa==1)
            {
                numa = a[1];
            }
            else
            {
                if(a[posa]-b[i]<b[i]-a[posa-1]) numa=a[posa];
                else numa = a[posa-1];
            }
            if(posc==nc+1)
            {
                numc = c[nc];
            }
            else if(posc==1)
            {
                numc = c[1];
            }
            else
            {
                if(c[posc]-b[i]<b[i]-c[posc-1]) numc=c[posc];
                else numc = c[posc-1];
            }
            numb= b[i];
            ans=min(ans,(numa-numb)*(numa-numb)+(numa-numc)*(numa-numc)+(numb-numc)*(numb-numc));
        }

        for(int i=1; i<=nc; i++)
        {
            int posb=lower_bound(b,b+1+nb,c[i])-b;
            int posa=lower_bound(a,a+1+na,c[i])-a;
            if(posb==nb+1)
            {
                numb = b[nb];
            }
            else if(posb==1)
            {
                numb = b[1];
            }
            else
            {
                if(b[posb]-c[i]<c[i]-b[posb-1]) numb=b[posb];
                else numb = b[posb-1];
            }
            if(posa==na+1)
            {
                numa = a[na];
            }
            else if(posa==1)
            {
                numa = a[1];
            }
            else
            {
                if(a[posa]-c[i]<c[i]-a[posa-1]) numa=a[posa];
                else numa = a[posa-1];
            }
            numc= c[i];
            ans=min(ans,(numa-numb)*(numa-numb)+(numa-numc)*(numa-numc)+(numb-numc)*(numb-numc));
        }
        printf("%I64d\n",ans);
    }
}