2016山东省第七届ACM大学生程序设计竞赛题解

最新推荐文章于 2024-04-29 17:03:19 发布
最新推荐文章于 2024-04-29 17:03:19 发布
阅读量486 收藏
点赞数
分类专栏： Contest
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Irish_Moonshine/article/details/80201825
版权

A Julyed
答案每一个数对后面整除，若不能整除，答案为整除+1。

#include<iostream>
#include<stdio.h>

using namespace std;

int main()
{
    int t;
    cin>>t;
    while(t--){
        double a,b;
        cin>>a>>b;
        double c=a/b;
        int d= c;
        if(c==d){
            cout<<d;
        }else{
            cout<<d+1;
        }
        cout<<"\n";

    }
    return 0;
}

B Fibonacci
把一个数字拆成许多不连续的斐波那契数字之和，可以找到贪心的策略，从大向小能拆必拆！

#include<iostream>
#include<stdio.h>
#include<queue>
#include<vector>
#include<string.h>
#include<algorithm>
using namespace std;

const int maxn=1e2+10;
const int mod=1e9+7;
int f[maxn];
int sz=0;
int ans[maxn];
void init()
{
    f[1]=1;
    f[2]=2;
    for(int i=3;i<=45;i++){
        f[i]=f[i-1]+f[i-2];
        if(f[i]>mod){
            sz=i;break;
        }
    }
}
int main()
{
    init();
    int T;
    scanf("%d",&T);
    while(T--){
        int n;
        scanf("%d",&n);
        int tmp=n;
        bool flag=0;int cs=0;
        for(int i=sz;i>=1;i--){
            if(flag==0&&n>=f[i]){
                n-=f[i];flag=1;ans[++cs]=f[i];
            }
            else if(flag==1)flag=0;
        }
        if(n==0){
            printf("%d=%d",tmp,ans[cs]);
            for(int i=cs-1;i>=1;i--){
                printf("+%d",ans[i]);
            }
        }
        else printf("-1");
        printf("\n");
    }
    return 0;
}

C Proxy
保存路径的最短路

#include<iostream>
#include<stdio.h>
#include<queue>
#include<vector>
#include<string.h>
#include<algorithm>
using namespace std;
const int maxn = 1000+33;
const int inf = 0x3f3f3f3f;
int n,m;
vector<int>G[maxn];
vector<int>len[maxn];
int pre[maxn];
int vis[maxn],dis[maxn];
void spfa(int s,int t)
{

    for(int i=0;i<=n+1;i++){
        vis[i]=0;
        dis[i]=inf;
    }
    queue<int>q;
    dis[0]=0;
    q.push(s);
    while(!q.empty()){
        int u = q.front();
        q.pop();
        vis[u]=0;
        for(int i=0;i<G[u].size();i++){
            int v=G[u][i];
            if(dis[v]>dis[u]+len[u][i]){
                dis[v]=dis[u]+len[u][i];
                pre[v]=u;
                if(!vis[v]){
                    vis[v]=1;
                    q.push(v);
                }
            }else if(dis[v]==dis[u]+len[u][i]&&pre[v]>u){
                pre[v]=u;
            }
        }
    }
}

int main()
{
    int T;
    scanf("%d",&T);
    while(T--){
        scanf("%d%d",&n,&m);
        for(int i=0;i<=n+1;i++){
            G[i].clear();
            len[i].clear();
            pre[i]=0;
        }
        for(int i=1;i<=m;i++){
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            G[u].push_back(v);
            len[u].push_back(w);
        }
        spfa(0,n+1);
        int now=n+1;
        if(dis[n+1]==inf){
            printf("-1\n");
            continue;
        }
        int ans=0;
        while(now){
            ans=now;
            now=pre[now];
        }
        if(ans==n+1){
            printf("0\n");
        }else{
            printf("%d\n",ans);
        }
    }


    return 0;
}

D Swiss-system tournament
模拟归并排序，在进行r轮操作的时候，我们发现其中的一半数字被调出来++，另一半则不变，那么这两个子数组的单调性是不发生变化的，所以可以归并！

