感觉这套比赛题目比较容易，没有以前做过的某次codechef那么凶残。题目还是很有意思的，最好的是有中文翻译。

CSUB：签到题，直接从左往右扫一遍即可，维护前面出现过多少个1.

#include <cstdio>

#include <cstring>

#define maxn 100100

using namespace std;

char s[maxn];

long long ans;

int cur,T,n;

int main()

{

    scanf("%d",&T);

    while (T--)

    {

        scanf("%d%s",&n,s);

        ans=cur=;

        for (int i=; s[i]; i++)

            if (s[i]=='') ans+=++cur;

        printf("%lld\n",ans);

    }

    return ;

}

RETPO：简单找规律。注意一开始的朝向，同时根据对称性，所有的点都可以对称到第一象限来。要走弯路的话，第一个单位距离消耗3步，第二个单位距离消耗1步，第三个消耗3步，第四个1步，依次类推即可。

#include <iostream>

#include <cstdio>

#include <cstring>

using namespace std;

long long x,y,n,ans;

int T;

int main()

{

    scanf("%d",&T);

    while (T--)

    {

        scanf("%lld%lld",&x,&y);

        if (x<) x=-x;

        if (y<) y=-y;

        n=y-x;

        if (n>= && n<=) ans=x+y;

            else

            {

                if (n<) n=-n;

                if (y>x) ans=*min(x,y)+(n/)*+(n&)*;

                        else ans=*min(x,y)+(n/)*+(n&)*;

            }

        printf("%lld\n",ans);

    }

    return ;

}

FROGV：氺题。对于每只青蛙，f[i]保存它向右最远可以传递到那一只青蛙，假设当前我们计算第i只青蛙，对于j>i，且i可以传递信息给j，那么f[i]=max(f[j])。

#include <iostream>

#include <cstdio>

#include <cstring>

#include <algorithm>

#define maxn 100100

using namespace std;

int g[maxn],f[maxn];

int n,m,k,x,y;

struct node{

    int x,id;

}a[maxn];

bool cmp(node n1,node n2)

{

    return n1.x<n2.x;

}

int main()

{

    scanf("%d%d%d",&n,&k,&m);

    for (int i=; i<=n; i++) scanf("%d",&a[i].x),a[i].id=i;

    sort(a+,a++n,cmp);

    for (int i=; i<=n; i++) g[a[i].id]=i;

    f[n]=n;

    for (int i=n-; i>; i--)

        if (a[i+].x-a[i].x<=k) f[i]=f[i+];

            else f[i]=i;

    while (m--)

    {

        scanf("%d%d",&x,&y);

        x=g[x],y=g[y];

        if (x>y) swap(x,y);

        if (y<=f[x]) puts("Yes");

            else puts("No");

    }

    return ;

}

SGARDEN：数学题。对于一种置换，它里面一定构成了若干个环。所有人都回到原地的步数就是所有环长度的lcm值。由于这个lcm值很大，必须对于每个环长度进行因数分解，保存每个质数出现的次数就可。最后取模计算。

#include <iostream>

#include <cstdio>

#include <cstring>

#include <map>

#define maxn 100100

typedef long long ll;

using namespace std;

const int M=;

int a[maxn],T,n,cur,N;

bool b[maxn];

ll ans;

map<int,int> ss;

void dfs(int x)

{

    if (b[x]) return;

    cur++,b[x]=true;

    dfs(a[x]);

}

void deal(int x)

{

    for (int i=; i*i<=x; i++)

    {

        if (x%i) continue;

        N=;

        while (x%i==) x/=i,N++;

        ss[i]=max(ss[i],N);

    }

    if (x>) ss[x]=max(ss[x],);

}

int main()

{

    scanf("%d",&T);

    while (T--)

    {

        ss.clear();

        ans=;

        scanf("%d",&n);

        for (int i=; i<=n; i++) scanf("%d",&a[i]),b[i]=false;

        for (int i=; i<=n; i++)

            if (!b[i])

            {

                cur=;

                dfs(i);

                deal(cur);

            }

        for (int i=; i<=n; i++)

            while (ss[i]--) ans=(ans*i)%M;

        printf("%lld\n",ans);

    }

    return ;

}

DISHOWN：一看这个题目就是一个典型的并查集了。每次查找盘子的主人，然后两个主人之间的比较无非就是改变一下指针而已了，路径压缩，所有的操作都是O(1)的。

#include <iostream>

#include <cstdio>

#include <cstring>

#define maxn 10010

using namespace std;

int a[maxn],f[maxn];

int n,q,T;

