Codeforces Round #406 (Div. 2) ABCDE

最新推荐文章于 2021-10-27 12:54:30 发布
最新推荐文章于 2021-10-27 12:54:30 发布
阅读量194 收藏
点赞数
分类专栏： 主席树 水题 贪心 模板 线段树 最短路
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/overload1997/article/details/69937349
版权
模板 同时被 3 个专栏收录
21 篇文章 0 订阅
订阅专栏
线段树
16 篇文章 0 订阅
订阅专栏
水题
9 篇文章 0 订阅
订阅专栏

题目链接

大都是经典的套路题，下面我没做太多详细的叙述，不懂的留言就可以。

A:暴力跑一遍就可以了

#include<bits/stdc++.h>
using namespace std;
const int maxn=1e4+10;
int neg[maxn],pos[maxn];
int main()
{
    int n,k,t;
    while(cin>>n>>k)
    {
        bool ans=true;
        memset(neg,0,sizeof(neg));
        memset(pos,0,sizeof(pos));
        for(int m=1;m<=k;m++)
        {
            bool flag=false;
            cin>>n;
            while(n--)
            {
                cin>>t;
                if(t<0)
                {
                    if(pos[-t]==m) flag=true;
                    else neg[-t]=m;
                }
                else if(neg[t]==m) flag=true;
                else pos[t]=m;
            }
            if(!flag) ans=false;
        }
        if(!ans) puts("YES");
        else puts("NO");
    }
}

B: 水题，每一行如果出现x，就必须有-x，bool数组判一下就过了。 

#include<bits/stdc++.h>
using namespace std;
const int maxn=1e4+10;
int neg[maxn],pos[maxn];
int main()
{
    int n,k,t;
    while(cin>>n>>k)
    {
        bool ans=true;
        memset(neg,0,sizeof(neg));
        memset(pos,0,sizeof(pos));
        for(int m=1;m<=k;m++)
        {
            bool flag=false;
            cin>>n;
            while(n--)
            {
                cin>>t;
                if(t<0)
                {
                    if(pos[-t]==m) flag=true;
                    else neg[-t]=m;
                }
                else if(neg[t]==m) flag=true;
                else pos[t]=m;
            }
            if(!flag) ans=false;
        }
        if(!ans) puts("YES");
        else puts("NO");
    }
}

C: 简单的博弈，广搜一下，把能确定胜负的点放进队列，最后不能确定胜负的就是平局 
#include<bits/stdc++.h>
using namespace std;
struct Node
{
    int p;
    bool ifwin;
    bool flag;
    Node(int _p=0,bool _ifwin=0,bool _flag=0):p(_p),ifwin(_ifwin),flag(_flag){}
};
const int maxn=1e4+10;
int a,b;
int astep[maxn],bstep[maxn];
int apd[maxn],bpd[maxn];
int acnt[maxn],bcnt[maxn];
int main()
{
    int n,step;
    while(~scanf("%d",&n))
    {
        memset(acnt,0,sizeof(acnt));
        memset(bcnt,0,sizeof(bcnt));
        memset(apd,-1,sizeof(apd));
        memset(bpd,-1,sizeof(bpd));
        scanf("%d",&a);
        for(int i=0;i<a;i++) scanf("%d",&step),astep[i]=step;
        scanf("%d",&b);
        for(int i=0;i<b;i++) scanf("%d",&step),bstep[i]=step;
        queue<Node>Q;
        apd[0]=bpd[0]=0;
        Q.push(Node(0,0,1));
        Q.push(Node(0,0,0));
        while(!Q.empty())
        {
            Node head=Q.front();
            Q.pop();
            if(head.flag)
            {
                for(int i=0;i<b;i++)
                {
                    int lst=((head.p-bstep[i])%n+n)%n;
                    if(~bpd[lst]) continue;
                    if(!head.ifwin)
                    {
                        bpd[lst]=1;
                        Q.push(Node(lst,1,!head.flag));
                        continue;
                    }
                    else bcnt[lst]++;
                    if(bcnt[lst]==b)
                    {
                        bpd[lst]=0;
                        Q.push(Node(lst,0,!head.flag));
                    }
                }
            }
            else
            {
                for(int i=0;i<a;i++)
                {
                    int lst=((head.p-astep[i])%n+n)%n;
                    if(~apd[lst]) continue;
                    if(!head.ifwin)
                    {
                        apd[lst]=1;
                        Q.push(Node(lst,1,!head.flag));
                        continue;
                    }
                    else acnt[lst]++;
                    if(acnt[lst]==a)
                    {
                        apd[lst]=0;
                        Q.push(Node(lst,0,!head.flag));
                    }
                }
            }
        }
        for(int i=1;i<n;i++)
        {
            if(i>1) printf(" ");
            if(apd[i]==1) printf("Win");
            else if(apd[i]==0) printf("Lose");
            else printf("Loop");
        }
        printf("\n");
        for(int i=1;i<n;i++)
        {
            if(i>1) printf(" ");
            if(bpd[i]==1) printf("Win");
            else if(bpd[i]==0) printf("Lose");
            else printf("Loop");
        }
        printf("\n");
    }
}