#include<iostream>
#include<string.h>
#include<stdio.h>
#include<algorithm>
using namespace std;
const int maxn=1e5+10;
struct node{
    int id,wl,sc;
}a[maxn<<1],b[maxn],c[maxn];
int n,r,q,tmp;
bool cmp(node a,node b)
{
    if(a.sc!=b.sc) return a.sc>b.sc;
    else return a.id<b.id;
}
void merge_sort()
{
    for(int i=1;i<=r;i++)
    {
        int l1=0,l2=0;
        for(int j=1;j<=tmp;j+=2){
            l1++; l2++;
            if(a[j].wl<a[j+1].wl) a[j+1].sc++,b[l1]=a[j+1],c[l2]=a[j];
            else a[j].sc++,b[l1]=a[j],c[l2]=a[j+1];
        }
        l1=l2=1;int k=0;
        while(l1<=n&&l2<=n)
        {
//            if(b[l1].sc<c[l2].sc) a[++k]=c[l2++];
//        //  if(b[l1].sc<c[l2].sc) a[++k]=c[l2++];
//            else if(b[l1].sc>c[12].sc) a[++k]=b[l1++];
//        //  else if(b[l1].sc>c[l2].sc) a[++k]=b[l1++];
//            else {
//        //  else {
//                if(b[l1].id<c[l2].id) a[++k]=b[l1++];
//            //  if(b[l1].id<c[l2].id) a[++k]=b[l1++];
//                else a[++k]=c[l2++];
//            //  else a[++k]=c[l2++];
//            }
            if(b[l1].sc<c[l2].sc) a[++k]=c[l2++];
            else if(b[l1].sc>c[l2].sc) a[++k]=b[l1++];
            else {
                if(b[l1].id<c[l2].id) a[++k]=b[l1++];
                else a[++k]=c[l2++];
            }
        }
        while(l1<=n) a[++k]=b[l1++];
        while(l2<=n) a[++k]=c[l2++];
    }
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d%d",&n,&r,&q);tmp=2*n;
        for(int i=1;i<=tmp;i++){
            a[i].id=i;scanf("%d",&a[i].sc);
        }
        for(int i=1;i<=tmp;i++){
            scanf("%d",&a[i].wl);
        }
        sort(a+1,a+1+tmp,cmp);
        merge_sort();
        printf("%d\n",a[q].id);
    }
    return 0;
}

E The Binding of Isaac
基本的搜索题，找到秘密房间的数量。只和一个#相连的外围房间被视作秘密房间。

#include<iostream>
#include<stdio.h>
#include<string>
#include<string.h>
#include<algorithm>
using namespace std;

char mp[111][111];
int flag[111][111];
int dir[4][2]={0,1,0,-1,1,0,-1,0};

int n,m;
int check(int x,int y)
{
    if(mp[x][y]=='#') return 0;
    int ans=0;
    for(int i=0;i<4;i++){
        int xx = x+dir[i][1];
        int yy = y+dir[i][0];
        if(xx>=1&&xx<=n&&yy>=1&&yy<=m){
            if(mp[xx][yy]=='#')
                ans++;
        }
    }
    if(ans>1) return 0;
    return 1;
}


int main()
{
    int T;
    scanf("%d",&T);
    while(T--){
        scanf("%d%d",&n,&m);
        memset(mp,0,sizeof(mp));
        for(int i=1;i<=n;i++){
            scanf("%s",mp[i]+1);
        }
        memset(flag,0,sizeof flag);
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                if(mp[i][j]=='#'){
                    int x=i,y=j;
                    for(int k=0;k<4;k++){
                        int xx=x+dir[k][0];
                        int yy=y+dir[k][1];
                        if(check(xx,yy)){
                            flag[xx][yy]=1;
                        }
                    }
                }
            }
        }
        int ans=0;
        for(int i=0;i<=n+1;i++){
            for(int j=0;j<=m+1;j++){
                if(flag[i][j]) ans++;
            }
        }
        printf("%d\n",ans);
    }

    return 0;
}

F Feed the monkey
记忆化搜索|| DP D P ， dp[i][j][k][x] d p [ i ] [ j ] [ k ] [ x ] 表示当前还剩i个第一种水果，j个第二种水果，k个第三个水果没有分配并且当前以k水果结尾的方案数。

DP D P :

#include<iostream>
#include<string.h>
#include<stdio.h>
#include<algorithm>
#include<math.h>
using namespace std;
const int maxn = 1e5 + 10;
#define ll long long int
const ll mod = 1e9 + 7;
ll dp[55][55][55][3];

