SDUT 2017 春夏组队训练赛3

最新推荐文章于 2024-10-11 21:38:42 发布
最新推荐文章于 2024-10-11 21:38:42 发布
阅读量463 收藏
点赞数
分类专栏： 训练赛 Problem Set 文章标签： c语言 团队 练习赛
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Herman_Lien/article/details/72589181
版权

Sat May 20 12:55:34 CST 2017
回归acm集训队第一场组队赛！不管队友是谁，团队协作+不懈努力！gangbadei！
SDUT 2017 春夏组队训练赛3
Sat May 20 21:44:29 CST 2017
解题+补题: L_Z_S
SDUT 2017 春夏组队训练赛3 C D F I J L

C - Shooting Game

来源：FZU - 2144
在小队成员一同分析过后，结论这是一道贪心题，类似时间管理。然而代码过程频频出错，还是经验不足啊！总结题的要点有：
1.数学过程有大坑！
-每个输入数据都能用int来存，但是解方程过程中大量乘法易爆出范围（用对每一个乘法运算先×1.0解决了）；
-输入作为有效数据计入的条件分析不很到位；
-测评系统不支持long long 的 %lld形式输入（%I64d可行，FOJ的特点？）；
2.对数据的分析判断，一定要好好结合题意！凭感觉不分析没好事。。

ac代码1：

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <queue>
#include <math.h>
#define N 100100
using namespace std;
struct info
{
    double s;
    double e;
} mo[N];
bool cmp(struct info a, struct info b)
{
    return a.e <= b.e;
}
int main ()
{
    int t, kase = 0;
    int n;
    long long r;
    long long dx, dy, dz;
    long long x, y, z;
    long long a, b, c;
    double ch;
    cin >> t;
    while(t--)
    {
        cin >> n >> r;
        int l = 0;
        for(int i = 0; i < n; i++)
        {
            scanf("%I64d %I64d %I64d", &x, &y, &z); //若用%lld会tle，神奇！
            scanf("%I64d %I64d %I64d", &dx, &dy, &dz);
            a = dx * dx + dy * dy + dz * dz;
            b = 2 * (x * dx + y * dy + z * dz);
            c = x * x + y * y + z * z - r * r;
            ch = 1.0 * b * b - 4 * a * c;
            if(ch >= 0)
            {
                double al, be;
                al = - ((b + sqrt(ch)) / 2 / a);
                be = - ((b - sqrt(ch)) / 2 / a);
                if (be >= 0)
                    mo[l].s = al, mo[l++].e = be;
            }
        }
        sort(mo, mo + l, cmp);
        int sum = 0;
        if (l)
        {
            sum++;
            double time = mo[0].e;
            for(int i = 1; i < l; )
            {
                while(i < l && mo[i].s <= time)
                    i++;
                if (i < l)
                    sum++;
                time = mo[i].e;
            }
        }
        printf("Case %d: %d %d\n", ++kase, l, sum);
    }
    return 0;
}

ac代码2：

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <queue>
#include <math.h>
#define N 100100
using namespace std;
struct info
{
    double s;
    double e;
} mo[N];
bool cmp(struct info a, struct info b)
{
    return a.e <= b.e;
}
int main ()
{
    int t, kase = 0;
    int n, r;
    int dx, dy, dz;
    int x, y, z;
    double a, b, c;
    double ch;
    cin >> t;
    while(t--)
    {
        cin >> n >> r;
        int l = 0;
        for(int i = 0; i < n; i++)
        {
            scanf("%d %d %d", &x, &y, &z);
            scanf("%d %d %d", &dx, &dy, &dz);
            a = 1.0 * dx * dx + 1.0 * dy * dy + 1.0 * dz * dz;  //cause: may overflow during every multiplication operation
            b = 2 * (1. * x * dx + 1. * y * dy + 1. * z * dz);
            c = 1. * x * x + 1. * y * y + 1. * z * z - 1. * r * r;
            ch = b * b - 4 * a * c;
            if(ch >= 0)
            {
                double al, be;
                al = - ((b + sqrt(ch)) / 2 / a);
                be = - ((b - sqrt(ch)) / 2 / a);
                if (be >= 0)
                    mo[l].s = al, mo[l++].e = be;
            }
        }
        sort(mo, mo + l, cmp);
        int sum = 0;
        if (l)
        {
            sum++;
            double time = mo[0].e;
            for(int i = 1; i < l; )
            {
                while(i < l && mo[i].s <= time)
                    i++;
                if (i < l)
                    sum++;
                time = mo[i].e;
            }
        }
        printf("Case %d: %d %d\n", ++kase, l, sum);
    }
    return 0;
}

