2017百度之星初赛

最新推荐文章于 2022-08-29 18:47:40 发布
最新推荐文章于 2022-08-29 18:47:40 发布
阅读量998 收藏 1
点赞数
分类专栏： 比赛 文章标签： 2017 百度之星 初赛 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AC__GO/article/details/77131824
版权

A汇总（无1004 迷宫出逃）
结合自己理解和网上题解汇总了一下2017百度之星初赛的题解，暂无0ak的1004题

小C的倍数问题

Accepts: 1990 Submissions: 4931
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Problem Description
根据小学数学的知识，我们知道一个正整数x是3的倍数的条件是x每一位加起来的和是3的倍数。反之，如果一个数每一位加起来是3的倍数，则这个数肯定是3的倍数。

现在给定进制P，求有多少个B满足P进制下，一个正整数是B的倍数的充分必要条件是每一位加起来的和是B的倍数。

Input
第一行一个正整数T表示数据组数(1<=T<=20)。

接下来T行，每行一个正整数P(2 < P < 1e9)，表示一组询问。

Output
对于每组数据输出一行，每一行一个数表示答案。

Sample Input
1
10
Sample Output
3

假设一个数为 ： p 进制下的 a1a2a3 % B == 0,者以下俩个等式一定成立：
1）a1 * p ^ 2 + a2 * p ^ 1 + a3 * p ^ 1 = sum % B == 0,
2）a1 + a2 + a3 = ans % B == 0

以上两个式子同时成立的条件是 ： p % B == 1
所以满足条件的 B 的个数为 p - 1 的因子数

AC代码：

#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAX = 1e5 + 10;
typedef long long LL;
void solve(LL o){
    int ans = 0;
    for(LL i = 1; i * i <= o; i++){
        if(o % i == 0){
                ans++;
            if(i * i != o) ans++;
        }
    }
    printf("%d\n",ans);
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--){
        LL n;
        scanf("%lld",&n);
        solve(n - 1);
    }
    return 0;
}

数据分割

小w来到百度之星的赛场上，准备开始实现一个程序自动分析系统。

这个程序接受一些形如x_i = x_jx​i​​=x​j​​ 或 x_i \neq x_jx​i​​≠x​j​​ 的相等/不等约束条件作为输入，判定是否可以通过给每个 w 赋适当的值，来满足这些条件。

输入包含多组数据。 然而粗心的小w不幸地把每组数据之间的分隔符删掉了。 他只知道每组数据都是不可满足的，且若把每组数据的最后一个约束条件去掉，则该组数据是可满足的。

请帮助他恢复这些分隔符。

Input
第11行：一个数字LL，表示后面输入的总行数。

之后LL行，每行包含三个整数，i,j,ei,j,e，描述一个相等/不等的约束条件，若e=1e=1，则该约束条件为x_i = x_jx​i​​=x​j​​ ，若e=0e=0，则该约束条件为 x_i \neq x_jx​i​​≠x​j​​ 。

i,j,L \leq 100000i,j,L≤100000

x_i , x_j \leq Lx​i​​,x​j​​≤L

Output
输出共T+1T+1行。

第一行一个整数TT，表示数据组数。

接下来TT行的第ii行，一个整数，表示第i组数据中的约束条件个数。

