yoj87题

最新推荐文章于 2024-07-18 16:42:53 发布
最新推荐文章于 2024-07-18 16:42:53 发布
阅读量284 收藏 1
点赞数
文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/skyheartfly/article/details/121708347
版权

 

 

 

#include <stdio.h>

#include <math.h>

int i2;

int x[10002], y[10002], mark[102][102], mark1[102][102], x11[10002], y11[10002];

double R[102][102], G[102][102], B[102][102], R1[102][102], G1[102][102], B1[102][102];

int judge(double x, double y, double z);

int c = 0;

int main()

{

    char r, g, b;

    int n, m;

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

    int i, j, k, l, i1, j1;

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

    {

        for (j = 0; j < m; j++)

        {

            scanf(" %c %lf %c %lf %c %lf", &r, &R[i][j], &g, &G[i][j], &b, &B[i][j]);

            if ((R[i][j] == 0) && (G[i][j] == 0) && (B[i][j] == 0))

            {

                x[c] = i;

                y[c] = j;

                mark[i][j] = 1;

                c++;

            }

        }

    }

    k = c;

    if (k == n * m)

    {

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

        {

            for (j = 0; j < m; j++)

            {

                printf("%c %0.lf %c %0.lf %c %0.lf ", r, R[i][j], g, G[i][j], b, B[i][j]);

            }

            printf("\n");

        }

    }

    else

    {

        while (1)

        {

            int p = 0;

            for (i = 0; i < c; i++)

            {

                double r1 = 0, g1 = 0, b1 = 0, c1 = 0;

                if (mark[x[i]][y[i]] && (!mark[x[i] + 1][y[i]] || !mark[x[i] - 1][y[i]] || !mark[x[i]][y[i] + 1] || !mark[x[i]][y[i] - 1])) //确定第几轮 ,因为是按顺序更新像素，每一轮更新的像素要储存到新的数组中，否则会影响下一个像素的条件判断

                {                                                                                                                           

                    if (x[i] == 0 && y[i] == 0)

                    {

                        double r1 = 0, g1 = 0, b1 = 0, c1 = 0;

                        if (judge(R[x[i] + 1][y[i]], G[x[i] + 1][y[i]], B[x[i] + 1][y[i]]))

                        {

                            r1 += R[x[i] + 1][y[i]];

                            g1 += G[x[i] + 1][y[i]];

                            b1 += B[x[i] + 1][y[i]];

                            c1++;

                        }

                        if (judge(R[x[i]][y[i] + 1], G[x[i]][y[i] + 1], B[x[i]][y[i] + 1]))

                        {

                            r1 += R[x[i]][y[i] + 1];

                            g1 += G[x[i]][y[i] + 1];

                            b1 += B[x[i]][y[i] + 1];

                            c1++;

                        }

                        if (c1 != 0) //除数不能为零，以下同理

                        {

                            R1[x[i]][y[i]] = ceil(r1 / c1);

                            G1[x[i]][y[i]] = ceil(g1 / c1);

                            B1[x[i]][y[i]] = ceil(b1 / c1);

                        }

                    }

                    else if (x[i] == n - 1 && y[i] == 0)

                    {

                        double r1 = 0, g1 = 0, b1 = 0, c1 = 0;

                        if (judge(R[x[i] - 1][y[i]], G[x[i] - 1][y[i]], B[x[i] - 1][y[i]]))

                        {

                            r1 += R[x[i] - 1][y[i]];

                            g1 += G[x[i] - 1][y[i]];

                            b1 += B[x[i] - 1][y[i]];

                            c1++;

                        }

                        if (judge(R[x[i]][y[i] + 1], G[x[i]][y[i] + 1], B[x[i]][y[i] + 1]))

                        {

                            r1 += R[x[i]][y[i] + 1];

                            g1 += G[x[i]][y[i] + 1];

                            b1 += B[x[i]][y[i] + 1];

                            c1++;

                        }

                        if (c1 != 0)

                        {

                            R1[x[i]][y[i]] = ceil(r1 / c1);

                            G1[x[i]][y[i]] = ceil(g1 / c1);

                            B1[x[i]][y[i]] = ceil(b1 / c1);

                        }

                    }

                    else if (x[i] == 0 && y[i] == m - 1)

                    {

                        double r1 = 0, g1 = 0, b1 = 0, c1 = 0;

                        if (judge(R[x[i] + 1][y[i]], G[x[i] + 1][y[i]], B[x[i] + 1][y[i]]))

                        {

                            r1 += R[x[i] + 1][y[i]];

                            g1 += G[x[i] + 1][y[i]];

                            b1 += B[x[i] + 1][y[i]];

                            c1++;

                        }

                        if (judge(R[x[i]][y[i] - 1], G[x[i]][y[i] - 1], B[x[i]][y[i] - 1]))

                        {

                            r1 += R[x[i]][y[i] - 1];

                            g1 += G[x[i]][y[i] - 1];

                            b1 += B[x[i]][y[i] - 1];

                            c1++;

                        }

                        if (c1 != 0)

                        {

                            R1[x[i]][y[i]] = ceil(r1 / c1);

                            G1[x[i]][y[i]] = ceil(g1 / c1);

                            B1[x[i]][y[i]] = ceil(b1 / c1);

                        }

                    }

                    else if (x[i] == n - 1 && y[i] == m - 1)

                    {

                        double r1 = 0, g1 = 0, b1 = 0, c1 = 0;

                        if (judge(R[x[i] - 1][y[i]], G[x[i] - 1][y[i]], B[x[i] - 1][y[i]]))

                        {

                            r1 += R[x[i] - 1][y[i]];

                            g1 += G[x[i] - 1][y[i]];

                            b1 += B[x[i] - 1][y[i]];

                            c1++;

                        }

                        if (judge(R[x[i]][y[i] - 1], G[x[i]][y[i] - 1], B[x[i]][y[i] - 1]))

                        {

                            r1 += R[x[i]][y[i] - 1];

                            g1 += G[x[i]][y[i] - 1];

                            b1 += B[x[i]][y[i] - 1];

                            c1++;

                        }

                        if (c1 != 0)

                        {

                            R1[x[i]][y[i]] = ceil(r1 / c1);

                            G1[x[i]][y[i]] = ceil(g1 / c1);

                            B1[x[i]][y[i]] = ceil(b1 / c1);

                        }

                    }

                    else if (x[i] == 0 && y[i] != 0 && y[i] != m - 1)

                    {

                        double r1 = 0, g1 = 0, b1 = 0, c1 = 0;

                        if (judge(R[x[i] + 1][y[i]], G[x[i] + 1][y[i]], B[x[i] + 1][y[i]]))

                        {

                            r1 += R[x[i] + 1][y[i]];

                            g1 += G[x[i] + 1][y[i]];

                            b1 += B[x[i] + 1][y[i]];

                            c1++;

                        }

                        if (judge(R[x[i]][y[i] + 1], G[x[i]][y[i] + 1], B[x[i]][y[i] + 1]))

                        {

                            r1 += R[x[i]][y[i] + 1];

                            g1 += G[x[i]][y[i] + 1];

                            b1 += B[x[i]][y[i] + 1];

                            c1++;

                        }

                        if (judge(R[x[i]][y[i] - 1], G[x[i]][y[i] - 1], B[x[i]][y[i] - 1]))

                        {

                            r1 += R[x[i]][y[i] - 1];

                            g1 += G[x[i]][y[i] - 1];

                            b1 += B[x[i]][y[i] - 1];

                            c1++;

                        }

                        if (c1 != 0)

                        {

                            R1[x[i]][y[i]] = ceil(r1 / c1);

                            G1[x[i]][y[i]] = ceil(g1 / c1);

                            B1[x[i]][y[i]] = ceil(b1 / c1);

                        }

                    }

                    else if (x[i] == n - 1 && y[i] != 0 && y[i] != m - 1)

                    {

                        double r1 = 0, g1 = 0, b1 = 0, c1 = 0;

                        if (judge(R[x[i] - 1][y[i]], G[x[i] - 1][y[i]], B[x[i] - 1][y[i]]))

                        {

                            r1 += R[x[i] - 1][y[i]];

                            g1 += G[x[i] - 1][y[i]];

                            b1 += B[x[i] - 1][y[i]];

                            c1++;

                        }

                        if (judge(R[x[i]][y[i] + 1], G[x[i]][y[i] + 1], B[x[i]][y[i] + 1]))

                        {

                            r1 += R[x[i]][y[i] + 1];

                            g1 += G[x[i]][y[i] + 1];

                            b1 += B[x[i]][y[i] + 1];

                            c1++;

                        }

                        if (judge(R[x[i]][y[i] - 1], G[x[i]][y[i] - 1], B[x[i]][y[i] - 1]))

                        {

                            r1 += R[x[i]][y[i] - 1];

                            g1 += G[x[i]][y[i] - 1];

                            b1 += B[x[i]][y[i] - 1];

                            c1++;

                        }

                        if (c1 != 0)

                        {

                            R1[x[i]][y[i]] = ceil(r1 / c1);

                            G1[x[i]][y[i]] = ceil(g1 / c1);

                            B1[x[i]][y[i]] = ceil(b1 / c1);

                        }

                    }

                    else if (y[i] == 0 && x[i] != 0 && x[i] != n - 1)

                    {

                        double r1 = 0, g1 = 0, b1 = 0, c1 = 0;

                        if (judge(R[x[i] - 1][y[i]], G[x[i] - 1][y[i]], B[x[i] - 1][y[i]]))

                        {

                            r1 += R[x[i] - 1][y[i]];

                            g1 += G[x[i] - 1][y[i]];

                            b1 += B[x[i] - 1][y[i]];

                            c1++;

                        }

                        if (judge(R[x[i]][y[i] + 1], G[x[i]][y[i] + 1], B[x[i]][y[i] + 1]))

                        {

                            r1 += R[x[i]][y[i] + 1];

                            g1 += G[x[i]][y[i] + 1];

                            b1 += B[x[i]][y[i] + 1];

                            c1++;

                        }

                        if (judge(R[x[i] + 1][y[i]], G[x[i] + 1][y[i]], B[x[i] + 1][y[i]]))

                        {

                            r1 += R[x[i] + 1][y[i]];

                            g1 += G[x[i] + 1][y[i]];

                            b1 += B[x[i] + 1][y[i]];

                            c1++;

                        }

                        if (c1 != 0)

                        {

                            R1[x[i]][y[i]] = ceil(r1 / c1);

                            G1[x[i]][y[i]] = ceil(g1 / c1);

                            B1[x[i]][y[i]] = ceil(b1 / c1);

                        }

                    }

                    else if (y[i] == m - 1 && x[i] != 0 && x[i] != n - 1)

                    {

                        double r1 = 0, g1 = 0, b1 = 0, c1 = 0;

                        if (judge(R[x[i] - 1][y[i]], G[x[i] - 1][y[i]], B[x[i] - 1][y[i]]))

                        {

                            r1 += R[x[i] - 1][y[i]];

                            g1 += G[x[i] - 1][y[i]];

                            b1 += B[x[i] - 1][y[i]];

                            c1++;

                        }

                        if (judge(R[x[i]][y[i] - 1], G[x[i]][y[i] - 1], B[x[i]][y[i] - 1]))

                        {

                            r1 += R[x[i]][y[i] - 1];

                            g1 += G[x[i]][y[i] - 1];

                            b1 += B[x[i]][y[i] - 1];

                            c1++;

                        }

                        if (judge(R[x[i] + 1][y[i]], G[x[i] + 1][y[i]], B[x[i] + 1][y[i]]))

                        {

                            r1 += R[x[i] + 1][y[i]];

                            g1 += G[x[i] + 1][y[i]];

                            b1 += B[x[i] + 1][y[i]];

                            c1++;

                        }

                        if (c1 != 0)

                        {

                            R1[x[i]][y[i]] = ceil(r1 / c1);

                            G1[x[i]][y[i]] = ceil(g1 / c1);

                            B1[x[i]][y[i]] = ceil(b1 / c1);

                        }

                    }

                    else

                    {

                        double r1 = 0, g1 = 0, b1 = 0, c2 = 0;

                        if (judge(R[x[i] - 1][y[i]], G[x[i] - 1][y[i]], B[x[i] - 1][y[i]]))

                        {

                            r1 += R[x[i] - 1][y[i]];

                            g1 += G[x[i] - 1][y[i]];

                            b1 += B[x[i] - 1][y[i]];

                            c2++;

                        }

                        if (judge(R[x[i]][y[i] - 1], G[x[i]][y[i] - 1], B[x[i]][y[i] - 1]))

                        {

                            r1 += R[x[i]][y[i] - 1];

                            g1 += G[x[i]][y[i] - 1];

                            b1 += B[x[i]][y[i] - 1];

                            c2++;

                        }

                        if (judge(R[x[i] + 1][y[i]], G[x[i] + 1][y[i]], B[x[i] + 1][y[i]]))

                        {

                            r1 += R[x[i] + 1][y[i]];

                            g1 += G[x[i] + 1][y[i]];

                            b1 += B[x[i] + 1][y[i]];

                            c2++;

                        }

                        if (judge(R[x[i]][y[i] + 1], G[x[i]][y[i] + 1], B[x[i]][y[i] + 1]))

                        {

                            r1 += R[x[i]][y[i] + 1];

                            g1 += G[x[i]][y[i] + 1];

                            b1 += B[x[i]][y[i] + 1];

                            c2++;

                        }

                        if (c2 != 0)

                        {

                            R1[x[i]][y[i]] = ceil(r1 / c2);

                            G1[x[i]][y[i]] = ceil(g1 / c2);

                            B1[x[i]][y[i]] = ceil(b1 / c2);

                        }

                    }

                    if (R1[x[i]][y[i]] || G1[x[i]][y[i]] || B1[x[i]][y[i]])

                    {

                        mark1[x[i]][y[i]] = 0;

                        k--;

                        x11[p] = x[i];

                        y11[p] = y[i];

                        p++;

                    }

                }

            }

            for (i2 = 0; i2 < p; i2++) //一轮更新完毕后，将本轮更新的数赋值到原数组（注意，数值和判断数组mark都要用新数组储存）

            {

                mark[x11[i2]][y11[i2]] = mark1[x11[i2]][y11[i2]];

                R[x11[i2]][y11[i2]] = R1[x11[i2]][y11[i2]];

                B[x11[i2]][y11[i2]] = B1[x11[i2]][y11[i2]];

                G[x11[i2]][y11[i2]] = G1[x11[i2]][y11[i2]];

            }

            if (k == 0)

                break;

        }

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

        {

            for (j = 0; j < m; j++)

            {

                printf("%c %0.lf %c %0.lf %c %0.lf ", r, R[i][j], g, G[i][j], b, B[i][j]);

            }

            printf("\n");

        }

    }

    return 0;

}

