cf #379div2

A.

题意：输入一串字符只含A和D，判断A和D的多少比较，

分析：直接计数

B.

题意：给出数字2,3,5,6的个数，用这些数组成256和32，要求最后组成的数的和最大

分析：贪心，优先组成256，然后组成32; n₂₅₆=min(k₂,k₅,k₆),n₃₂=min(k₃,k₂-n₂₅₆);

C.

题意：要求你制作出n瓶药水，初始每瓶药水要花费x的时间，另有两种魔法操作可以缩短制作时间，type1 ：将制作每一瓶药水的时间都缩短至ai的时间，但是要花费bi的魔法点数；type2：瞬间制作出ci瓶药水（相当这ci瓶药水没花时间），但是要花费di的魔法点数。初始你有s的魔法点数，type1有m种魔法，type2有k种魔法。要求出制作出n瓶药水的最短时间

（1 ≤ n ≤ 2·1e9, 1 ≤ m, k ≤ 2·1e5)

分析：1.首先，我们发现如果我们选择第一种type的第i个魔法和第二种type的第j个魔法，则我们准备所有的药水要花费 a_i*(n-c_j)的时间，我们要使这个值最小；

2.第二种类型魔法可以制作出的药水数及花费的魔法点数是非递减序列，考虑用二分；

3.直接循环一遍type1的魔法（a[i]数组），然后用剩下的魔法点数s1找到能使用的type2的魔法的最大值（二分）

4.注意边界，可能初始的魔法点数既不可能选择type1 也不能选择type2 ，此时答案直接是初始的x*n；

代码：

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

 #define maxn 200010
 #define ll long long
 #define fi first
 #define se second
 ll a[maxn],b[maxn],c[maxn],d[maxn];
 ll n,m,k,x,s;

 ll get(ll mon)
 {
     ll l=,r=k;
     while(l<r)
     {
         ll mid=(l+r+)/;
         if(d[mid]>mon)
             r=mid-;
         else
             l=mid;
     }
     return c[l];
 }
 int main()
 {

     cin>>n>>m>>k;
     cin>>x>>s;
     ll ans=n*x;
     a[]=x;  //type1没有选中的spell时注意初始化
     for(ll i=;i<=m;i++) cin>>a[i];
     for(ll i=;i<=m;i++) cin>>b[i];
     for(ll i=;i<=k;i++) cin>>c[i];
     for(ll i=;i<=k;i++) cin>>d[i];
     for(int i=;i<=m;i++) //i要从0开始，因为tyoe1可能也没有可以使用的pell
     {
         ll s1=s-b[i];
         //cout<<s1<<"  "<<get(s1)<<" "<<(n-get(s1))*a[i]<<endl;
         if(s1<)continue;
         ans=min(ans,(n-get(s1))*a[i]);
     }
     cout<<ans<<endl;
     return ;
 }

D.

题意：-1e9~1e9的棋盘，给出黑king的位置，和n个白棋的位置白棋只能是象，车，王后；问白棋是否能在一步之内攻击到黑king。

Bishop象：只能走对角线任意格但不能跳过障碍；

Rook车:只能走水平和垂直但不能跳过障碍；

Queen王后：可以走对角线和水平和垂直，也不能跳过障碍；

分析：以黑king为分析对象，一步之内要攻击到黑king只有上下左右及上左上右下左下右八个方向上离黑king最近的白棋（因为白棋都不能跳过挡道棋子），即可在输入时更新每个方向上离黑king最近的白棋，最后根据每种白棋能走的方向判断能否攻击到黑king。

代码：//自己容易手挫版

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

#define ll long long
#define fi first
#define se second
pair<ll,ll>p[];
int flag[];
char cr[];
ll xx;
ll yy;