Sample Input
6
2 2 1
2 2 1
1 1 1
3 1 1
1 3 1
1 3 0
Sample Output
1
6
———————————————————————————————————————
因为相等具有传递性所以我们可以用并查集维护一波
但是不能不具有传递性所以我们可以用平衡树维护一波
当然这里我用的是set
这样之后呢 等于我们就可以把他们扔在一个并查集里面
不等于的就把不等于他的扔进他的平衡树里面
每次询问
如果是一对相等的数
我们就找一波他们是否在同一个并查集里 是就直接继续下一波
不是就找他们是否存在对方的并查集里面 当然这里我们强行把size小的合并进大的里面保证复杂度
如果是不想等就判短他们是否同属一个并查集
是就清空一波 记录答案
不然就把他们加入对方的平衡树里面

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<set>
using namespace std;
int read(){
    int ans=0,f=1,c=getchar();
    while(c<'0'||c>'9'){if(c=='-') f=-1; c=getchar();}
    while(c>='0'&&c<='9'){ans=ans*10+(c-'0'); c=getchar();}
    return ans*f;
}
int T,f[200007];
int find(int x){return f[x]==x?x:f[x]=find(f[x]);}
set<int>tr[200007];
int vis[200007],cnt=1;
int ans[200007],ap;
int stk[200007],stp;
int a,b,h;
void clear(){
    while(stp){
        int x=stk[--stp];
        tr[x].clear();
        f[x]=x;
    }
    ++cnt;
}
int main()
{
    T=read();
    for(int i=0;i<=200000;i++) f[i]=i;
    for(int i=1;i<=T;i++){
        a=read(); b=read(); h=read();
        if(vis[a]!=cnt) stk[stp++]=a,vis[a]=cnt;
        if(vis[b]!=cnt) stk[stp++]=b,vis[b]=cnt;
        int p=find(a),q=find(b);
        if(tr[p].size()<tr[q].size()) swap(p,q);
        if(h==1){
            if(p==q) continue;
            if(tr[p].find(q)!=tr[p].end()){
                clear();
                ans[++ap]=i;
                continue;
            }
            f[q]=p;
            for(set<int>::iterator it=tr[q].begin();it!=tr[q].end();it++){
                int z=*it;
                tr[z].erase(q);
                tr[z].insert(p);
                tr[p].insert(z);
            }
            tr[q].clear();
        }
        else{
            if(p==q){
                clear();
                ans[++ap]=i;
                continue;
            }
            tr[p].insert(q);
            tr[q].insert(p);
        }
    }
    printf("%d\n",ap);
    for(int i=1;i<=ap;i++) printf("%d\n",ans[i]-ans[i-1]);
    return 0;
}

路径交

Problem Description
给定一棵n个点的树，以及m条路径，每次询问第L条到第R条路径的交集部分的长度（如果一条边同时出现在2条路径上，那么它属于路径的交集）。

Input
第一行一个数n（n<=500,000）

接下来n-1行，每行三个数x，y，z，表示一条从x到y并且长度为z的边 第n+1行一个数m（m<=500,000）

接下来m行，每行两个数u，v，表示一条从u到v的路径

接下来一行一个数Q，表示询问次数（Q<=500,000）

接下来Q行，每行两个数L和R

Output
Q行，每行一个数表示答案。

Sample Input
4
1 2 5
2 3 2
1 4 3
2
1 2
3 4
1
1 2
Sample Output
5

题解：看到题的第一反应就是线段树，然后在区间合并的时候求一下两个路径的交即可，现在我们只需要快速求出两个路径的交即可。

设两条路径分别为a1-b1,a2-b2，它们的lca是c1,c2，求出a1,b1-a2,b2两两之间的lca，设分别为d1,d2,d3,d4，假设dep[d1]<=dep[d2]<=dep[d3]<=dep[d4]，dep[c1]<=dep[c2]。那么如果两条路径有交，当且仅当dep[d1]>=dep[c1]且dep[d4]>=dep[d3]>=dep[c2]（自己画画就知道了）。并且如果有交，那么交一定是d3-d4。