D:这个题一开始我也没思路，然后在一Dalao的指点下才知道线段树优化建边这东西，看了一下，然后就过了。不过第一次写，代码写的好SB。

#include<bits/stdc++.h>
using namespace std;
const int maxn=3e5+10;
typedef long long LL;
const LL INF=1e17+10;
bool book[maxn<<4];
LL dis[maxn<<4];
int head[maxn<<2],tot,n,q,s,id,vis1[maxn<<1],vis2[maxn<<1];
struct Node
{
    int u,v,w,next;
    Node(int _u=0,int _v=0,int _w=0,int _next=0):u(_u),v(_v),w(_w),next(_next){}
}edges[maxn<<4];
struct node
{
    int v;
    LL d;
    node(int _v=0,LL _d=0):v(_v),d(_d){}
    bool operator < (const node& x)const
    {
        return d>x.d;
    }
};
void addedge(int u,int v,int w)
{
    //printf("addedge-> u:%d v:%d w:%d\n",u,v,w);
    edges[tot]=Node(u,v,w,head[u]);
    head[u]=tot++;
}
void buildtree1(int rt,int l,int r)//edges links from up to down which weight are 0
{
    if(vis1[rt]==0) vis1[rt]=++id;
    if(l==r)
    {
        addedge(vis1[rt],l,0);
        return;
    }
    int mid=(l+r)>>1,lson=rt<<1,rson=rt<<1|1;
    buildtree1(lson,l,mid);
    buildtree1(rson,mid+1,r);
    addedge(vis1[rt],vis1[lson],0);
    addedge(vis1[rt],vis1[rson],0);
}
void buildtree2(int rt,int l,int r)
{
    if(vis2[rt]==0) vis2[rt]=++id;
    if(l==r)
    {
        addedge(l,vis2[rt],0);
        return;
    }
    int mid=(l+r)>>1,lson=rt<<1,rson=rt<<1|1;
    buildtree2(lson,l,mid);
    buildtree2(rson,mid+1,r);
    addedge(vis2[lson],vis2[rt],0);//down to up - weight 0
    addedge(vis2[rson],vis2[rt],0);//down to up - weight 0
}
void addedge2(int u,int rt,int l,int r,int ql,int qr,int w)
{
    if(l>qr||r<ql) return;
    if(ql<=l&&r<=qr)
    {
        addedge(vis2[rt],u,w);
        return;
    }
    int mid=(l+r)>>1,lson=rt<<1,rson=rt<<1|1;
    addedge2(u,lson,l,mid,ql,qr,w);
    addedge2(u,rson,mid+1,r,ql,qr,w);
}
void addedge1(int u,int rt,int l,int r,int ql,int qr,int w)
{
    if(l>qr||r<ql) return;
    if(ql<=l&&r<=qr)
    {
        //cout<<1<<endl;
        //cout<<rt<<" "<<l<<" "<<r<<endl;
        addedge(u,vis1[rt],w);
        return;
    }
    int mid=(l+r)>>1,lson=rt<<1,rson=rt<<1|1;
    addedge1(u,lson,l,mid,ql,qr,w);
    addedge1(u,rson,mid+1,r,ql,qr,w);
}
void init()
{
    id=n;
    tot=0;
    memset(vis1,0,sizeof(vis1));
    memset(vis2,0,sizeof(vis2));
    memset(book,false,sizeof(book));
    memset(head,-1,sizeof(head));
    buildtree1(1,1,n);
    buildtree2(1,1,n);
}
void dijkstra()
{
    priority_queue<node>Q;
    for(int i=0;i<=9*n;i++)
    {
        //addedge(i,i,0);
        dis[i]=INF;
    }
    dis[s]=0;
    Q.push(node(s,0));
    while(!Q.empty())
    {
        node a=Q.top();
        Q.pop();
        int u=a.v;
        if(book[u]) continue;
        book[u]=true;
        //cout<<"u:"<<u<<endl;
        for(int i=head[u];~i;i=edges[i].next)
        {
            int v=edges[i].v,w=edges[i].w;
            //cout<<"v:"<<v<<" w:"<<w<<endl;
            if(dis[u]+w<dis[v])
            {
                dis[v]=dis[u]+w;
                if(!book[v]) Q.push(node(v,dis[v]));
            }
        }
    }
    for(int i=1;i<=n;i++)
    {
        if(dis[i]==INF) dis[i]=-1;
        if(i==1) cout<<dis[i];
        else cout<<" "<<dis[i];
    }
    puts("");
}
int main()
{
    int op,u,v,w,l,r;
    while(~scanf("%d%d%d",&n,&q,&s))
    {
        init();
        while(q--)
        {
            scanf("%d",&op);
            if(op==1)
            {
                scanf("%d%d%d",&u,&v,&w);
                addedge(u,v,w);
                // u -> f1(v,v)
            }
            else if(op==2)
            {
                scanf("%d%d%d%d",&u,&l,&r,&w);
                addedge1(u,1,1,n,l,r,w);
                // u -> f1(l,r)
            }
            else
            {
                scanf("%d%d%d%d",&u,&l,&r,&w);
                addedge2(u,1,1,n,l,r,w);
                // f2(l,r) -> u
            }
        }
        dijkstra();
    }
}