int main()
{
    int T; int n1, n2, n3, d1, d2, d3;
    scanf("%d", &T);
    while (T--) {
        scanf("%d %d %d %d %d %d", &n1, &n2, &n3, &d1, &d2, &d3);
        memset(dp, 0, sizeof dp);
        for (int i = 1; i <= min(d1, n1); i++) dp[n1 - i][n2][n3][0] = 1;
        for (int i = 1; i <= min(d2, n2); i++) dp[n1][n2 - i][n3][1] = 1;
        for (int i = 1; i <= min(d3, n3); i++) dp[n1][n2][n3 - i][2] = 1;
        for (int i = n1; i >= 0; i--)
            for (int j = n2; j >= 0; j--)
                for (int k = n3; k >= 0; k--) {
                    if ((i + j + k) == (n1 + n2 + n3)) continue;
                    for (int p = 1; p <= min(i, d1); p++) {
                        dp[i - p][j][k][0] = (dp[i - p][j][k][0] + (dp[i][j][k][1] + dp[i][j][k][2]) % mod) % mod;
                    }
                    for (int p = 1; p <= min(j, d2); p++) {
                        dp[i][j - p][k][1] = (dp[i][j - p][k][1] + (dp[i][j][k][0] + dp[i][j][k][2]) % mod) % mod;
                    }
                    for (int p = 1; p <= min(k, d3); p++) {
                        dp[i][j][k - p][2] = (dp[i][j][k - p][2] + (dp[i][j][k][1] + dp[i][j][k][0]) % mod) % mod;
                    }
                }
        ll ans = 0;
        for (int i = 0; i < 3; i++) (ans += dp[0][0][0][i]) %= mod;
        printf("%lld\n", ans);
    }
    return 0;
}

记忆化搜索

#include<iostream>
#include<stdio.h>
#include<queue>
#include<vector>
#include<string.h>
#include<algorithm>
using namespace std;
#define  LL long long

const LL mod=1000000007;
LL dp[55][55][55][4];
LL d1,d2,d3;
int vis[55][55][55][4];

LL dfs(LL x,LL y,LL z,LL pre)
{
    LL num=0;
    LL k=0;
    if(x!=0) k=1,num++;
    if(y!=0) k=2,num++;
    if(z!=0) k=3,num++;
    if(num==0) return 1;
    if(num==1){
        if(k==1&&x<=d1) return 1;
        if(k==2&&y<=d2) return 1;
        if(k==3&&z<=d3) return 1;
        return 0;
    }
    if(pre!=-1&&vis[x][y][z][pre]) return dp[x][y][z][pre];
    LL xx=min(x,d1);
    LL yy=min(y,d2);
    LL zz=min(z,d3);
    LL ans=0;
    if(pre==-1){
        for(LL i=1;i<=xx;i++){
            (ans+=dfs(x-i,y,z,1))%=mod;
        }
        for(LL i=1;i<=yy;i++){
            (ans+=dfs(x,y-i,z,2))%=mod;
        }
        for(LL i=1;i<=zz;i++){
            (ans+=dfs(x,y,z-i,3))%=mod;
        }
    }
    if(pre==1){
        for(LL i=1;i<=yy;i++){
            (ans+=dfs(x,y-i,z,2))%=mod;
        }
        for(LL i=1;i<=zz;i++){
            (ans+=dfs(x,y,z-i,3))%=mod;
        }
    }
    if(pre==2){
        for(LL i=1;i<=xx;i++){
            (ans+=dfs(x-i,y,z,1))%=mod;
        }

        for(LL i=1;i<=zz;i++){
            (ans+=dfs(x,y,z-i,3))%=mod;
        }
    }
    if(pre==3){
        for(LL i=1;i<=xx;i++){
            (ans+=dfs(x-i,y,z,1))%=mod;
        }
        for(LL i=1;i<=yy;i++){
            (ans+=dfs(x,y-i,z,2))%=mod;
        }

    }
    if(pre!=-1)  dp[x][y][z][pre]=ans,vis[x][y][z][pre]=1;
    return ans;
}