如果用RMQ求LCA，则时间复杂度为nlogn。
ac代码：

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define lson x<<1
#define rson x<<1|1
using namespace std;
const int maxn=500010;
typedef long long ll;
struct path
{
    int a,b,c;
    path(){}
    path(int A,int B,int C) {a=A,b=B,c=C;}
}p[maxn],s[maxn<<2];
int n,m,q,cnt;
int mn[20][maxn<<1],Log[maxn<<1],pos[maxn],dep[maxn],fa[maxn];
int head[maxn],nxt[maxn<<1],val[maxn<<1],to[maxn<<1];
int cs[10];
ll len[maxn];
int MN(int a,int b)
{
    return dep[a]<dep[b]?a:b;
}
int lca(int a,int b)
{
    int x=pos[a],y=pos[b];
    if(x>y) swap(x,y);
    int k=Log[y-x+1];
    return MN(mn[k][x],mn[k][y-(1<<k)+1]);
}
bool cmp(int a,int b)
{
    return dep[a]<dep[b];
}
path mix(path x,path y)
{
    if(!x.c||!y.c)  return path(0,0,0);
    cs[1]=lca(x.a,y.a),cs[2]=lca(x.a,y.b),cs[3]=lca(x.b,y.a),cs[4]=lca(x.b,y.b);
    sort(cs+1,cs+5,cmp);
    int md=max(dep[x.c],dep[y.c]),nd=min(dep[x.c],dep[y.c]);
    if(dep[cs[1]]<nd||dep[cs[3]]<md)    return path(0,0,0);
    else    return path(cs[3],cs[4],lca(cs[3],cs[4]));
}
inline int rd()
{
    int ret=0,f=1;  char gc=getchar();
    while(gc<'0'||gc>'9')   {if(gc=='-')f=-f;   gc=getchar();}
    while(gc>='0'&&gc<='9') ret=ret*10+gc-'0',gc=getchar();
    return ret*f;
}
void add(int a,int b,int c)
{
    to[cnt]=b,val[cnt]=c,nxt[cnt]=head[a],head[a]=cnt++;
}
void dfs(int x)
{
    pos[x]=++pos[0],mn[0][pos[0]]=x;
    for(int i=head[x];i!=-1;i=nxt[i])
    {
        if(to[i]!=fa[x])
        {
            fa[to[i]]=x,dep[to[i]]=dep[x]+1,len[to[i]]=len[x]+val[i],dfs(to[i]);
            mn[0][++pos[0]]=x;
        }
    }
}
void build(int l,int r,int x)
{
    if(l==r)
    {
        s[x]=p[l];
        return ;
    }
    int mid=l+r>>1;
    build(l,mid,lson),build(mid+1,r,rson);
    s[x]=mix(s[lson],s[rson]);
}
path query(int l,int r,int x,int a,int b)
{
    if(a<=l&&r<=b)  return s[x];
    int mid=l+r>>1;
    if(b<=mid)  return query(l,mid,lson,a,b);
    if(a>mid)   return query(mid+1,r,rson,a,b);
    return mix(query(l,mid,lson,a,b),query(mid+1,r,rson,a,b));
}
int main()
{
    n=rd();
    int i,j,a,b,c;
    memset(head,-1,sizeof(head));
    for(i=1;i<n;i++)    a=rd(),b=rd(),c=rd(),add(a,b,c),add(b,a,c);
    dep[1]=1,dfs(1);
    for(i=2;i<=2*n-1;i++)   Log[i]=Log[i>>1]+1;
    for(j=1;(1<<j)<=2*n-1;j++)  for(i=1;i+(1<<j)-1<=2*n-1;i++)  mn[j][i]=MN(mn[j-1][i],mn[j-1][i+(1<<j-1)]);
    m=rd();
    for(i=1;i<=m;i++)   p[i].a=rd(),p[i].b=rd(),p[i].c=lca(p[i].a,p[i].b);
    build(1,m,1);
    q=rd();
    for(i=1;i<=q;i++)
    {
        a=rd(),b=rd();
        path ans=query(1,m,1,a,b);
        printf("%lld\n",len[ans.a]+len[ans.b]-2*len[ans.c]);
    }
    return 0;
}

今夕何夕

Time Limit: 2000/1000 MS (Java/Others)

Memory Limit: 32768/32768 K (Java/Others)
Problem Description
今天是2017年8月6日，农历闰六月十五。