F - A-B Game

FZU - 2147
知识点：某数a的余数最大时对应除数为：a / 2 + 1 ( / 为整除)。
此题wa了好久，最后把所有输入从scanf改为cin就对了，神奇！%FZU！
当然有知道为什么的大神，求留言！
（貌似和上题同一个毛病！？%lld不可用）
wa：

#include <stdio.h>
#include <string.h>

int main(void)
{
    long long a, b;
    int t, c;


    scanf("%d", &t);
    int kase = 0;
    while (t--)
    {
        scanf("%lld %lld", &a, &b);
        c = 0;
        while (a > b)
        {
            a = a / 2 + 1;
            c++;
        }
        printf("Case %d: %d\n", ++kase, c);
    }
    return 0;
}

ac：

#include <stdio.h>
#include <string.h>
#include <iostream>
using namespace std;
int main(void)
{
    long long a, b;
    int t, c;
    cin >> t;
    int kase = 0;
    while (t--)
    {
        cin >> a >> b;
        c = 0;
        while (a > b)
        {
            a = a / 2 + 1;
            c++;
        }
        printf("Case %d: %d\n", ++kase, c);
    }
    return 0;
}

果真！！下面是ac代码

#include <stdio.h>
#include <string.h>

int main(void)
{
    long long a, b;
    int t, c;


    scanf("%d", &t);
    int kase = 0;
    while (t--)
    {
        scanf("%I64d %I64d", &a, &b);
        c = 0;
        while (a > b)
        {
            a = a / 2 + 1;
            c++;
        }
        printf("Case %d: %d\n", ++kase, c);
    }
    return 0;
}

I - Moon Game

FZU - 2148
题意：一个平面上给出多个不重点，且任意三点不在一条直线上，求能作出的凸四边形（convex quadrilateral）个数。
解法一：四点中任取两点作直线，之后再取另两点作直线，若两次操作余下两点均在直线的同侧或均在异侧，则为凸四边形，否则为凹四边形；作个图就明了了。
解法一
解法二：将四个点两两相连，得到四个三角形。若是从凹四边形判断则有
SΔABC=SΔABD+SΔACD+SΔBCD ；若是从凸四边形判断则有
SΔABD+SΔCBD=SΔBAC+SΔDAC ；面积则用海伦公式求得。
解法二
（具体实现后面再补）

J - Fire Game

FZU - 2150
这是一道简单暴力搜索题，但原谅我们半天没怼出方案来，自己挖了坑跳不出来了。其中有趣的想法是：
L:连通分量+最短路（硬是没想出只有一个连通分量时怎么做，局限在单点开始的bfs中…）；
S:生成树的”最长路“（忽略了这是地图，是有贿赂（回路）阻挠的！图 != 树）
解法：两起点一同入队bfs。
下面是我自己优化过的ac代码，但可能仍有可改进的地方：

#include <cstdio>
#include <cstring>
#include <queue>
#include <cmath>
#include <algorithm>

using namespace std;

typedef struct Posi
{
    int x, y;
}Grid;

char Map[15][15];
int book[15][15];  //相当于vis[]和访问次序记录数组
int dx[4] = {1, 0, 0, -1};  //四方向
int dy[4] = {0, 1, -1, 0};
int n, m;

int bfs(int, int, int, int);
int main(void)
{
    int t, kase = 0;

    scanf("%d", &t);
    while (t--)
    {
        memset(Map, 0, sizeof(Map));
        scanf("%d %d ", &n, &m);
        for (int i = 1; i <= n; i++)//从1开始，和memset配合，节省了对边界的特殊判断~
        {
            char tmp[15];
            scanf("%s", tmp);
            for (int j = 1; j <= m; j++)//同上
                Map[i][j] = tmp[j - 1];
        }
        int ans = 100;
        for (int i = 1; i <= n; i++) //四重for
            for (int j = 1; j <= m; j++)
            {
                if (Map[i][j] == '#')
                {
                    for (int k = i; k <= n; k++) //k = 1优化，去重省了近一半时间(原time:187ms)
                        for (int l = 1; l <= m; l++) //l = j不可行
                        {
                            if (Map[k][l] == '#')
                            {
                                int tmp = bfs(i, j, k, l);
                                if (tmp < ans)
                                    ans = tmp;
                            }
                        }
                }
            }
        if (ans >= 100)
            ans = -1;
        printf("Case %d: %d\n", ++kase, ans);
    }
    return 0;
}

