Codeforces Round #190 (Div. 2) 解题报告

-----------------

A. Ciel and Dancing

n个男孩和m个女孩配对跳舞，每首歌有一对男女跳舞，要求配对男孩和女孩中至少有一个没有跳过舞。

求最多的能放的歌曲数并输出配对方案。

分析可知最多能放n+m-1首歌曲。

----

贪心，男孩1和所有的女孩跳舞。

女孩1和所有的男孩跳舞。

除去男孩1和女孩1重复的情况

#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;

int main()
{
    int n,m;
    int s;
    while (cin>>n>>m)
    {
        s=0;
        s=n+m-1;
        cout<<s<<endl;
        for (int i=1;i<=m;i++) cout<<"1 "<<i<<endl;
        for (int i=2;i<=n;i++) cout<<i<<" 1"<<endl;
    }
    return 0;
}

-----------------

B. Ciel and Flowers

有三种花：红R，绿G，蓝B。

四种花束方案：3红，3绿，3蓝，1红1绿1蓝。

求最大的花束数。。。

----

先考虑枚举第四种方案，再尽可能的组前三种花束。

实际上可以考虑贪心。只枚举第四种方案数从min(R,G,B)-1到min(R,G,B)。

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>

using namespace std;

int r,g,b;
int rr,gg,bb;
int ans;
int ans1;

int main()
{
    while (cin>>rr>>gg>>bb)
    {
        ans=0;
        r=rr;g=gg;b=bb;
        int tmp=min(r,min(g,b));
        for (int i=max(tmp-1,0); i<=tmp; i++)
        {
            r=rr;g=gg;b=bb;
            ans1=0;
            r-=i;g-=i;b-=i;
            ans1+=i;
            ans1+=r/3;ans1+=g/3;ans1+=b/3;
            ans=max(ans,ans1);
        }
        cout<<ans<<endl;
    }
    return 0;
}

-----------------

C. Ciel and Robot

有一个机器人位于(0,0)。有四种移动方案上下左右。

给定目标坐标|x|<=10^9，|y|<=10^9。

给定移动序列1<=S<=100。

机器人按照移动序列循环移动，问是否有可能移动到目标坐标。

----

设目标坐标为Q，点a[i]为Pi， 点a[i+n]为Pj。

首先按照序列移动两遍。

首先判断点Q是否在射线 Pi->Pj 上。

然后判断线段PiQ是不是PiPj的倍数。

(似乎有更简便的方法，不懂几何不会写)

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int direct[4][2]={ {0,1},{0,-1},{-1,0},{1,0} };//U, D, L, R
const long long MX=1e9;

struct POINT{
    long long x;
    long long y;
    POINT(long long _x=0,long long _y=0)
    {
        x=_x;
        y=_y;
    }
    void output()
    {
        cerr<<"p "<<x<<" "<<y<<endl;
    }
};

char s[111];
POINT a[222];
int ex,ey;
int n;

bool onSegment(POINT Pi,POINT Pj,POINT Q)
{
    if ( (Q.x-Pi.x)*(Pj.y-Pi.y)==(Pj.x-Pi.x)*(Q.y-Pi.y)&&
        min(Pi.x,Pj.x)<=Q.x&&Q.x<=max(Pi.x,Pj.x)&&
        min(Pi.y,Pj.y)<=Q.y&&Q.y<=max(Pi.y,Pj.y))
        return true;
    else
        return false;
}