小度独自凭栏，望着一轮圆月，发出了“今夕何夕，见此良人”的寂寞感慨。

为了排遣郁结，它决定思考一个数学问题：接下来最近的哪一年里的同一个日子，和今天的星期数一样？比如今天是8月6日，星期日。下一个也是星期日的8月6日发生在2023年。

小贴士：在公历中，能被4整除但不能被100整除，或能被400整除的年份即为闰年。

Input
第一行为T，表示输入数据组数。

每组数据包含一个日期，格式为YYYY-MM-DD。

1 ≤ T ≤ 10000

YYYY ≥ 2017

日期一定是个合法的日期

Output
对每组数据输出答案年份，题目保证答案不会超过四位数。

Sample Input
3
2017-08-06
2017-08-07
2018-01-01
Sample Output
2023
2023
2024
思路：模拟题没什么好说的，注意2月29即可；

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<iostream>
#include<cstdio>
#include<cmath>
#include<string>
#include<queue>
#include<algorithm>
#include<stack>
#include<cstring>
#include<vector>
#include<list>
#include<set>
#include<map>
using namespace std;
#define LL long long
#define pi (4*atan(1.0))
#define eps 1e-14
#define bug(x)  cout<<"bug"<<x<<endl;
const int N=1e4+110,M=1e6+10,inf=2147483647;
const LL INF=1e18+10,mod=1e9+7;

int mouth[15]={0,31,29,31,30,31,30,31,31,30,31,30,31};
int yyyy(int x)
{
    if(x%400==0||(x%4==0&&x%100!=0))
    return 1;
    return 0;
}
int much(int y,int m,int d)
{
    int flag=yyyy(y);
    int ans=0;
    for(int i=1;i<m;i++)
    {
        if(i==2)
        {
            if(flag)ans+=29;
            else ans+=28;
        }
        else ans+=mouth[i];
    }
    return ans+d;
}
int fuck(int yy,int mm,int dd,int y,int m,int d)
{
    int ans=0;
    for(int i=yy;i<y;i++)
    {
        if(yyyy(i))ans+=366;
        else ans+=365;
    }
    return ans;
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        int y,m,d;
        scanf("%d-%d-%d",&y,&m,&d);
        if(m==2&&d==29)
        {
            int pre=y,ans=0;
            for(int i=y+4;;i+=4)
            {
                if(yyyy(i)==0)continue;
                ans+=fuck(pre,m,d,i,m,d);
                if(ans%7==0)
                {
                    printf("%d\n",i);
                    break;
                }
                pre=i;
            }
        }
        else
        {
            int ans=0;
            for(int i=y+1;;i++)
            {
            int d1=much(i-1,m,d);
            int d2=much(i-1,12,31);
            int d3=much(i,m,d);
            ans+=d2-d1+d3;
            if(ans%7==0)
            {
                printf("%d\n",i);
                break;
            }
            }
        }
    }
    return 0;
}

度度熊的01世界

Time Limit: 2000/1000 MS (Java/Others)

Memory Limit: 32768/32768 K (Java/Others)
Problem Description
度度熊是一个喜欢计算机的孩子，在计算机的世界中，所有事物实际上都只由0和1组成。

现在给你一个n*m的图像，你需要分辨他究竟是0，还是1，或者两者均不是。

图像0的定义：存在1字符且1字符只能是由一个连通块组成，存在且仅存在一个由0字符组成的连通块完全被1所包围。

图像1的定义：存在1字符且1字符只能是由一个连通块组成，不存在任何0字符组成的连通块被1所完全包围。

连通的含义是，只要连续两个方块有公共边，就看做是连通。

完全包围的意思是，该连通块不与边界相接触。

Input
本题包含若干组测试数据。 每组测试数据包含： 第一行两个整数n,m表示图像的长与宽。 接下来n行m列将会是只有01组成的字符画。