int main()
{
    LL T;
    scanf("%lld",&T);
    while(T--){
        LL n1,n2,n3;
        scanf("%lld%lld%lld%lld%lld%lld",&n1,&n2,&n3,&d1,&d2,&d3);
        for(int i=0;i<=n1;i++)
            for(int j=0;j<=n2;j++)
                for(int k=0;k<=n3;k++)
                    for(int t=0;t<=3;t++)
                        vis[i][j][k][t]=0;
        cout<<dfs(n1,n2,n3,-1)<<endl;

    }

    return 0;
}

G Triple Nim
博弈题目，要求一个数字分成三个数字并且这三个数字的异或和为0。暴力打表，找到在二进制每增加一个高位1，答案为之前的三倍加一。即 ans[i]=ans[i−1]∗3+1 a n s [ i ] = a n s [ i − 1 ] ∗ 3 + 1 ;

#include<iostream>
#include<stdio.h>
#include<queue>
#include<vector>
#include<string.h>
#include<algorithm>
using namespace std;

const int maxn=1e2+10;
const int mod=1e9+7;

int mp[33][33][33];

void f(int x)
{
    int ans=0;
    for(int i = 1;i<=500;i++){
        for(int j=i+1;j<=500;j++){
            for(int k=j+1;k<=500;k++){
                if(i+j+k!=x) continue;
                if((i^j^k)==0)
                    ans++;
            }
        }
    }
    cout<<x<<" "<<ans<<endl;

}

int main()
{
    int T;
    scanf("%d",&T);
    while(T--){
        int n;
        scanf("%d",&n);
        if(n&1){
            printf("0\n");
        }else{
            int num=0;
            while(n){
                if(n&1) num++;
                n>>=1;
            }
            if(num==1){
                printf("0\n");
            }else{
                long long int ans = 1;
                for(int i=2;i<num;i++){
                    ans=ans*3+1;
                }
                printf("%lld\n",ans);
            }
        }
    }


    return 0;
}

H Memory Leak
内存分配的模拟题
I Rock Paper Scissors
J Execution of Paladin
对三张炉石传说卡牌直接模拟搞

#include<iostream>
#include<stdio.h>
#include<queue>
#include<vector>
#include<string.h>
#include<algorithm>
using namespace std;

const int maxn=1e2+10;
const int mod=1e9+7;


int main()
{
    int T;
    cin>>T;
    while(T--){
        int n,hp;
        scanf("%d %d",&n,&hp);
        char s[maxn];
        int lingjun=0;
        int c21=0;
        int old=0;
        getchar();
        for(int i=1;i<=n;i++){
            gets(s);
            if(s[0]=='M'){
                lingjun++;
            }
            if(s[0]=='B'){
                c21++;
            }
            if(s[0]=='O'){
                old++;
            }
        }
        int atk=0;
        atk+=c21*(2+lingjun*2);
        atk+=old*(lingjun*2+2+n-1);
        if(hp-atk>0){
            printf("Tell you a joke, the execution of Paladin.\n");
        }else{
            printf("Mrghllghghllghg!\n");
        }
    }

    return 0;
}

K Reversed Words
每个单词反向输出

#include<iostream>
#include<stdio.h>
#include<string>
#include<algorithm>
using namespace std;

int main()
{
    int T;
    while(~scanf("%d",&T)&&T){
        string s;
        while(T--){
        while(cin>>s){
            char c;
            reverse(s.begin(),s.end());
            cout<<s;
            c=getchar();
            if(c=='\n')
                break;
            else{
                printf(" ");
            }
        }
            printf("\n");

        }
    }
    return 0;
}

L Password

