• cf #379div2


    A.

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

    分析:直接计数

    B.

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

    分析:贪心,优先组成256,然后组成32; n256=min(k2,k5,k6),n32=min(k3,k2-n256);

    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个魔法,则我们准备所有的药水要花费 ai*(n-cj)的时间,我们要使这个值最小;

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

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

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

    代码:

     1 #include<iostream>
     2 #include<algorithm>
     3 #include<cstdio>
     4 using namespace std;
     5 
     6 #define maxn 200010
     7 #define ll long long
     8 #define fi first
     9 #define se second
    10 ll a[maxn],b[maxn],c[maxn],d[maxn];
    11 ll n,m,k,x,s;
    12 
    13 ll get(ll mon)
    14 {
    15     ll l=0,r=k;
    16     while(l<r)
    17     {
    18         ll mid=(l+r+1)/2;
    19         if(d[mid]>mon)
    20             r=mid-1;
    21         else
    22             l=mid;
    23     }
    24     return c[l];
    25 }
    26 int main()
    27 {
    28 
    29     cin>>n>>m>>k;
    30     cin>>x>>s;
    31     ll ans=n*x;
    32     a[0]=x;  //type1没有选中的spell时注意初始化
    33     for(ll i=1;i<=m;i++) cin>>a[i];
    34     for(ll i=1;i<=m;i++) cin>>b[i];
    35     for(ll i=1;i<=k;i++) cin>>c[i];
    36     for(ll i=1;i<=k;i++) cin>>d[i];
    37     for(int i=0;i<=m;i++) //i要从0开始,因为tyoe1可能也没有可以使用的pell
    38     {
    39         ll s1=s-b[i];
    40         //cout<<s1<<"  "<<get(s1)<<" "<<(n-get(s1))*a[i]<<endl;
    41         if(s1<0)continue;
    42         ans=min(ans,(n-get(s1))*a[i]);
    43     }
    44     cout<<ans<<endl;
    45     return 0;
    46 }
    View Code

    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[10];
    int flag[10];
    char cr[10];
    ll xx;
    ll yy;
    
    int judge(char c,ll x,ll y)
    {
        if(x==xx)
        {
            if(y<yy)
            {
                if(!flag[1])
                {
                    flag[1]=1;
                    p[1].se=y;p[1].fi=xx;cr[1]=c;
                }
                p[1].se=max(p[1].se,y);
                if(p[1].se==y) cr[1]=c;
            }
            else
            {
                if(!flag[5])
                {
                    flag[5]=1;
                    p[5].se=y;p[5].fi=xx;cr[5]=c;
                }
                p[5].se=min(p[5].se,y);
                if(p[5].se==y) cr[5]=c;
            }
        }
        else if(y==yy)
        {
            if(x<xx)
            {
                if(!flag[3])
                {
                    flag[3]=1;
                    p[3].fi=x;p[3].se=yy;cr[3]=c;
                }
                p[3].fi=max(p[3].fi,x);
                if(p[3].fi==x) cr[3]=c;
            }
            else
            {
                if(!flag[7])
                {
                    flag[7]=1;
                    p[7].fi=x;p[7].se=yy;cr[7]=c;
                }
                p[7].fi=min(p[7].fi,x);
                if(p[7].fi==x) cr[7]=c;
            }
        }
        else if(x+y==xx+yy)
        {
            if(x>xx&&y<yy)
            {
                if(!flag[8])
                {
                    flag[8]=1;
                    p[8].fi=x;p[8].se=y;cr[8]=c;
                }
                p[8].fi=min(p[8].fi,x);
                p[8].se=max(p[8].se,y);
                if(p[8].fi==x) cr[8]=c;
            }
            else
            {
                if(!flag[4])
                {
                    flag[4]=1;
                    p[4].fi=x;p[4].se=y;cr[4]=c;
                }
                p[4].fi=max(p[4].fi,x);
                p[4].se=min(p[4].se,y);
                if(p[4].fi==x) cr[4]=c;
            }
        }
        else if(x-y==xx-yy)
        {
            if(x<xx&&y<yy)
            {
                if(!flag[2])
                {
                    flag[2]=1;
                    p[2].fi=x;p[2].se=y;cr[2]=c;
                }
                p[2].fi=max(p[2].fi,x);
                p[2].se=max(p[2].se,y);
                if(p[2].fi==x)cr[2]=c;
            }
            else
            {
                if(!flag[6])
                {
                    flag[6]=1;
                    p[6].fi=x;p[6].se=y;cr[6]=c;
                }
                p[6].fi=min(p[6].fi,x);
                p[6].se=min(p[6].se,y);
                if(p[6].fi==x) cr[6]=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=1;i<=8;i++)
        {
            //cout<<p[i].fi<<" "<<p[i].se<<" "<<cr[i]<<endl;
            if(i%2&&(cr[i]=='R'||cr[i]=='Q'))
                is=true;
            else if(i%2==0&&(cr[i]=='B'||cr[i]=='Q'))
                is=true;
        }
        if(is)
            cout<<"YES
    ";
        else
            cout<<"NO
    ";
        return 0;
    }
    View Code

    //出题author优美版

    #include <cstdio>
    #include <algorithm>
    
    using namespace std;
    
    inline char in_char()
    {
        char c = '';
        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[8];
    
    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 0;
        if (cur.x == x0 && cur.y > y0) return 1;
        // horizontal
        if (cur.y == y0 && cur.x < x0) return 2;
        if (cur.y == y0 && cur.x > x0) return 3;
        // diagonal 1
        if ((cur.y - y0) == (cur.x - x0) && cur.x < x0) return 4;
        if ((cur.y - y0) == (cur.x - x0) && cur.x > x0) return 5;
        // diagonal 2
        if ((cur.y - y0) == (x0 - cur.x) && cur.y < y0) return 6;
        if ((cur.y - y0) == (x0 - cur.x) && cur.y > y0) return 7;
        // the piece doesn't lie on any of the eight directions
        return -1;
    }
    
    int main()
    {
        n = in_int();
        x0 = in_int(); y0 = in_int();
        for (int i = 0; i < 8; i++)
            nearest[i].kind = '?';
        // read and update nearest
        for (int i = 0; i < n; i++)
        {
            figurine cur;
            cur.kind = in_char(); cur.x = in_int(); cur.y = in_int();
            int dir = get_direction(cur);
            if (dir >= 0)
                upd_nearest(nearest[dir], cur);
        }
        bool ans = false;
        // check verticals and horizontals
        for (int i = 0; i < 4; i++)
            if (nearest[i].kind == 'R' || nearest[i].kind == 'Q')
                ans = true;
        // check diagonals
        for (int i = 4; i < 8; i++)
            if (nearest[i].kind == 'B' || nearest[i].kind == 'Q')
                ans = true;
        // output
        puts(ans ? "YES" : "NO");
        return 0;
    }
    View Code

    E. 

    待更新

  • 相关阅读:
    智能实验室-通用网络请求(Webio) 2.5.0.180
    智能实验室-YouTube资源下载(YouTubio) 1.2.0.40
    智能实验室-批量解压(Extractio) 1.5.0.10
    智能实验室-全能优化(Guardio) 3.9.0.555
    智能实验室通用网络请求(Webio) 1.1.0.81 正式发布第一版
    智能安全实验室-全能优化(Guardio) 3.9.0.541:批量粉碎文件
    智能实验室-全能优化(Guardio) 4.0.0.600 beta 1
    快速浏览Silverlight3 Beta: 在多个Silverlight应用间传递信息
    快速浏览Silverlight3 Beta:当HLSL遇上Silverlight
    简读clubof网站源码之后的思考
  • 原文地址:https://www.cnblogs.com/tristatl/p/6081892.html
Copyright © 2020-2023  润新知