int main()
{
    cin>>ex>>ey;
    cin>>(s+1);
    int n=strlen(s+1);
    POINT tmp;
    tmp.x=0;
    tmp.y=0;
    a[0]=tmp;
    for (int i=1;i<=n;i++)
    {
        a[i].x=a[i-1].x;
        a[i].y=a[i-1].y;
        if (s[i]=='U')
        {
            a[i].x+=direct[0][0];
            a[i].y+=direct[0][1];
        }
        if (s[i]=='D')
        {
            a[i].x+=direct[1][0];
            a[i].y+=direct[1][1];
        }
        if (s[i]=='L')
        {
            a[i].x+=direct[2][0];
            a[i].y+=direct[2][1];
        }
        if (s[i]=='R')
        {
            a[i].x+=direct[3][0];
            a[i].y+=direct[3][1];
        }
    }
    for (int i=n+1;i<=n+n;i++)
    {
        a[i].x=a[i-1].x;
        a[i].y=a[i-1].y;
        if (s[i-n]=='U')
        {
            a[i].x+=direct[0][0];
            a[i].y+=direct[0][1];
        }
        if (s[i-n]=='D')
        {
            a[i].x+=direct[1][0];
            a[i].y+=direct[1][1];
        }
        if (s[i-n]=='L')
        {
            a[i].x+=direct[2][0];
            a[i].y+=direct[2][1];
        }
        if (s[i-n]=='R')
        {
            a[i].x+=direct[3][0];
            a[i].y+=direct[3][1];
        }
    }

    //for (int i=1;i<=n;i++) cerr<<"ai="<<a[i].x<<" "<<a[i].y<<" ai+n="<<a[i+n].x<<" "<<a[i+n].y<<endl;


    bool flag=false;
    for (int i=0;i<=n;i++)
    {
        long long x,y,bit=MX;
        POINT Pi(a[i].x,a[i].y);
        if (a[i+n].x-a[i].x!=0) bit=min(bit,abs(MX/(a[i+n].x-a[i].x)));
        if (a[i+n].y-a[i].y!=0) bit=min(bit,abs(MX/(a[i+n].y-a[i].y)));
        x=(bit+1)*(a[i+n].x-a[i].x)+a[i].x;
        y=(bit+1)*(a[i+n].y-a[i].y)+a[i].y;
        POINT Pj(x,y);
        POINT Q(ex,ey);
        //Pi.output();
        //Pj.output();
        //Q.output();
        //cerr<<(Q.x-Pi.x)*(Pj.y-Pi.y)<<endl;
        //cerr<<(Pj.x-Pi.x)*(Q.y-Pi.y)<<endl;
        //cerr<<"----"<<endl;
        if ( onSegment(Pi,Pj,Q) )
        {
            if (((a[i+n].x-a[i].x==0)||(ex-a[i].x)%(a[i+n].x-a[i].x)==0)&&
                ((a[i+n].y-a[i].y==0)||(ey-a[i].y)%(a[i+n].y-a[i].y)==0))
            {
                flag=true;
                break;
            }
        }
    }
    if (flag) puts("Yes");
    else puts("No");
    return 0;
}

-----------------

D. Ciel and Duel

按照游戏王的规则，对方场上有n只通常怪兽，我方场上有m只通常怪兽。

给出对方n只怪兽的表示形式（ATK、DEF）与攻击力/守备力。

给出我方攻击表示的m只怪兽的攻击力。

求最大伤害。

----

贪心策略

首先对三个类型的怪兽（对手ATK怪兽、对手DEF怪兽、我方怪兽）排序。

①进行直接攻击的情况：

首先用最少的伤害击败对手所有的DEF怪兽。

然后判断是否能击败剩下的ATK怪兽。

最后统计直接攻击的伤害。

若不能成功直接攻击则该种情况的伤害置零。

②不进行直接攻击的情况：

只对攻击表示的怪兽进行攻击。

尽可能用攻击力最高的怪兽攻击对手攻击力最低的怪兽。(未证明)

两者方案的伤害取最大值。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;

const int maxn=111;