int bfs(int x, int y, int a, int b)
{
    memset(book, -1, sizeof(book));
    Grid Queue[112];   //手工简单队列，方便快捷省时间~
    int head = 0, tail = 0;
    Queue[0].x = x, Queue[0].y = y;
    book[x][y] = 0;
    if (x != a || y != b)  //防止同一起点重复入队（对于这个代码不判断也行）
    {
        Queue[1].x = a, Queue[1].y = b;
        tail++;
        book[a][b] = 0;
    }
    int ans = -1;
    while (head <= tail)
    {
        int f = 0;
        int tx = Queue[head].x;
        int ty = Queue[head].y;
        for (int i = 0; i < 4; i++)
        {
            int fx = tx + dx[i];
            int fy = ty + dy[i];

            if (Map[fx][fy] == '#' && book[fx][fy] == -1)
            {
                f = 1;
                book[fx][fy] = book[tx][ty] + 1;
                Queue[++tail].x = fx;
                Queue[tail].y = fy;
            }
        }
        if (!f && ans < book[tx][ty])
            ans = book[tx][ty];
        ++head;
    }
    for (int i = 1; i <= n; i++)  //判断是否走完所有'#'
        for (int j = 1; j <= m; j++)
        {
            if (Map[i][j] == '#' && book[i][j] == -1)
            {
                ans = 1000;
                break;
            }
        }//可优化省去，只在主函数里出现一次两层for，但貌似对时间没什么影响
    return ans;
}//time:93ms

下面是和Shang讨论后得到的用queue实现的代码，优化了一些地方，但queue的用时保持在了300ms左右。（或许有更好的，待mark）

#include <cstdio>
#include <cstring>
#include <queue>
#include <cmath>
#include <algorithm>

using namespace std;

typedef struct node
{
    int x;
    int y;
}Node;
char Map[12][12];
int vis[12][12]; //同时记录访问次序
Node Grid[110]; //存储每个草地位置，目的把四重for简化为两重
int dx[4] = {1, 0, 0, -1};
int dy[4] = {0, 1, -1, 0};
int bfs(int u, int v);  //u、v表示草地编号
int n, m;
int l;  //用于记录草地总数
int main()
{
    int t;
    scanf("%d", &t);
    int cnt = 0;
    while(t--)
    {
        memset(Map, 0, sizeof(Map));
        scanf("%d%d", &n, &m);
        l = 0;
        for(int i = 1; i <= n; i++)
        {
            scanf("%s", Map[i] + 1);  //能想到的最快的输入方法，mark！
            for(int j = 1; j <= m; j++)
            {
                if(Map[i][j] == '#')
                {
                    Grid[l].x = i;
                    Grid[l++].y = j;
                }
            }
        }
        int Min = 9999;
        for(int i = 0; i < l; i++)
        {
            for(int j = i; j < l; j++)
            {
                memset(vis, -1, sizeof(vis));
                Min = min(bfs(i, j), Min);
            }
        }
            printf("Case %d: %d\n", ++cnt, Min >= 9999 ? -1 : Min);

    }
    return 0;
}
int bfs(int u, int v)
{
    queue <Node> q;
    vis[Grid[u].x][Grid[u].y] = 0;
    q.push(Grid[u]);
    if (u != v)
    {
        vis[Grid[v].x][Grid[v].y] = 0;
        q.push(Grid[v]);
    }
    int ans = -1;
    int sum = 0; //记录烧过的草地数
    while (!q.empty())
    {
        Node tmp = q.front();
        q.pop();
        sum++;
        int f = 1;
        for (int i = 0; i < 4; i++)
        {
            int nx = tmp.x + dx[i];
            int ny = tmp.y + dy[i];
            if (Map[nx][ny] == '#' && vis[nx][ny] == -1)
            {
                f = 0;
                vis[nx][ny] = vis[tmp.x][tmp.y] + 1;
                Node next = {nx, ny};
                q.push(next);
            }
        }
        if (f && ans < vis[tmp.x][tmp.y]) //对路尽头进行处理
            ans = vis[tmp.x][tmp.y];
    }
    if (sum < l) //判断是否全部走完
        ans = 9999;
    return ans;
}

D、L是水题，略。
总结这一次的组队赛，自己还有许多待完成的事，并无成功与否之分，但有所悟有所成长。