int father(int x) { return f[x]==x?f[x]:f[x]=father(f[x]); }

int main()

{

    int ope,x,y;

    scanf("%d",&T);

    while (T--)

    {

        scanf("%d",&n);

        for (int i=; i<=n; i++) scanf("%d",&a[i]),f[i]=i;

        scanf("%d",&q);

        while (q--)

        {

            scanf("%d",&ope);

            if (ope==)

            {

                scanf("%d%d",&x,&y);

                x=father(x),y=father(y);

                if (a[x]==a[y])

                {

                    if (x==y) puts("Invalid query!");

                    continue;

                }

                if (a[x]>a[y]) f[y]=x;

                    else f[x]=y;

            }

            else

            {

                scanf("%d",&x);

                printf("%d\n",father(x));

            }

        }

    }

    return ;

}

LEPAINT：这个题目我一开始以为我会T。没想到写了一发最最暴力的居然都A掉了。不过我觉得这个应该是被卡掉的，只是数据不够强吧。优化可以是这样的，对于物品，直接预处理它染色多少次后，为某种颜色的概率。同时，后面的区间染色就用扫描区间的方法，直接得出，直接求和即可。对于题目所说的取子集的问题，就相当于在这个范围里面每一个物品都有0.5的概率被染色。

#include <iostream>

#include <cstdio>

#include <cstring>

using namespace std;

double f[][],tmp[],ans;

int L,R,n,m,c,T;

int main()

{

    scanf("%d",&T);

    while (T--)//

    {

        scanf("%d%d%d",&n,&c,&m);

        for (int i=; i<=n; i++)

        {

            for (int j=; j<c; j++) f[i][j]=;

            f[i][]=;

        }

        while (m--)//

        {

            scanf("%d%d",&L,&R);

            for (int i=L; i<=R; i++)//

            {

                for (int j=; j<c; j++) f[i][j]/=,tmp[j]=f[i][j];

                for (int j=; j<c; j++)//

                    for (int k=; k<c; k++)//

                        f[i][j*k%c]+=tmp[j]/c;

            }

        }

        ans=;

        for (int i=; i<=n; i++)

            for (int j=; j<c; j++) ans+=f[i][j]*j;

        printf("%.9f\n",ans);

    }

    return ;

}

GNUM：很好的一个题目。一开始我就看准了这个题目，花时间最多的一个题目。读完题目后直接想到的就是二分图取匹配。显然是T。可以建模来解。以a[i]<b[j]且满足gcd条件的点位左边点，连接源点，以a[i]>b[j]且满足gcd条件的点为右点，连接汇点。中间是gcd出现过的质数，分别连接相应的左右点，所有的边流量都是1，跑最大流即可。这个做法肯定是没有错的。但是还是有一些问题存在。点太多了。咋解决？缩点，分别把左右边的点中含有相同的质因子种类的点缩成一个点，边容量累加。再跑最大流，缩点后，点数的级别也就1000吧，可以ac。

#include <iostream>

#include <cstdio>

#include <cstring>

#include <vector>

#include <queue>

#include <map>

#define maxn 2002000

#define maxpri 100100

using namespace std;

int pri[maxpri],pnum=,antipri[maxpri];

int z[][],Z[],a[],aa[];

int to[maxn],c[maxn],next[maxn],first[maxn],edge,node;

int tag[maxn],d[maxn],Q[maxn],bot,top,TAG=;

int f[][],Tf;

bool can[maxn];

int T,n,tmp,s,t,ans,cas;

map<int,int> ss,pos,Ttime;//质�对������

int gcd(int A,int B) { return B==?A:gcd(B,A%B); }

void getprim()

{

    for (int i=; i<maxpri; i++)

    {

        if (antipri[i]==-) continue;

        pri[++pnum]=i; antipri[i]=pnum;

        for (int j=i+i; j<maxpri; j+=i) antipri[j]=-;

    }

}

int addnode()

{

    node++;

    first[node]=-;

    return node;

}

void _init()

{

    ss.clear(),pos.clear(),Ttime.clear();

    edge=-,node=,Tf=;

    s=addnode(),t=addnode();

    ans=;

}

void addedge(int U,int V,int W)

{

    edge++;

    to[edge]=V,c[edge]=W,next[edge]=first[U],first[U]=edge;

    edge++;

    to[edge]=U,c[edge]=,next[edge]=first[V],first[V]=edge;

}

void deal(int x)