int judge(double x, double y, double z)

{

    if (x || y || z)

        return 1;

    else

        return 0;

}

gone of the wind
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
YOJ211 严神的机器人 IV
Elijahqi
06-16 216
注意细节即可 #include<bits/stdc++.h> using namespace std; inline int gcd(int x,int y){ return !y?x:gcd(y,x%y); } int n,a,b; int main(){ scanf("%d%d%d",&n,&a,&b); long long t=(long long)a*b/gcd(a,b); int ans=n-n/a-n/b+2*(n/t); printf("%d\n.
C#练习题答案: 反恐精英系列【难度：1级】--景越C#经典编程题库,1000道C#基础练习题等你来挑战
景越c#经典编程题库(csharp programming training)
10-17 107
反恐精英系列【难度:1级】: 答案1: namespace CS { using System; using System.Collections.Generic; public class Kata { private static Dictionary<string, int> s = new Dictionary<strin...
Python题库——答案
Jia ming 的日常学习笔记
10-17 5331
python 习题答案
迷宫（YOJ2.0中的题）
Fool256353的博客
10-31 67
同时上一层递归对下一层递归的返回值进行判断，如果为1，则直接return 1，否则进行下一步尝试（当时是写return 0，就错了，悲），当所有都尝试完的时候都不行就return 0。当要移动的时候判断下一格是否为1，为1则移动，移动时将原来的位置变为0，这样就不会返回去，而且因为静态数组设置时，所有的变量都为0，所以移动时不会超出迷宫。三次都是在第一层函数递归的return出了问题，草稿没打是这样的，虽然我不知道打了草稿会不会也是这样。根据第一层的返回值输出YES或者NO。三次WA后才得到的AC。
图像处理（YOJ2.0中的题）
Fool256353的博客
10-21 128
先说一下感受吧：真的是爽死了，不过因为有提前打草稿（电纸书神！），所以中间的思路完全没出错，有什么错的话，也只有在输入上有问题。写了一个小时多，真的爽，希望以后能秒了。因为我有写注释，就不写解题思路了，核心就是一开始设置的两个数组，一个记录各点的数据，另一个记录坏点坐标（实际上你看名称也可以看得懂）虽然英文名称可以让我们一看就懂，但是太长了搞得我有点头晕，以后试试缩写吧。题目如上（至于YOJ2.0，那是我学校的做题网站）最后就得了90分，有一个数据超时了（爽死了）
yoj维护
ez_yww的博客
10-23 546
维护启动容器docker start yoj暂停容器docker stop yoj重启容器docker restart yoj进入容器的终端docker attach yok保存容器的镜像docker commit yoj yoj_back:tag查看所有容器docker ps -a查看所有镜像docker images删除容器docker rm yoj删除镜像docker rmi yoj_back
递归倒置字符数组（YOJ2.0中的题）
Fool256353的博客
10-31 53
md什么东西，给我了4个Compile Error。而且又简单到不行，怎么配得上难度5的啊？我按我的风格略改了一下代码格式。结果是只要填补充的代码。
YOJ1961-软件工程
w2259318982的博客
03-30 360
题目描述 Merlin 的软件工程老师 Max 布置了开发一个软件的大作业。由于这是一个大型软件，所以单靠 Merlin 一个人不可能在预定时间内做完，必须与其他人合作。 由于大家都要做这个作业，所以 Merlin 理所当然找他的同班同学，但是同班同学的能力是参差不齐的。全班都很明确，这个工程可以分为 nnn 个不同的部分，每个部分都是独立，并且每个人都有一定的能力完成其中一个部分。Merlin 认为，自己应该去做项目经理的职位，把 nnn 个部分分配给若干个人，不同的部分可以分配给一个人或者多个人，但
YOJ3176值日安排
w2259318982的博客
03-29 928
题目描述 新生报到，OJ 实验室新来了 777 名同学，为了安排一周的宿舍值日情况，决定按照年龄从小到大的顺序依次安排到周一至周日。 请完善如下程序： #include <stdio.h> #include <stdlib.h> struct studentInfo { int num; //学生学号 char name[20]; //学生姓名，默认不超过20个字符 int year; //学生出生年份 int m
mysql可视化工具sqlyog
01-07
MySQL是世界上最受欢迎的开源数据库管理系统之一，而SQLyog是为MySQL设计的一款强大的图形化管理工具，它提供了直观且用户友好的界面，使得数据库管理、查询、数据导入导出等任务变得更为简单。...
Yejq-online-judge:中山大学云平台编程语言在线评估系统
03-11
YOJ目标 如何设计数据库？ 如何分析系统？ 如何使用python？ 如何使用网络技术？ 目标 互联网上有很多在线裁判系统。 其中一些用于编程语言学习，例如python和c。 系统上发布了很多问题，人们可以将解决方案上载到...
Home-Equity-Loan:住房抵押贷款违约概率的预测
04-08
房屋净值贷款 房屋净值贷款（HMEQ）报告5960份房屋净值贷款的特征和欠款信息。 房屋净值贷款是指债务人将其房屋净值用作基础抵押品的贷款。 在这个项目中，我们预测贷款违约的可能性。...YOJ：现任工作年限
JDK 1.6 Windows 版本
04-14
JDK 1.6 windows版本，有时候从官网下载比较慢，如果有需要的可以直接在这里下载， ...http://jimloveq.quickconnect.cn/d/s/548185039500745519/4ciAIy-fYti3ONnzQJ0Yoj51sCK8HZcW-BiDgpHMwnAc_ 密码：20200414
【视觉SLAM】 十四讲ch5习题
weixin_68880273的博客
07-18 1107
介绍了《视觉SLAM十四讲》的ch5习题
磁力链磁力链磁力链.txt
最新发布
07-22
磁力链
“人力资源+大数据+薪酬报告+涨薪调薪”
07-22
人力资源+大数据+薪酬报告+涨薪调薪，在学习、工作生活中，越来越多的事务都会使用到报告，通常情况下，报告的内容含量大、篇幅较长。那么什么样的薪酬报告才是有效的呢？以下是小编精心整理的调薪申请报告，欢迎大家分享。相信老板看到这样的报告，一定会考虑涨薪的哦。
安装graphviz和pygraphviz
07-22
pygraphviz 是一个Python库，它是Graphviz图形可视化软件的Python接口。Graphviz是一个开源的图形可视化软件，广泛用于创建和编辑有向图和无向图。pygraphviz使得Python开发者能够轻松地创建和操作图形，以及执行图形的布局和可视化。 一、pygraphviz的主要功能 创建和编辑图形：pygraphviz允许开发者通过Python代码来创建图形，包括添加节点、边等元素，并且可以编辑这些元素的属性，如颜色、形状、标签等。 图形布局：pygraphviz支持多种图形布局算法，如dot、neato、circo等，开发者可以根据需要选择合适的算法来优化图形的布局。 图形可视化：pygraphviz可以将创建和编辑好的图形保存为图片文件，支持多种图片格式，如PNG、JPEG等，方便开发者进行展示和分享。
BrainF**k Devlopment Toolkit
07-22
BrainF**k Devlopment Toolkit(BFDTK)，可用于开发BrainF**k程序。
基于UC3875控制的大功率全桥开关电源设计（提供原理图、PCB图）
07-22
基于UC3875控制的大功率全桥开关电源设计（提供原理图、PCB图） 1、使用UC3875为控制芯片； 2、NCP1253为辅助电源设计，输出12V，给控制芯片供电； 3、UC3845做BOOST升压控制，实现市电整流升压到400V； 4、全桥拓扑设计结构； 5、后级输出同步整流设计； 6、过压硬件保护电路； 7、过流硬件保护电路； 8、提供原理图、PCB图；
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值