Herman_Lien
关注
专栏目录
zcmu-1977
yu121380的博客
07-17 269
1977: 黑暗意志 Time Limit: 1 Sec  Memory Limit: 128 MB Submit: 89  Solved: 46 [Submit][Status][Web Board] Description 在数千年前潘达利亚从卡利姆多分离之时，迷雾笼罩着这块新形成的大陆，使它不被外来者发现。迷雾同样遮蔽着这片大陆古老邪恶的要塞——雷神的雷电王座。在雷神统治时期，他的要塞...
蓝桥杯 2017年C语言混搭 C/C++
博客标题不能为空我也没办法
02-28 1003
1、贪吃蛇长度 +-------------------------------------------------+ | | | H###### #### | | # # ...
SDUT 2017 春夏组队训练赛11 2017 6 10
axuhongbo的博客
06-10 322
本次比赛做出四个题，题目是2015长春区域赛的题目 其中l题为求表面积的题目 先算出方块的总个数然后*5，减去重叠部分即可（根据具体例子写） J题 是一个简单的优化，算1000个数中不相同的i,j,k三个值异或的最大值，之前一直受long long 的坑影响，这次又换了复杂度，其中圣昭写的i(0,n) j(i+1,n) k(0,n) 三重for复杂度为 (n^3 )/2,而用另一种方法写出
A - Cut the sticks SDUT 2017算法训练赛
BePosit的博客
06-28 566
You are given a number of sticks of varying lengths. You will iteratively cut the sticks into smaller sticks, discarding the shortest pieces until there are none left. At each iteration you will deter...
SDUT--组队赛心得总结
Gold_Medal的博客
07-30 252
今天这是第二次组队赛了，因为疫情的原因，这学年的不少赛事都取消了，所以我们组队也比较晚。 在家里的组队赛都是在群里进行讨论，虽然交流方式有些限制，但是队友们的积极性仍然很高。 组队赛对比个人赛来讲，其实更加磨练人，提高人。不仅可以提高团队合作能力，而且在和队友的考论中也可以取长补短。 因为竞赛的时间都比较长，个人赛末尾的时候难免会有“心有余而力不足”的感觉。而组队赛中，队员们可以互相鼓励，听着屏幕那边敲击键盘的声音，队员们为自己那小小的梦想而发出热火朝天的讨论声音。内心，何不触动？ 在比赛开始之后，
2020.7.30 SDUT暑假集训组队赛总结
sdut_you的博客
07-30 159
今天是第二次参加组队赛，比第一次和队友之间的配合默契了许多。队友之间相互分工，相互讨论，很有意思。就是这次比赛的输入，输出形式有所变化。我和队友们都没有做过类似的题，导致我们wa了一下午，一个题也没有做出来，我们心态都快崩了。晚上补题的时候才发现这个细节，以后再遇到这种题就不会再wa了。希望我们这个小队能一直走下去啊！（D_L_S） ...
SDUT3903 CF（dp+贪心） 2017山东ACM省赛
雪的期许
03-20 420
CFTime Limit: 1000 ms Memory Limit: 65536 KiBhttps://acm.sdut.edu.cn/onlinejudge2/index.php/Home/Index/problemdetail/pid/3903.htmlSubmit Statistic DiscussProblem DescriptionLYD loves codeforces since ...
SDUT 3914 校赛~校赛~
yxc9806的博客
06-05 431
SDUT 3914 校赛~校赛~Time Limit: 1000MS Memory Limit: 65536KBProblem DescriptionSDUT 的校赛是从 2009 年开始的，康纳每年看到比赛之后，往往就会喊一声 “ma ji ya ba ku nai + 年份的缩写”。比如说 2009 年就会说 “ma ji ya ba ku nai 9”。年份的缩写是一个字符串形式的，但是如果当
SDUT 2017 离散数学考试题
Wzking的博客
06-02 3588
集合的包含Time Limit: 1000 ms Memory Limit: 65536 KiBSubmit StatisticProblem Description已知含n个元素的集合的子集A和B，用位串表示法判断是否有A⊆B。Input多组测试数据，每组测试数据第1行输入正整数n(1 &lt;= n &lt;= 100)，表示集合元素个数，第2行输入位串表示法形式的集合A，第3行输入位串表示法...
stepbystep:SDUTACM训练计划
06-10
"SDUTACM训练计划"是一个面向初学者到高级选手的逐步学习路径，旨在帮助学生提升在算法竞赛（如ACM/ICPC）中的技能。这个训练计划可能包含一系列的练习题、教程和代码示例，以HTML为主要的展示形式。HTML（HyperText...
2013-2017 ICPC中国大陆区域赛真题模拟训练指南
3. **真题训练链接**：文档提供了从2013年至2017年每个年度的铜牌和银牌题目的在线模拟训练链接，这些链接位于vjudge.net平台上，方便参赛者进行实战演练。 4. **历年真题整理**：对2013年至2017年每年的比赛题目...
SDUT---OJ《数据结构与算法》实践能力专题训练3 栈与队列
m0_46062697的博客
11-13 464
A - 数据结构实验之栈与队列一：进制转换 Description 输入一个十进制非负整数，将其转换成对应的 R (2 <= R <= 9) 进制数，并输出。 Input 第一行输入需要转换的十进制非负整数； 第二行输入 R。 Output 输出转换所得的 R 进制数。 Sample Input 1279 8 Output 2377 #include <iostream> #include <bits/stdc++.h> using na..
离散数学 SDUT 4182 哪款赛车最佳？
OneTrianee的博客
03-28 383
1.题目 哪款赛车最佳？ Time Limit: 1000 ms Memory Limit: 65536 KiB Problem Description 四名专家对四款赛车进行评论。 专家A说：a号赛车是最好的。 专家B说：b号赛车是最好的。 专家C说：c号不是最佳赛车。 专家D说：专家B说错了。 事实上只有一款赛车最佳，且只有一名专家说对了，其他三人都说错了。请编程输出最佳车的...
ACM_2017级SDUTOJ程序设计基础与新手入门培训
这份资料面向的是2017级的SDUTOJ（Sunshine University Training Online Judge）新手，为他们提供了一套完整的新手入门训练材料。 知识点一：ACM竞赛的介绍与重要性 ACM竞赛是全球范围内极具影响力的计算机程序设计...
C语言[函数嵌套找大数]
2401_87108776的博客
10-11 376
max4是4个数中最大的，max2是两个数中最大的，max4是将max2嵌套调用。两个调用函数max4和max2。使用一个主函数main。
【水果识别】基于matlab GUI形态学水果大小识别【含Matlab源码 920期】.md
10-15
CSDN Matlab武动乾坤上传的资料均有对应的代码，代码均可运行，亲测可用，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博客文章底部QQ名片； 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 图像识别：表盘识别、车道线识别、车牌识别、答题卡识别、电器识别、跌倒检测、动物识别、发票识别、服装识别、汉字识别、红绿灯识别、火灾检测、疾病分类、交通标志牌识别、口罩识别、裂缝识别、目标跟踪、疲劳检测、身份证识别、人民币识别、数字字母识别、手势识别、树叶识别、水果分级、条形码识别、瑕疵检测、芯片识别、指纹识别
【瑕疵检测】基于matlab瓶盖瑕疵检测【含Matlab源码 730期】.md
10-15
CSDN Matlab武动乾坤上传的资料均有对应的代码，代码均可运行，亲测可用，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博客文章底部QQ名片； 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 图像识别：表盘识别、车道线识别、车牌识别、答题卡识别、电器识别、跌倒检测、动物识别、发票识别、服装识别、汉字识别、红绿灯识别、火灾检测、疾病分类、交通标志牌识别、口罩识别、裂缝识别、目标跟踪、疲劳检测、身份证识别、人民币识别、数字字母识别、手势识别、树叶识别、水果分级、条形码识别、瑕疵检测、芯片识别、指纹识别
Shapely-1.6.4.post2-cp35-cp35m-win_amd64.whl
10-15
Shapely-1.6.4.post2-cp35-cp35m-win_amd64.whl
Apache Flink CEP复杂事件处理详解及实战案例
最新发布
10-15
内容概要：本文详细介绍了Apache Flink的FlinkCEP模块，讲解了其安装配置、事件流处理基础及其应用场景，其中包括电商欺诈检测、网络监控、实时交易系统的模式匹配以及社交媒体趋势分析的具体实现。通过多个实战示例演示了如何利用正则表达式定义复杂模式并在大数据流中识别有用的事件序列，适用于需要从实时数据流中挖掘价值的多种场景。 适用人群：具备一定大数据处理经验的研发人员、架构师以及相关领域的研究人员和技术爱好者。 使用场景及目标：针对金融反欺诈、网络安全、高频交易、物联网数据分析等领域，实现复杂事件模式的实时监测和处理。 其他说明：本文提供了大量的实践代码样本，旨在引导读者掌握Flink CEP的实际应用技巧。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值