E:容易想到贪心，又因为涉及到区间不同数的个数很容易就想到主席树+二分，这样是O（n(logn)^3） 没试过（也许就过了呢），常见优化成主席树上的二分就是O(n(logn)^2)。为什么E题感觉比CD还水... 

#include<bits/stdc++.h>
using namespace std;
const int maxn=1e5+10;
int n,tot,c[maxn*100],lson[maxn*100],rson[maxn*100],T[maxn],a[maxn];
map<int,int>mp;
void init()
{
    tot=0;
    mp.clear();
}
int buildtree(int l,int r)
{
    int root=tot++;
    c[root]=0;
    if(l!=r)
    {
        int mid=(l+r)>>1;
        lson[root]=buildtree(l,mid);
        rson[root]=buildtree(mid+1,r);
    }
    return root;
}
int update(int root,int pos,int val)
{
    int newroot=tot++,tmp=newroot;
    int l=1,r=n;
    c[newroot]=c[root]+val;
    while(l<r)
    {
        int mid=(l+r)>>1;
        if(pos<=mid)
        {
            rson[newroot]=rson[root],lson[newroot]=tot++;
            newroot=lson[newroot],root=lson[root];
            r=mid;
        }
        else
        {
            lson[newroot]=lson[root],rson[newroot]=tot++;
            newroot=rson[newroot],root=rson[root];
            l=mid+1;
        }
        c[newroot]=c[root]+val;
    }
    return tmp;
}

void updatetree()
{
    T[n+1]=buildtree(1,n);
    for(int i=n;i>=1;i--)
    {
        if(mp.find(a[i])==mp.end()) T[i]=update(T[i+1],i,1);
        else
        {
            int tmp=update(T[i+1],mp[a[i]],-1);
            T[i]=update(tmp,i,1);
        }
        mp[a[i]]=i;
    }
}
int query(int root,int l,int r,int val)
{
	if(c[root]<=val) return r;
	if(l==r) return l-1;
	int mid=(l+r)>>1;
    if (c[lson[root]]<=val) return query(rson[root],mid+1,r,val-c[lson[root]]);  
    else return query(lson[root],l,mid,val);  
}
int main()
{
    while(~scanf("%d",&n))
    {
        init();
        for(int i=1;i<=n;i++) scanf("%d",&a[i]);
        updatetree();
        for(int k=1;k<=n;k++)
        {
            int tk=1,ans=0,p;
            while(tk<=n)
            {
               int lst=query(T[tk],1,n,k);
               tk=lst+1;
               ans++;
            }
            if(k==1) printf("%d",ans);
            else printf(" %d",ans);
        }
        puts("");
    }
}