int judge(char c,ll x,ll y)
{
    if(x==xx)
    {
        if(y<yy)
        {
            if(!flag[])
            {
                flag[]=;
                p[].se=y;p[].fi=xx;cr[]=c;
            }
            p[].se=max(p[].se,y);
            if(p[].se==y) cr[]=c;
        }
        else
        {
            if(!flag[])
            {
                flag[]=;
                p[].se=y;p[].fi=xx;cr[]=c;
            }
            p[].se=min(p[].se,y);
            if(p[].se==y) cr[]=c;
        }
    }
    else if(y==yy)
    {
        if(x<xx)
        {
            if(!flag[])
            {
                flag[]=;
                p[].fi=x;p[].se=yy;cr[]=c;
            }
            p[].fi=max(p[].fi,x);
            if(p[].fi==x) cr[]=c;
        }
        else
        {
            if(!flag[])
            {
                flag[]=;
                p[].fi=x;p[].se=yy;cr[]=c;
            }
            p[].fi=min(p[].fi,x);
            if(p[].fi==x) cr[]=c;
        }
    }
    else if(x+y==xx+yy)
    {
        if(x>xx&&y<yy)
        {
            if(!flag[])
            {
                flag[]=;
                p[].fi=x;p[].se=y;cr[]=c;
            }
            p[].fi=min(p[].fi,x);
            p[].se=max(p[].se,y);
            if(p[].fi==x) cr[]=c;
        }
        else
        {
            if(!flag[])
            {
                flag[]=;
                p[].fi=x;p[].se=y;cr[]=c;
            }
            p[].fi=max(p[].fi,x);
            p[].se=min(p[].se,y);
            if(p[].fi==x) cr[]=c;
        }
    }
    else if(x-y==xx-yy)
    {
        if(x<xx&&y<yy)
        {
            if(!flag[])
            {
                flag[]=;
                p[].fi=x;p[].se=y;cr[]=c;
            }
            p[].fi=max(p[].fi,x);
            p[].se=max(p[].se,y);
            if(p[].fi==x)cr[]=c;
        }
        else
        {
            if(!flag[])
            {
                flag[]=;
                p[].fi=x;p[].se=y;cr[]=c;
            }
            p[].fi=min(p[].fi,x);
            p[].se=min(p[].se,y);
            if(p[].fi==x) cr[]=c;
        }
    }
}

int main()
{
    int n;
    cin>>n;
    cin>>xx>>yy;
    ll x,y;
    char c;
    while(n--)
    {
        cin>>c>>x>>y;
        judge(c,x,y);
    }
    bool is=false;
    for(int i=;i<=;i++)
    {
        //cout<<p[i].fi<<" "<<p[i].se<<" "<<cr[i]<<endl;
        if(i%&&(cr[i]=='R'||cr[i]=='Q'))
            is=true;
        else if(i%==&&(cr[i]=='B'||cr[i]=='Q'))
            is=true;
    }
    if(is)
        cout<<"YES\n";
    else
        cout<<"NO\n";
    return ;
}

//出题author优美版

#include <cstdio>
#include <algorithm>

using namespace std;

inline char in_char()
{
    char c = '\0';
    while (c <= ' ')
        c = getchar();
    return c;
}

inline int in_int()
{
    int n;
    scanf("%d", &n);
    return n;
}

struct figurine
{
    char kind;
    int x, y;
};

int n;
int x0, y0;
figurine nearest[];

inline int dist(int x1, int y1, int x2, int y2)
{
    return max(abs(x1 - x2), abs(y1 - y2));
}

inline void upd_nearest(figurine& was, const figurine& cur)
{
    if (was.kind == '?' ||
        dist(x0, y0, cur.x, cur.y) < dist(x0, y0, was.x, was.y))
    was = cur;
}

inline int get_direction(const figurine& cur)
{
    // vertical
    if (cur.x == x0 && cur.y < y0) return ;
    if (cur.x == x0 && cur.y > y0) return ;
    // horizontal
    if (cur.y == y0 && cur.x < x0) return ;
    if (cur.y == y0 && cur.x > x0) return ;
    // diagonal 1
    if ((cur.y - y0) == (cur.x - x0) && cur.x < x0) return ;
    if ((cur.y - y0) == (cur.x - x0) && cur.x > x0) return ;
    // diagonal 2
    if ((cur.y - y0) == (x0 - cur.x) && cur.y < y0) return ;
    if ((cur.y - y0) == (x0 - cur.x) && cur.y > y0) return ;
    // the piece doesn't lie on any of the eight directions
    return -;
}

int main()
{
    n = in_int();
    x0 = in_int(); y0 = in_int();
    for (int i = ; i < ; i++)
        nearest[i].kind = '?';
    // read and update nearest
    for (int i = ; i < n; i++)
    {
        figurine cur;
        cur.kind = in_char(); cur.x = in_int(); cur.y = in_int();
        int dir = get_direction(cur);
        if (dir >= )
            upd_nearest(nearest[dir], cur);
    }
    bool ans = false;
    // check verticals and horizontals
    for (int i = ; i < ; i++)
        if (nearest[i].kind == 'R' || nearest[i].kind == 'Q')
            ans = true;
    // check diagonals
    for (int i = ; i < ; i++)
        if (nearest[i].kind == 'B' || nearest[i].kind == 'Q')
            ans = true;
    // output
    puts(ans ? "YES" : "NO");
    return ;
}

E.

待更新