满足1<=n,m<=100

Output
如果这个图是1的话，输出1；如果是0的话，输出0，都不是输出-1。

Sample Input
32 32
00000000000000000000000000000000
00000000000111111110000000000000
00000000001111111111100000000000
00000000001111111111110000000000
00000000011111111111111000000000
00000000011111100011111000000000
00000000111110000001111000000000
00000000111110000001111100000000
00000000111110000000111110000000
00000001111110000000111110000000
00000001111110000000011111000000
00000001111110000000001111000000
00000001111110000000001111100000
00000001111100000000001111000000
00000001111000000000001111000000
00000001111000000000001111000000
00000001111000000000000111000000
00000000111100000000000111000000
00000000111100000000000111000000
00000000111100000000000111000000
00000001111000000000011110000000
00000001111000000000011110000000
00000000111000000000011110000000
00000000111110000011111110000000
00000000111110001111111100000000
00000000111111111111111000000000
00000000011111111111111000000000
00000000111111111111100000000000
00000000011111111111000000000000
00000000001111111000000000000000
00000000001111100000000000000000
00000000000000000000000000000000
32 32
00000000000000000000000000000000
00000000000000001111110000000000
00000000000000001111111000000000
00000000000000011111111000000000
00000000000000111111111000000000
00000000000000011111111000000000
00000000000000011111111000000000
00000000000000111111110000000000
00000000000000111111100000000000
00000000000001111111100000000000
00000000000001111111110000000000
00000000000001111111110000000000
00000000000001111111100000000000
00000000000011111110000000000000
00000000011111111110000000000000
00000001111111111111000000000000
00000011111111111111000000000000
00000011111111111111000000000000
00000011111111111110000000000000
00000000001111111111000000000000
00000000000000111111000000000000
00000000000001111111000000000000
00000000000111111110000000000000
00000000000011111111000000000000
00000000000011111111000000000000
00000000000011111111100000000000
00000000000011111111100000000000
00000000000000111111110000000000
00000000000000001111111111000000
00000000000000001111111111000000
00000000000000000111111111000000
00000000000000000000000000000000
3 3
101
101
011
Sample Output
0
1
-1
思路:把与外围相连的0的联通块去掉，剩下的就是被1包围的，你只需要判断1，0联通块的个数即可；

　　并查集判联通；
　　

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<iostream>
#include<cstdio>
#include<cmath>
#include<string>
#include<queue>
#include<algorithm>
#include<stack>
#include<cstring>
#include<vector>
#include<list>
#include<set>
#include<map>
#include<bitset>
#include<time.h>
using namespace std;
#define LL long long
#define pi (4*atan(1.0))
#define eps 1e-4
#define bug(x)  cout<<"bug"<<x<<endl;
const int N=2e4+10,M=1e6+10,inf=1e9+7,MOD=1e9+7;
const LL INF=1e18+10,mod=1e9+7;