overload1997
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Codeforces Round #723 (Div. 2).md
10-13
Codeforces Round #723 (Div. 2).md
Codeforces Round #722 (Div. 2) ABCDE题解
quinn18的博客
05-25 450
目录A - Eshag Loves Big ArraysB - Sifid and Strange SubsequencesC - Parsa's Humongous Tree A - Eshag Loves Big Arrays 题意： 就是 总数−-−最小值的个数 #include<bits/stdc++.h> #define ll long long using namespace std; const int N = 105; int t, n, m, a[N]; int main..
Codeforces Round #697 (Div. 3) ABCDE 题解
待到山花烂漫时
01-26 251
=>我的博客园传送门，阅读更方便<= 久违的cf服务器爆炸场 A. Odd Divisor 思路：任何一个数都可以写成n=k2m，其中k是一个奇数n = k2^m，其中k是一个奇数n=k2m，其中k是一个奇数，若k=1，那么n就一定是一个2的幂。 view code #include<iostream> #include<string> #include<algorithm> #include<cstdio> #include<cstrin
Codeforces Round #674 (Div. 3) ABCDE
qq_51376774的博客
10-27 198
学长给的翻译就是好哇！！！通俗易懂！！！嘻嘻嘻懒得自己翻了。 A .Floor Number 题目大意：今天是yyj要去约会的日子，为了显示出他的帅气，他决定穿着编号为n的衣服出门，可是他忘了自己的衣服放在哪里了，yyj家是一栋可以无限增长的高楼，每层都有他的衣柜，除了第一层有两个衣柜，其他每层均有x个衣柜，且衣柜的编号依次递增，yyj的每一件衣服都是独特的，所以他的每一个衣柜中只会放一件衣服，请你帮助yyj找到他的衣服在哪一层 输入的第一行包含一个整数t(1≤t≤1000)——测试用例的数量。
Codeforces Round #485 (Div. 2) ABCDE
lajiyuan的博客
05-30 302
A题.Infinity Gauntlet A. Infinity Gauntlet 题意为求6个字符串中没出现的字符串，随意写吧 A题代码 #include&amp;amp;lt;iostream&amp;amp;gt; #include&amp;amp;lt;algorithm&amp;amp;gt; #include&amp;amp;lt;set&amp;amp;gt; #include&amp;amp;lt;string.h&am
Codeforces Round #643 (Div. 2) ABCDE题解
放荡者的茶会
05-17 1228
如果有什么讲的不清楚的欢迎留言私信交流~ 文章目录A. Sequence with Digits（思维）B. Young Explorers（贪心）C. Count Triangles （思维）D. Game With ArrayE. Restorer Distance（三分） A. Sequence with Digits（思维） 题意： 给定一个数x， 每次变化是 x = x + 最高数位 * 最低数位，求出k-1次变化后的值。 思路： 最大值只要初始不是0那么就不会是0，而最小值一直取min，最后肯定
Codeforces Round #630 (Div. 2) D. Walk on Matrix（构造）
01-03
上面代码跑出来的dp[n][m]是0，然后从（1，1）（1，2）（2，2）（2，3）这样的相与值是k (看懂ans+k是啥应该就懂了) 代码： int main() { std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0); int ans=(1&...
Codeforces Round #627 (Div. 3) B. Yet Another Palindrome Problem
01-03
就是把所有相等的数放到一个vector里，如果他出现大于2次，看最远的间距是否大于2即可，找到一个就可以 代码： #include #include #include #include #include #include #include #include #include #include #...
Codeforces Round #627 (Div. 3) C. Frog Jumps（思维）
01-20
传送门 题意： 开始位置在0，问能否跳到n+1位置 每步只能跳d 在1——n每个位置有方向，L,R，求d的最小值 思路： 只用找相邻两个R之间的最大值即可 代码： #include #include ...typedef long long l
Codeforces Round #629 (Div. 3) B. K-th Beautiful String
01-03
长度为n的字符串包含n−2n−2n−2个aaa和222个bbb，求按照字典序排列输出第kkk个字符串 解题思路 第一个bbb在倒数第二位有1个字符串，在倒数第三位有2个字符串…在倒数第nnn位时有n−1n-1n−1个字符串 可以根据第一...
【模板】斯坦纳树
overload1997
03-16 1030
又是图论里的一个可怕的数据结构。。 【斯坦纳树的定义】 给定个无向图和图上的一些点组成的点集，那么能使这些点集连通的该图的子树就是该图对于该点集的一颗斯坦纳树。 那么最小斯坦纳树就是所有斯坦纳树中边权值和最小的一颗。 其实就是最小生成树问题的一个衍伸，当这个点集包含图中所有的点的时候那么问题便转换为最小生成树。 【斯坦纳树的求法】 用dp来求就行了。具体的dp写法也是参考了这个博客才知
2016多校联赛4E (hdu5768) Lucky7
overload1997
07-28 903
Lucky7 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 318    Accepted Submission(s): 127 Problem Description When ?? was born, sev
POJ2135 Farm Tour（最小费用最大流裸题）
overload1997
10-03 852
Source Code #include #include #include #include #include #include using namespace std; const int MAXN = 100000; const int MAXM = 100000; const int INF = 1999999999; struct Edge { int to,next,cap,flow
SW算法求全局最小割
overload1997
08-07 578
//O(n^3)实现 #include using namespace std; #define sfi(a) scanf("%d",&a) #define sfd(a) scanf("%lf",&a) #define sfl(a) scanf("%lld",&a) #define sfs(a) scanf("%s",a) #define rep(i,a,b) for(int i=int(
求大组合数取模的模板（lucas定理）
overload1997
08-05 543
LL fac[N]; void init() {     int i;     fac[0] =1;     for(i =1; i         fac[i] = fac[i-1]*i%p; } LL pow(LL a, LL b) {     LL tmp = a % p, ans =1;     while(b)     {         if(b &1)
c++的输入优化
overload1997
08-15 532
入队快1年了，看过各种各样的博客，经常看到有人在输入的时候弄得很麻烦，今天我算是弄懂了原来这是优化，getchar的输入速度比scanf要快所以有大量输入数据的时候，想要节省时间，优化输入是个不错的做法。下面给模板 const int read() { char ch = getchar(); while (ch'9') ch = getchar(); i
莫比乌斯反演模板
overload1997
05-07 508
void getmu() { int tot=0; mu[1]=1; for(int i=2;imaxn;i++) { if(!vis[i]) { prime[++tot]=i; mu[i]=-1; } for(int j=1;prime[j]*imaxn;j++) { vis[prime[j]*i]=1; if(i%prime[j]==0)
边双连通分量模板
overload1997
08-07 489
#include #define MAXN 10005 using namespace std; struct Tarjan { struct edge { int u,v; edge(int uu=0,int vv=0):u(uu),v(vv){} }; int n; //µãµÄ¸öÊý vector e[MAXN]; //ͼ int DFN[MAXN
51nod1228 序列求和 （伯努利数）
overload1997
10-05 431
1228 序列求和 题目来源： HackerRank 基准时间限制：3 秒 空间限制：131072 KB 分值: 160 难度：6级算法题  收藏  关注 T(n) = n^k，S(n) = T(1) + T(2) + ...... T(n)。给出n和k，求S(n)。 例如k = 2，n = 5，S(n) = 1^2 + 2^2 +
codeforces round #772 (div. 2)
最新发布
03-16
好的，Codeforces Round #772 (Div. 2) 是一场由Codeforces主办的在线编程竞赛。 该比赛的比赛链接为：https://codeforces.com/contest/772。 该比赛分为两个级别：Div.1和Div.2。 Div. 1级别通常比Div. 2级别更...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值