Irish_Moonshine
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第十一届山东省大学生程序设计竞赛
m0_53846741的博客
05-15 426
第十一届山东省大学生程序设计竞赛 B. Build Roads 题意：给定一个长度为n的序列，构建一个无向图，无相图边长为gcd(a[i],a[j])gcd(a[i],a[j])gcd(a[i],a[j])，为从区间 [L,R]中的随机数。但是n最大为2e5，L和R为2e5，不能直接考虑最小生成树算法，需找规律，当L==RL==RL==R时，所有的gcd(a[i],a[j])gcd(a[i],a[j])gcd(a[i],a[j])全部为L，所以图的总长度为L∗(n−1)L*(n-1)L∗(n−1)。还有一条
第十一届山东省大学生程序设计竞赛题解（9 / 13）
繁凡さん的博客
05-18 2513
体验不是太好，后面的题都不是很想补 B 边权为 gcd⁡(ai,aj)\gcd(a_i, a_j)gcd(ai​,aj​)，显然如果存在一个点 axa_xax​ 是素数，则从该点向所有的点连边，这样连接的 n−1n-1n−1条边的权值都是1，答案就是 n−1n-1n−1 。 若 L=RL=RL=R，则 R+L+1=1R+L+1=1R+L+1=1，模1之后得到的显然都是0，也就是说 n2n^2n2 条边的权值都是 LLL，答案显然就是 L×(n−1)L\times (n-1)L×(n−1)。 然后因为 nn
Execution of Paladin（山东省第七届acm j题）
原点
06-25 558
省赛的时候,由于我是个英语渣，题意完全看不懂，也没玩过这个游戏，队友在那里抱着字典翻译了一个多小时，愣是没有翻译出来，最后也没有做出来，有点遗憾，但也没有办法。     回来以后还是没有看懂，就上网看看别人说的，慢慢的懂了。（不得不说太坑）     其实4种卡片，有两个能攻击的，其他两个不能直接攻击，只能凑人数和为那两个能直接攻击的加攻击力。         Coldlight Ora
2020年第十四届山东大学程序设计竞赛（重现赛）题解(C D F L)
Sqssq的博客
05-30 750
#include <iostream> #include <string> using namespace std; int main() { string a, b = "", c = ""; cin >> a; for (int i = 0; i < a.size(); ++i) { if (i % 2 == 0) b += a[i]; else .
[简单思维题]Sequence(山东省第九届ACM大学生程序设计竞赛E题)
dingfei496705的博客
05-14 160
Problem Description We define an elementa_iai​in a sequence "good", if and only if there exists aj(1\le j < i)j(1≤j<i)such thata_j < a_iaj​<ai​.Given a permutationppof integ...
山东省第一届ACM大学生程序设计竞赛(原题) Ivan comes again!
MY Blog
04-04 812
Ivan comes again! Time Limit: 1000MS Memory limit: 65536K 题目描述 The Fairy Ivan gave Saya three problems to solve (Problem F). After Saya finished the first problem (Problem H), here comes th
2016中北大学ACM程序设计新生赛题解
陌上尘的博客
12-22 2692
中北大学新生赛题解
题解 | #武汉工程大学第六届ACM程序设计竞赛（同步赛）#
最新发布
2301_79125431的博客
04-29 1617
各位，如果来了，就来了，别慌了，看命吧， 各位，如果来了，就来了，别慌了，看命吧，慌改变不了什么，还是要打工吃饭的。#铜五铁六真的存在吗？(51062)# #铜五铁六真的存在吗？# 我选铜五必存！#牛客帮帮团来啦！有问必答(50227) #牛客帮帮团来啦！有问必答# 25届双非java后端求助。请问各位大佬，现在双非后端很难进大厂，所以杭州亚信科技 26号做的笔试，有牛友收到面试通知了吗本菜鸟双非零实习零竞
华东交通大学2023年ACM“双基”程序设计竞赛标程
华鑫的专栏
11-17 106
我阐释你的梦，hr面完快三个月，问了不下七次，还在这里说“同学，不急，我们部门还在对焦噢”，你对你摩洛哥炒饼，能不能痛快挂了啊，还有被捞的机会，在这里泡着，泡几。挺无语的一家公司，一面通过之后发我二面链接，腾讯会议上写着产品二面，我当时还纳闷，结果那边的hr告诉我发错了，我想着这也正常，就不理了。华为HR认为，秋招万法的那个源头，他是什么，如如。本人湖北人，cpper，两个都没有30小米：base南京，java岗，公积金是12%，进去大概率转go，应该是995联影：base武汉，公积金（基数少1k）是8。
2016年第七届山东省ACM省赛题解
fanbaobao829的博客
04-11 1210
1.     http://paste.ubuntu.com/24355497/ 2.     http://paste.ubuntu.com/24355502/ 3.     http://paste.ubuntu.com/24355485/ 4.     http://paste.ubuntu.com/24355513/ 5.     http://paste.ubuntu.com
第十一届山东省大学生程序设计竞赛，补题+总结
飞向更远的博客
05-14 290
B题 题目描述如下： 思路如下： 代码如下： C题 D题 G题 H题 M题
第七届山东省ACM省赛 H Memory Leak 模拟
colorfulshark
06-12 774
模拟变量的声明与使用，存在一种溢出的情况，有两种处理方式，要么为每一个变量分配内存空间，要么分配一个大内存空间，记录每个变量在这个内存区间的左右区间，我使用了第一种方式，比较耗费内存。这题有一个坑点，就是输入的内容是在变量名称一个空格之后，也就是内容的头部也可能会有空格，实际上题目说了，但是容易忽略，另外针对第一种方式，需要记录每一个变量的存储空间是否溢出，但是重新赋值之后可以使原本溢出的状态变为...
ACM新生赛部分题解
qq_52208569的博客
12-28 1125
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、永远的聪明王。1.题目描述2.代码如下：2.总结一、菜学长的糖糖。1.题目描述2.代码如下：3.总结总结 前言 ACM新生赛总结与感悟。 一、永远的聪明王。 1.题目描述 2.代码如下： （示例）： #include<stdio.h> #include<stdlib.h> struct Node//定义结构体，存放字符串和分数 { char a[100]; int score; }; i
【补题日记】训练日记4：山东大学(SDU)acm新生赛
cls1277的博客
11-24 666
前 牛客 题目还是偏简单的 我是零零碎碎用上课时间写的 所以当时可能处理细节不太到位吧 才提交了很多遍 但其实思路都比较简单 就是部分题有坑点吧 中 A 签到题（出题人说的） #include<iostream> #include<cstdio> #include<queue> #include<cstring> #include<string> #include<algorithm> #include<cmath> #in
2016山东省第七届ACM省赛-部分题解
Vision
04-11 2410
sdut-3560-julyed：http://acm.sdut.edu.cn/onlinejudge2/index.php/Home/Index/problemdetail/pid/3560.html Julyed Problem Description     Julyed is preparing for her CET-6. She has N words to rememb
C语言深入学习二
Sunwenyan_的博客
10-04 516
宏函数：例如：#define ADD ((x)+(y)); 1：要保证运算的完整性 2：在一定程度上会比普通函数效率高，省去出栈入栈 时间上的开销。 3：以空间换时间 #include<stdio.h> #include<stdlib.h> #define ADD(x,y) ((x) + (y)); int main(){ int a = 40, b = 20,c; c = ADD(a,b); printf("%d", c); } 调用惯例： 1：C语言默认
第十届山东省ACM程序设计竞赛（部分题解）
浦柳人的博客
05-15 585
第十届山东省ACM程序设计竞赛（补题） A：只和日有关系，不用管年； //#include<bits/stdc++.h> #include<stdio.h> #include<iostream> #include<algorithm> #include<stdlib.h> #include<string.h> #inclu...
BUAA整数排序（排序-基本题）
weixin_45927469的博客
06-30 2623
【问题描述】 从标准输入中输入一组互不相同的整数（个数不超过100）及排序方式，按照从小到大排序，输出按某种算法排序的结果及元素的比较次数。 说明：排序方式为一个1~5的整数，分别表示： 1：选择排序，比较次数是指选择未排序部分的最小元素时的比较次数。 2：冒泡排序，比较次数是指相邻元素的比较次数，若某趟排序中没有进行数据交换，就认为排序结束。 3：堆排序，比较次数是指根元素调整过程中根元素与子树根结点的比较次数，即下面算法中红色语句的执行次数： void adjust(int k[ ],int i,int
第七届ACM程序设计竞赛 (SDIBT)
ZCY的博客
04-15 1024
1.淘气的蜡笔小鑫   蜡笔小鑫真是又闲又淘气，他看到走廊上的灯都是灭的，就跑过去捣乱。每个灯泡都有自己的开关，用来控制灯的状态（开或者关）。如果灯灭了，按一下开关即开灯，再按一次即关灯。假设走廊里有n个灯泡，蜡笔小鑫就沿着走廊来回走n次。每次都是沿走廊走下去然后再回来，并且当他在走第i次时，都会按一下所有位置可被i整除的灯的开关（每次他都只在去的时候按下开关，回来的时候未进行任何操作），例如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值