{

    Z[x]=,tmp=a[x],aa[x]=tmp;

    for (int i=; pri[i]<=tmp/pri[i]; i++)

        if (tmp%pri[i]==)

        {

            z[x][++Z[x]]=pri[i];

            while (tmp%pri[i]==) tmp/=pri[i];

        }

    if (tmp>) z[x][++Z[x]]=tmp;

    for (int i=; i<=Z[x]; i++)

        while (((aa[x]/z[x][i])%z[x][i])==) aa[x]/=z[x][i];

}

void buildedge()

{

    for (int x=; x<=n; x++)

        for (int y=n+; y<=n+n; y++)

            if (a[x]<a[y] && gcd(aa[x],aa[y])>)

            {

                int cur=gcd(aa[x],aa[y]);

                if (pos[cur]) { Ttime[cur]=Ttime[cur]+; continue; }

                pos[cur]=++Tf,f[Tf][]=,Ttime[cur]=;

                for (int i=; i<=Z[x]; i++)

                    if (aa[y]%z[x][i]==) f[Tf][++f[Tf][]]=z[x][i];

                f[Tf][f[Tf][]+]=cur;

            }

    for (int i=; i<=Tf; i++)

    {

        int cur=f[i][f[i][]+],tc=Ttime[cur],Nd=addnode();//Nd为��gcd代表���

        addedge(s,Nd,tc);

        for (int j=; j<=f[i][]; j++)

        {

            if (ss[f[i][j]]==) ss[f[i][j]]=addnode();

            addedge(Nd,ss[f[i][j]],tc);

        }

    }

    pos.clear(),Tf=;

    for (int x=; x<=n; x++)

        for (int y=n+; y<=n+n; y++)

            if (a[x]>a[y] && gcd(aa[x],aa[y])>)

            {

                int cur=gcd(aa[x],aa[y]);

                if (pos[cur]) { Ttime[cur]=Ttime[cur]+; continue; }

                pos[cur]=++Tf,f[Tf][]=,Ttime[cur]=;

                for (int i=; i<=Z[x]; i++)

                    if (aa[y]%z[x][i]==) f[Tf][++f[Tf][]]=z[x][i];

                f[Tf][f[Tf][]+]=cur;

            }

    for (int i=; i<=Tf; i++)

    {

        int cur=f[i][f[i][]+],tc=Ttime[cur],Nd=addnode();//Nd为��gcd代表���

        addedge(Nd,t,tc);

        for (int j=; j<=f[i][]; j++)

        {

            if (ss[f[i][j]]==) continue;

            addedge(ss[f[i][j]],Nd,tc);

        }

    }

}

bool bfs()

{

    TAG++;

    Q[bot=top=]=t,d[t]=,tag[t]=TAG,can[t]=false;

    while (bot<=top)

    {

        int cur=Q[bot++];

        for (int i=first[cur]; i!=-; i=next[i])

            if (c[i^]> && tag[to[i]]!=TAG)

            {

                tag[to[i]]=TAG,Q[++top]=to[i],d[to[i]]=d[cur]+,can[to[i]]=false;

                if (to[i]==s) return true;

            }

    }

    return false;

}

int dfs(int cur,int num)

{

    if (cur==t) return num;

    int tmp=num,k;

    for (int i=first[cur]; i!=-; i=next[i])

        if (c[i]> && d[to[i]]==d[cur]- && tag[to[i]]==TAG && can[to[i]]==false)

        {

            k=dfs(to[i],min(num,c[i]));

            if (k) num-=k,c[i]-=k,c[i^]+=k;

            //if (num==0) return tmp;

        }

    if (num) can[cur]=true;

    return tmp-num;

}

int main()

{

    getprim();

    scanf("%d",&T);

    while (T--)

    {

        scanf("%d",&n);

        for (int i=; i<=*n; i++) scanf("%d",&a[i]),deal(i);

        _init();

        buildedge();

        while (bfs()) ans+=dfs(s,maxn);

        printf("%d\n",ans);

    }

    return ;

}

SEAEQ：为什么这是整场比赛通过人数最少的题目？我觉得在平时比赛这种难度的题目也就算中等吧？此题让我想去去年杭州赛的那个题。深坑呐。解法是这样的，dp预处理长度为i的排列有不超过j个逆序数对的情况有多少种！这个可以dp好好想想就知道了，剩下的就是逆推枚举了，直接枚举区间长度，位置，对于两个排列其他的位置都是全排列即可。对于题目的那个要求就是在规定区间内，每个位置的相对大小相同即可，这个只需要保证对于预处理的种类数乘一次，对于取组合数和全排列数乘以两次即可。不难理解，自己想想就很清楚了。一开始取模打成了1000000009，都怪前几天打的那场acdream，坑死啦。