vector<int>atk;
vector<int>def;
vector<int>str;
vector<int>::iterator it;
bool v[maxn];
int n,m;
int ans1,ans2;
int main()
{
    while (cin>>n>>m)
    {
        ans1=ans2=0;
        memset(v,0,sizeof(v));
        atk.clear();
        def.clear();
        str.clear();
        for (int i=0;i<n;i++)
        {
            char s[4];
            int d;
            cin>>s>>d;
            if (!strcmp(s,"ATK")) atk.push_back(d);
            if (!strcmp(s,"DEF")) def.push_back(d);
        }
        for (int i=0;i<m;i++)
        {
            int d;
            cin>>d;
            str.push_back(d);
        }
        sort(atk.begin(),atk.end());
        sort(def.begin(),def.end());
        sort(str.begin(),str.end());
        //直接攻击
        int p=0;
        bool flag=false;
        for (int i=0;i<def.size();i++)
        {
            while (p<str.size()&&str[p]<=def[i]) p++;
            if (p>=str.size())
            {
                flag=true;
                break;
            }
            v[p]=true;
            p++;
        }
        p=0;
        for (int i=0;i<atk.size();i++)
        {
            while (p<str.size()&&(v[p]||str[p]<atk[i])) p++;
            if (p>=str.size())
            {
                flag=true;
                break;
            }
            v[p]=true;
            ans1+=str[p]-atk[i];
            p++;
        }
        for (int i=0;i<str.size();i++)
        {
            if (!v[i]) ans1+=str[i];
        }
        if (flag) ans1=0;
        //OTK
        p=str.size()-1;
        for (int i=0;i<atk.size();i++)
        {
            if (p>=0&&str[p]>=atk[i])
            {
                ans2+=str[p]-atk[i];
                p--;
            }
            else
            {
                break;
            }
        }
        cout<<max(ans1,ans2)<<endl;
    }
    return 0;
}

-----------------

E. Ciel the Commander

现在Fox Ciel成为了Tree Land的指挥官。

Tree Land，正如它的名字所说，有n个城市由n-1条无向道路连接，并且其中任意两个城市之间总是存在一条路径。

Fox Ciel需要在每个城市分配一个官员。每个官员都有一个等级---一个’A’到’Z’之间的字母。所以会有26个不同的等级，’A’是最高的，’Z’是最低的。

每个等级都有足够的官员。但是必须遵守一个特殊的规则：

——如果x和y是两个不同的城市并且他们的官员拥有相同的等级，那么x和y之间的简单路径中一定存在一个城市z有更高等级的官员。

这个规则可以保证两个同等级官员之间的通信会由较高等级的官员监控。

帮助Ciel制定一个有效的计划，如果这是不可能的，输出"Impossible!"。

Input

       第一行包含一个整数n (2 ≤ n ≤ 105)---Tree Land的城市数。

接下来的n-1行包含两个整数a和b (1 ≤ a, b ≤ n, a ≠ b)---表示a和b之间有一条无向的道路。城市的编号从1到n。

       保证题目给出的图是一棵树。

Output

       如果存在一个有效的计划，在一行里输出由空格分隔的n个字符，第i个字符表示第i个城市里官员的等级。

       否则输出"Impossible!"。

----

这是一个树上的问题，对于这种问题，通常有两种方法：自上而下或自下而上。对于每种方法有一种解决方案。

up-down construction

假设我们在点x分配一个等级为A的官员。对以x为根的两个子树T1、T2来说，不能有任何一个无效的路径通过它们，因为它们被节点x封锁。

（很显然，我们不能分配两个等级为A的官员）

因此我们可以独立的处理这些子树。唯一不同的是，我们不可以再使用等级A。

然后，问题是：x是哪个节点?如果所有的子树都尽肯能的小更好。

如果你知道什么是树的中心，那么你就可以快速找到x，如果x是一颗树的中心，那么子树不会超过原树的一半。

所以我们只需要log2(n)个等级，26个字母足够了。

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>

using namespace std;

const int maxn=311111;

struct TREENODE{
    bool visit;
    int rank;
}tree[maxn];
int sz[maxn];
struct EDGENODE{
    int to;
    int next;
}edges[maxn];
int head[maxn];
int edge;
void init_edge(){
    memset(head,-1,sizeof(head));
    edge=0;
}
void addedge(int u,int v){
    edges[edge].to=v,edges[edge].next=head[u],head[u]=edge++;
    edges[edge].to=u,edges[edge].next=head[v],head[v]=edge++;
}