int fa[N];
int vis[N],flag[N];
int Find(int x)
{
    return x==fa[x]?x:fa[x]=Find(fa[x]);
}
void update(int x,int y)
{
    int u=Find(x);
    int v=Find(y);
    if(u!=v)fa[u]=v;
}
int n,m;
char a[110][110];
int check(int x,int y)
{
    if(x<=0|x>n||y<=0||y>m)
        return 0;
    return 1;
}
int xx[5]={1,0,-1,0};
int yy[5]={0,-1,0,1};
int pos(int x,int y)
{
    return (x-1)*m+y;
}
void xjhz()
{
    memset(vis,0,sizeof(vis));
    memset(flag,0,sizeof(flag));
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            for(int k=0;k<4;k++)
            {
                int x=i+xx[k];
                int y=j+yy[k];
                if(check(x,y)&&a[x][y]==a[i][j])
                {
                    update(pos(x,y),pos(i,j));
                }
            }
        }
    }
    int zero=0,one=0;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            int XX=Find(pos(i,j));
            for(int k=0;k<4;k++)
            {
                int x=i+xx[k];
                int y=j+yy[k];
                if(check(x,y)==0)
                    vis[XX]=1;
            }
        }
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            int XX=Find(pos(i,j));
            if(a[i][j]=='1')
            {
                if(!flag[XX])one++;
                flag[XX]=1;
            }
            else
            {
                if(!vis[XX]&&!flag[XX])zero++;
                flag[XX]=1;
            }
        }
    }
    if(one!=1)printf("-1\n");
    else {
        if(zero==1)printf("0\n");
        else if(zero==0)printf("1\n");
        else printf("-1\n");
    }
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        for(int i=0;i<=15000;i++)
            fa[i]=i;
        for(int i=1;i<=n;i++)
        scanf("%s",a[i]+1);
        xjhz();
    }
    return 0;
}
AC__GO
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2012 百度之星初赛题
06-27
2012年百度之星初赛题目，仅供参考。有兴趣可以看看
【百度之星2023】初赛第一场 补题（部分）
最新发布
legend_yst的博客
08-28 1042
枚举之前的截止位置，从（已划分段数-1）和之前的截止位置和新一段若干块的最大值，对枚举得到的所有结果求最小值。dp[已划分段数][截止位置]。dp[0][0]=0，其它dp[i][j]=INF。按说过不了，但实际能过，可能实际比较“稀疏”，所以常数比较小。枚举横切，然后二分答案，每次划分尽可能推迟到较靠后的位置。首先BFS求从小度、度度熊和终点到每个点的举距离。用糖纸换的不需要买。然后枚举每个点，求在该点会合的答案。按位枚举横切，dp处理纵切。小心负数被除会向负无穷取整。应该可以进一步预处理成。
2022百度之星第一场初赛
艾
08-29 2435
2022百度之星第一场初赛题解
2017百度之星资格赛题解（1003、1004）
雪的期许
08-05 5008
1003度度熊与邪恶大魔王 Accepts: 1503 Submissions: 9026 Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others) Problem Description 度度熊为了拯救可爱的公主，于是与邪恶大魔王战斗起来。 邪恶大魔王的麾下有n个怪兽，每个怪兽有...
2017百度之星初赛第一场题解
OZY的博客
08-12 795
3744: Gty的妹子序列我早已习惯你不在身边， 人间四月天 寂寞断了弦。 回望身后蓝天， 跟再见说再见…… 某天,蒟蒻Autumn发现了从 Gty的妹子树(bzoj3720) 上掉落下来了许多妹子,他发现 她们排成了一个序列,每个妹子有一个美丽度。 Bakser神犇与他打算研究一下这个妹子序列,于是Bakser神犇问道:”你知道区间 [l,r]中妹子们美丽度的逆序对数吗?” 蒟蒻
HDU 6109 数据分割（并查集+set+在线倍增法）
ZSQ
09-28 488
Description小ww来到百度之星的赛场上，准备开始实现一个程序自动分析系统。这个程序接受一些形如xi=xjxi=xj或xi≠xjxi≠xj的相等/不等约束条件作为输入，判定是否可以通过给每个ww赋适当的值，来满足这些条件。输入包含多组数据。 然而粗心的小ww不幸地把每组数据之间的分隔符删掉了。 他只知道每组数据都是不可满足的，且若把每组数据的最后一个约束条件去掉，则该组数据是可满足的。请
百度之星2011（初赛）
06-15
百度之星 2011 初赛 算法设计题 百度之星
2012百度之星初赛第二场c题
06-04
原理很简单：取max1，max2 然后分别存到2个不同的数组，之后对这2个数组进行排序后比大小就可以了；
百度之星试题
07-17
百度之星试题，我也忘记是哪年的了。
【程序设计大赛】2018百度之星
11-16
【程序设计大赛】2018百度之星
2017百度之星总结
bless295的博客
08-20 2991
2017百度之星总结 从陕西省赛回来之后就退役了，刚开始的时候很迷茫也很颓废，期末考也没有考好。因为我的某一些个人原因只能选择退队，很对不起johsnows和UMR，让他们两个独自去面对下半年的CCPC和ICPC，心里的愧疚之情很是浓郁。 然后不知不觉到了暑假，某一次偶然的机会金桔臭骂了我一顿，谈话的主要内容就是就是退了队也不能放弃努力，在此之前已经接到了百度之星的电话，邀请我参赛，本来我已经
HDU 6109 数据分割 【并查集+set】 （2017"百度之星"程序设计大赛 - 初赛（A））
Coolxxx的博客
08-13 692
数据分割 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 1119    Accepted Submission(s): 268 Problem Description 小w来到百度之星的赛场上，准备开始实现一个程
2017百度之星初赛B场总结
about:Banlk
08-13 893
（A场因为不可抗力因素(?)没能参加，B场还好算是磕磕碰碰地吃着低保过去了，真的菜呀） Chess Problem Description 車是中国象棋中的一种棋子，它能攻击同一行或同一列中没有其他棋子阻隔的棋子。一天，小度在棋盘上摆起了许多車……他想知道，在一共N×M个点的矩形棋盘中摆最多个数的車使其互不攻击的方案数。他经过思考，得出了答案。但他仍不满足，想增加一个条件：对于任何一个車A
2017百度之星 复赛
老臣
08-18 1141
作为一只菜鸡，这可能是我OI生涯中最后一次打百度之星了，希望明年这个时候能不退役（虽然不大可能）开始贴题解吧。会持续更新。1001 Arithmetic of Bomb 煞笔模拟题，1A#include<cstdio> #include<algorithm> #include<cstring> #define fo(i,a,b) for(int i=a;i<=b;i++) #define fd(i
[HDU6109][2017"百度之星"程序设计大赛 - 初赛（A）]数据分割
UISG103的博客
08-13 298
数据分割 小w来到百度之星的赛场上，准备开始实现一个程序自动分析系统。这个程序接受一些形如xi=xj或xi≠xj的相等/不等约束条件作为输入，判定是否可以通过给每个 w 赋适当的值，来满足这些条件。输入包含多组数据。然而粗心的小w不幸地把每组数据之间的分符删掉了。他只知道每组数据都是不可满足的，且若把每组数据的最后一个约束条件去掉，则该组数据是可满足的。请帮助他恢复这些分隔符。Input第1
2017百度之星初赛A 第二题 ——并查集启发式合并
usernamezzz的博客
08-11 240
数据分割 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 2091    Accepted Submission(s): 607   Problem Description 小w来到百度之星的赛场上，准备开始实现一个程序自动分析系统...
百度之星2017初赛题解（A）
yfzcsc的博客
08-13 1242
T1: 简单数论，问满足（a0+a1*B+...+an*B^n）=a0+a1+...+an（mod P）的P的个数 即满足P|(B-1)a1+(B^2-1)a2+(B^3-1)a3+...,即P|B-1的P的个数 sqrt(B-1)暴力枚举B-1约数即可 T2: 现在给若干个条件，xi=xj或xi≠xj,要你将它们划分成若干组，满足每个组除去最后一个条件时成立，否则不成立。 拿并查集将
百度之星初赛（A）--数据分割----启发式合并
bless295的博客
08-13 435
数据分割 Accepts: 202 Submissions: 1332 Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others) Problem Description 小w来到百度之星的赛场上，准备开始实现一个程序自动分析系统。 这个程序接
百度之星2023初赛
08-24
很抱歉，我没有找到关于百度之星2023初赛的任何信息。在本次回答中，我所引用的资料只包括百度之星2022初赛相关的信息。可能是因为百度之星2023初赛的信息还没有公开或者我无法访问到相关的资料。建议您咨询百度官方...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值