#include <iostream>

#include <cstdio>

#include <cstring>

#define maxn 502

typedef long long ll;

using namespace std;

const int M=;

int n,e,T,ans;

int sum[maxn][(maxn*maxn-maxn)/];//�度����对�

ll P[maxn],C[maxn][maxn];

int main()

{

    P[]=,C[][]=;

    for (int i=; i<maxn; i++) P[i]=(P[i-]*i)%M;

    for (int i=; i<maxn; i++)

    {

        C[i][]=;

        for (int j=; j<=i; j++) C[i][j]=(C[i-][j-]+C[i-][j])%M;

    }

    int last=,next;

    sum[][]=;

    for (int i=; i<maxn; i++)

    {

        next=last+i-;

        sum[i][]=;

        for (int j=; j<i; j++)

        {

            sum[i][j]=sum[i][j-]+sum[i-][j];

            if (sum[i][j]>=M) sum[i][j]-=M;

        }

        for (int j=i; j<=last; j++)

        {

            sum[i][j]=sum[i][j-]+sum[i-][j]-sum[i-][j-i];

            if (sum[i][j]>=M) sum[i][j]-=M;

            if (sum[i][j]<) sum[i][j]+=M;

        }

        for (int j=last+; j<=next; j++)

        {

            sum[i][j]=sum[i][j-]+sum[i-][last]-sum[i-][j-i];

            if (sum[i][j]>=M) sum[i][j]-=M;

            if (sum[i][j]<) sum[i][j]+=M;

        }

        last=next;

    }

    scanf("%d",&T);

    while (T--)

    {

        scanf("%d%d",&n,&e);

        ans=;

        for (int i=; i<=n; i++)

        {

            int cur=min((i*i-i)/,e);

            cur=sum[i][cur];

            ll tmp=(C[n][i]*P[n-i])%M;

            tmp=((tmp*tmp)%M*cur)%M;

            ans+=(tmp*(n+-i))%M;

            if (ans>=M) ans-=M;

        }

        printf("%d\n",ans);

    }

    return ;

}

Codechef_JULY14的更多相关文章

随机推荐

  1. cookie记住密码/base64加密（js控制）

    cookie记住密码/base64加密(js控制) • 配置cookie //设置cookie function setCookie ( name, value, expdays ) { var ex ...

  2. appium自动化---activity获取

    方法一:appt查询activity获取 aapt dump badging <路径/包名> | find "launchable-activity" 方法二: 1.打 ...

  3. 开始认真的学习Python

    虽然以前有多年的Fortran.C.C++以及Java开发经验,但真的开始熟悉Python还是被惊艳到了,太舒服了,看起来有如沐春风的感觉,简洁和优美,这个才是代码艺术.

  4. 【 C# 】（一） ------------- 泛型带头节点的单链表，双向链表实现

    在编程领域,数据结构与算法向来都是提升编程能力的重点.而一般常见的数据结构是链表,栈,队列,树等.事实上C#也已经封装好了这些数据结构,在头文件 System.Collections.Generic ...

  5. maven项目的标准目录结构

    maven项目的标准目录结构如下:

  6. 2019CSUST集训队选拔赛题解（二）

    凛冬将至 Description 维斯特洛大陆的原住民是森林之子,他们长得如孩童一般,善于使用石器,威力值35,用树叶树枝作为衣物,在森林里繁衍生息,与万物和平相处.他们会使用古老的魔法(比如绿之视野 ...

  7. ssh软件及命令的使用

    常用软件安装及使用目录 第1章 ssh常用用法小结 1.1 连接到远程主机: 命令格式 : ssh name@remoteserver 或者 ssh remoteserver -l name 说明:以 ...

  8. Django_csrf

    CSRF攻击介绍 CSRF 攻击可以在受害者毫不知情的情况下以受害者名义伪造请求发送给受攻击站点,从而在并未授权的情况下执行在权限保护之下的操作.比如说,受害者 Bob 在银行有一笔存款,通过对银行的 ...

  9. React的setState分析

    前端框架层出不穷,不过万变不离其宗,就是从MVC过渡到MVVM.从数据映射到DOM,angular中用的是watcher对象,vue是观察者模式,react就是state了. React通过管理状态实 ...

  10. Arithmatic项目修改总结

    Arithmatic项目修改总结 github仓库 arithmatic3.0 一. 修改介绍 修改后类图: 1.关于类的合并 ==可以发现相比右边(旧)的类,左边(新)的类少了很多,这是我这次大改的 ...