void dfs(int u,int pa);
int find_center(int x);
void solve(int x,int rk);

int n;

void dfs(int u,int pa)
{
    sz[u]=1;
    for (int i=head[u];i!=-1;i=edges[i].next)
    {
        int v=edges[i].to;
        if (v!=pa&&!tree[v].visit)
        {
            dfs(v,u);
            sz[u]+=sz[v];
        }
    }
}

int find_center(int x)
{
    int p=0;
    dfs(x,p);
    int cap=sz[x]/2;
    bool found=true;
    while (found)
    {
        found=false;
        for (int i=head[x];i!=-1;i=edges[i].next)
        {
            int y=edges[i].to;
            if (!tree[y].visit&&y!=p&&sz[y]>cap)
            {
                found=true;
                p=x;
                x=y;
                break;
            }
        }
    }
    return x;
}

void solve(int x,int rk)
{
    int u=find_center(x);
    tree[u].rank=rk;
    tree[u].visit=true;
    for (int i=head[u];i!=-1;i=edges[i].next)
    {
        int v=edges[i].to;
        if (!tree[v].visit) solve(v,rk+1);
    }
}

int main()
{
    while (cin>>n)
    {
        init_edge();
        memset(tree,0,sizeof(tree));
        for (int i=0; i<n-1; i++)
        {
            int a,b;
            cin>>a>>b;
            addedge(a,b);
        }
        solve(1,0);
        for (int i=1; i<=n; i++)
        {
            cout<<char(tree[i].rank+'A')<<" ";
        }
        cout<<endl;
    }
    return 0;
}

down-up construction

假设我们选择1为根节点并且把树当做有向树。

我们有一些根节点为T1,T2…..,Tk的子树，并且他们已经指派了官员，我们需要指派一个官员到点x将它们连接。

那么，正常的想法是，选择一个最尽可能最低的等级。

x的等级应该满足：

如果Ti中有一个点等级为t并且Tj中有一个点为t（i!=j），那么x的等级必须高于t。（否则它们之间的路径将是无效的）

如果Ti中有一个点等级为t，那么x的等级不能为t。

因此我们可以采用这个规则选择尽可能低的等级。

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>

using namespace std;

const int maxn=311111;

struct EDGENODE{
    int to;
    int next;
}edges[maxn];

int head[maxn];
int edge;

void init_edge()
{
    memset(head,-1,sizeof(head));
    edge=0;
}

void addedge(int u,int v)
{
    edges[edge].to=v,edges[edge].next=head[u],head[u]=edge++;
    edges[edge].to=u,edges[edge].next=head[v],head[v]=edge++;
}

int n;

struct TREENODE{
    int stu;
    int rank;
}tree[maxn];

bool flag;

void dfs(int u,int pa)
{
    int stu=0;
    int dub=0;
    for (int i=head[u];i!=-1;i=edges[i].next)
    {
        int v=edges[i].to;
        if (v==pa) continue;
        dfs(v,u);
        dub=max(dub, stu&tree[v].stu);
        stu|=tree[v].stu;
    }
    int &p=tree[u].stu;
    p=1;
    while (p<=dub||(p&stu)) p<<=1;
    for (int i=(p<<1);i<(1<<26);i<<=1) if (i&stu) p|=i;
    for(int i=0;i<26;i++)
    {
        if((1<<i)&tree[u].stu)
        {
            tree[u].rank=26-i-1;
            if (tree[u].rank<0||tree[u].rank>=26) flag=true;
            break;
        }
    }
}

int main()
{
    while (cin>>n)
    {
        init_edge();
        memset(tree,0,sizeof(tree));
        flag=false;
        for (int i=0;i<n-1;i++)
        {
            int a,b;
            cin>>a>>b;
            addedge(a,b);
        }
        dfs(1,0);
        if (flag) cout<<"Impossible!";
        else
        for (int i=1;i<=n;i++)
        {
            cout<<char(tree[i].rank+'A')<<" ";
        }
        cout<<endl;
    }
    return 0;
}

-----------------