UI 设计师不容错过的12款APP UI 交互设计

原型演示和下载地址:http://doc.mockplus.cn/?p=1549

易错点解析

  1. 稍加同学规律找对了,可惜忘记每一遍都要初步化;
  2. 稍稍同学规律找对了,可惜跟机器人结果的争执统一反了;
  3. 多少同学规律找对了,可惜计算 4 的翻番时也有意无意算进 2 的倍数了;
  4. 稍稍同学规律找对了,可惜忘记是倍数

参考思路

四维偏序关系(partial ordering relation)计数。

虽说有三个维度,但出于每一个维度的界定较小,所以状态数有限,唯有 \(4^4 = 256\)
个,完全可以用标记数组记录一下:先预处理出同样种情状的卡牌有微微张,对于每种卡牌,找出比它弱的卡牌数量,最终根据卡牌的输入顺序直接计算输出答案。时间复杂度
\(O(256 \times 256 + N)\) 或 \(O(256N)\) 。

L2M 说可以将每个意况加起来,时间复杂度 \(O(4
\times 256 + N)\) 。

标志数组可以是 ‘D’ – ‘A’ 变基映射成 0 – 3 的四维属性数组,那样大体会有 5
或 8 个 for
循环;也足以是储存哈希(hash)成四进制数的一维状态数组;当然某些同学直接打表算状态也得以,就是有点奇怪hhh。

参考思路

遍历计数。时间复杂度 \(O(L^2)\) 或
\(O(L^3)\) ,其中 \(L = |S|\) 即字符串的长度。
从左到右扫四遍字符串,总括当中扫过的 ‘0’ 和 ‘1’
的多少,若数量相当于则扫过的子串符合条件,举办添加。
由于一个字符串的子串有 \(L + (L – 1) +
\ldots + 2 + 1 = \frac{L(L + 1)}{2}\) 个,所以可能要遍历 \(L\) 次起点, \(1 \ldots (L – i)\) 次终点。

Hint

样例解释:
对于样例 1 ,可以周全分组为最多 6 组,每组有 3 名男生 4
名女孩子,不要求再抽人展开装扮情侣活动。
对于样例 2 ,先抽出一对送给 FFF 团,之后就跟样例 1 一样啊。
对于样例 3 ,只可以抽出 18
对玩假扮情侣活动,然后下一行为剩下的可怜妹纸出口 happy single dog! 。

易错点解析

  1. 不亮堂有没有同桌把 Oyk 看成了 Qyk …(逃;

在互动上,那款APP的两点在于选取停车点后出现的音讯卡,并且迅速地绘制最佳路径,穿插停车点的数码并推送停车点图片音讯。

Sample Output

Oyk Oyk!
Oyk Oyk!
diu,Czj!

那款APP的定义促使人思考手机阅读的形式,可以点击和滑动书籍标题,当你挑选了一本,就会弹出书籍封面。当您读书的时候,你如故可以滑动选择书籍,可以肆意地变换到其它的标题。

参照思路

签到题,公式乱搞就行。

那款APP把用户的注意力聚焦到了领航的进度当中,将发现音乐那一个互动进度变得顺滑和机智。其余那种交互方式也加强了动用的沉浸感,是一款创意和互相出彩的音乐播放器。

Hint

Sample Input

3
3
1 2 4
4
1 5 6 9
4
1 4 2 2

2. Bthere

参考代码

标程 1 (\(O(256N)\)):

#include <stdio.h>

const int N = 1e5 + 10;
const int M = 4;
int a0[N], a1[N], a2[N], a3[N];
int b[M][M][M][M];

int main() {
    int n;
    scanf("%d\n", &n);
    for (int i = 0; i < n; ++i) {
        scanf("%c%c%c%c\n", &a0[i], &a1[i], &a2[i], &a3[i]);
        a0[i] = 'D' - a0[i]; a1[i] = 'D' - a1[i]; a2[i] = 'D' - a2[i]; a3[i] = 'D' - a3[i];
        b[a0[i]][a1[i]][a2[i]][a3[i]]++;
    }
    for (int i = 0; i < n; ++i) {
        int ans = 0;
        for (int j0 = 0; j0 <= a0[i]; ++j0)
            for (int j1 = 0; j1 <= a1[i]; ++j1)
                for (int j2 = 0; j2 <= a2[i]; ++j2)
                    for (int j3 = 0; j3 <= a3[i]; ++j3)
                        ans += b[j0][j1][j2][j3];
        printf("%.2f\n", (double)ans/n);
    }
    return 0;
}

标程 2 (\(O(256 \times 256 +
N)\)):

#include <stdio.h>

const int N = 1e5 + 10;
const int M = 4;
int a0[N], a1[N], a2[N], a3[N];
int b[M][M][M][M], c[M][M][M][M];

int main() {
    int n;
    scanf("%d\n", &n);
    for (int i = 0; i < n; ++i) {
        scanf("%c%c%c%c\n", &a0[i], &a1[i], &a2[i], &a3[i]);
        a0[i] = 'D' - a0[i]; a1[i] = 'D' - a1[i]; a2[i] = 'D' - a2[i]; a3[i] = 'D' - a3[i];
        b[a0[i]][a1[i]][a2[i]][a3[i]]++;
    }
    for (int i0 = 0; i0 < M; ++i0)
        for (int i1 = 0; i1 < M; ++i1)
            for (int i2 = 0; i2 < M; ++i2)
                for (int i3 = 0; i3 < M; ++i3)
                    for (int j0 = 0; j0 <= i0; ++j0)
                        for (int j1 = 0; j1 <= i1; ++j1)
                            for (int j2 = 0; j2 <= i2; ++j2)
                                for (int j3 = 0; j3 <= i3; ++j3)
                                    c[i0][i1][i2][i3] += b[j0][j1][j2][j3];
    for (int i = 0; i < n; ++i)
        printf("%.2f\n", (double)c[a0[i]][a1[i]][a2[i]][a3[i]]/n);
    return 0;
}

ZYJ 的四进制标记解法(O\((4 \times 256
\times 256 + N)\),即使多了个常数 4
但就是自豪地比标程快(骄傲.jpg)):

#include <stdio.h>

int N;
int cardSet[100100];
int cardMap[256];
int leqCount[256];

void addCard(int idx, const char* card) {
    int val = 0;
    for (const char *p = card + 3; p >= card; --p) {
        val <<= 2;
        val |= 'D' - *p;
    }
    cardSet[idx] = val;
    ++cardMap[val];
}

void read() {
    char card[5];
    scanf("%d", &N);
    for (int i = 0; i < N; ++i) {
        scanf("%s", card);
        addCard(i, card);
    }
}

int leqCard(int a, int b) {
    for (int i = 4; i > 0; --i) {
        if ((a & 3) > (b & 3)) {
            return 0;
        }
        a >>= 2;
        b >>= 2;
    }
    return 1;
}

void work() {
    for (int i = 0; i < 256; ++i) {
        if (cardMap[i]) for (int j = 0; j < 256; ++j) {
            if (cardMap[j] && leqCard(j, i)) {
                leqCount[i] += cardMap[j];
            }
        }
    }
    for (int i = 0; i < N; ++i) {
        printf("%.2lf\n", (double)leqCount[cardSet[i]] / N);
    }
}

int main() {
    read();
    work();
    return 0;
}

到您旅行到一座新的都市的时候,填饱自己的肚子是最焦躁的事体。Bon
App!可能是你最佳的选取,查看本地美食测评,探寻美食沙龙,同时也足以登录和在线分享温馨的美食心得。

Output

对应每组数据输出一个质数,为 cgy 绩点排行的质数计数法。

5. WIP Discover Music

Output

每组数据占一行,输出 ljc 至少要未雨绸缪的糖的多寡。

Siren那款APP用了大气不比的互动动画,当您向左或向右滑动时,移动分化延迟的因素爆发不安的意义。为用户提供了对于主页面全部结构和流程的额外反馈。此外,那款应用还运用裁减的要一贯展开界面的交互区域,同时确保重点音信一贯维持展现。

易错点解析

  1. 乘法溢出:因为 int
    乘法有可能溢出,为了防止高精总结,干脆每回都让首个数除以某个数跟它的最大公约数,只要到终极时首个数成为
    1 ,表明它在那个历程中被除掉啊;
  2. 约分:整个经过实际上就一定于约分,大家在约分时就是在找分子和分母的最大公约数并同除,这么些相应相当好明白;
  3. 运算结合性:现代人类设计出来的算术乘法、算术除法符号是左结合的,也就是早晚是从左往右算的,那一点应该没问题啊,所以
    a / b / c 一定等价于 ((a / b) / c) 也没问题吧….

那款APP的导航交互丰盛考虑到了小屏幕的配备的布局问题,用户可以在屏幕底边拖动以体现折叠导航,3D的折叠功效也是负有科学和技术感。

Description

引人侧目, cgq 因为脸黑而并未去玩法特狗这一款游戏,不过她COO gou4shi1
平常问他某个英灵厉不厉害,为了一劳永逸, cgq
决定写个程序给所有英灵打个分。
在法特狗里,每张卡牌都对应着一个英灵。设 \(n\) 为卡池里有所卡牌的多寡, \(m\) 为卡池里有稍许张卡牌 y 使得,英灵 x
的拥有属性都超出等于英灵 y 的相应属性(注意, y 能够是 x
本身),则英灵x的评分为 \(\frac{m}{n}\) 。
现行以为每个英灵只有四个特性(耐久、敏捷、魔力、幸运),每个属性唯有多个级次(ABCD
, A 最强, D 最弱)。给出一个卡池所有英灵的习性,必要给拥有英灵评分。

在大城市停车永远是一项万分胃痛的事体。高效便民地找到停车场是一件卓殊火急的工作。

Sample Input

3
2
4 4
no
3
1 2 4
yes
4
1 2 2 4
yes

这款由Mockplus打造的APP原型内容的切换自然流畅,品尝美食时忽然闪现的灵感,就足以透过点击应用下方导航栏的公布按钮,登时地记录下来。在布局直观的美食佳肴推荐的页面流中,也能便捷地收获餐厅的切实音讯和图表。

问题大意

给定一串除法式子 a / b / c / …
,可以对该姿势任意加括号以变更其中一些运算符(除号变乘号),问是或不是存在那样一种加括号方案,使得整个式子的分子得以整除分母。

Description

cgy是一个很有偏执性精神障碍的人,他一看到小数就全身愁肠。但是有一天,他相见了那般一条唯有整数和除号构成的姿势:1/2/4/16
,他的性心理障碍又来了,加上了括号让式子变成了 (1/2)/(4/16)=2
把它变成了整数。可是走着走着,他又碰到了一个墙上写满了那些风格的姿态,cgy突然发现有些式子可以透过加括号来让结果变成整数,有些却非凡。可是他手下没有纸和笔,于是就没有把这几个想法写下来,现在您能透过这一多级数字来判定他们是还是不是足以由此加括号成为整数么

11. Animated Sliding Tab Bar by Virgil Pana

Description

一个字符串的子串表示原字符串中一段连接的部分。例如,字符串”121″的子串总共有三个,它们各自是”1″(前一个),”2″,”1″(后一个),”12″,”21″和”121″。但”11″不是”121″的子串,因为多少个’1’在原串中不总是。大家觉得空串也不是子串。
现给你一个只蕴涵’0’和’1’二种字符的字符串,问它涵盖相同’0’和’1’的子串有多少个。例如,字符串”0101″中符合条件的子串有4个。它们分别是”01″(前一个),”10″,”01″(后一个),”0101″。

这几个文章是或不是给您的并行设计带来了满满的灵感呢?要求分明的是,产品中保有的相互的目标,都是升高用户体验,太过头花哨和复杂的互相可能会弄巧成拙。如若还有越多的互动文章推荐的话,欢迎在数短论长中提出。​​​​

Sample Input

4
5
6

透过动态的图片过渡和背景象切换和有些单独的微动画元素(包含独轮车的尾气),Bthere高效地传递了品牌的趣味性,从而也更上一层楼了APP的用户转化率和停留时间。

Input

首先行输入一个正整数 \(T \leq 10\)
代表着练习组数。
接下来 \(3T\) 行,每 \(3\) 行首先是一个正整数 \(2 \leq N \leq 1000\)
代表着特征值的个数,接下去一行是用空格隔开的特色值 \(A_i\) (其中 \(1 \leq A_葡京签到送彩金,i \leq 10^9\) 且 \(0 \leq i < N\) ),最后一行 ZetaGo
会给出它的判断结果 “yes” 或者 “no” 。

那款应用基于那样的概念:只必要轻点几下,用户就可以得到之前增进和标记的图纸;只需一键,就足以选拔想要的图形类型。整个进度令人联想到桌面上的图样检索,那样的操作仅仅在活动设备上就能落到实处。

Sample Output

0.500
0.707
0.000

F. 法特狗

10. Home Budget Feed Animation

Input

多组数据,每一组一行是 cgq 给出的一个正整数 n
,输入到文件结尾截至(\(n \leq
80\))。

8. Siren

C. ljc 吃糖

美食永远是让大家靠拢这一个世界一级的点子,这款APP的彼此也传言了那般的音讯。场景是在咖啡厅中提供降价券和折扣,客户就足以立即用手中的电子降价券购买心仪的佳肴。通过添加界面动画,全体交互变得生气勃勃,充满活力,并且还助长了有些微交互,趣味十足。

参考代码

标程:

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

int kase,n,x,c[1010];
int dp[1010];

int main(void)
{
    scanf("%d",&kase);
    while (kase--)
    {
        memset(dp,0,sizeof(dp));
        scanf("%d",&n);
        for (int i=0;i<n;++i)
            scanf("%d",&c[i]);
        scanf("%d",&x);
        for (int i=0;i<=x;++i)
            for (int j=0;j<n;++j)
                if (i>c[j] && dp[i-c[j]])
                {
                    if (!dp[i])
                        dp[i]=dp[i-c[j]]+1;
                    else
                        dp[i]=dp[i-c[j]]+1<dp[i]?dp[i-c[j]]+1:dp[i];
                }
                else if (i==c[j])
                    dp[i]=1;
        if (dp[x])
            printf("%d\n",dp[x]);
        else
            printf("%d\n",-1);
    }

    return 0;
}

ZYJ:

#include <stdio.h>

inline void getMin(int& a, const int b) {
    if (a > b) a = b;
}

const int INF = 0x3f3f3f3f;
const int MAXN = 101;
const int MAXX = 1010;

int N, amount;
int cost[MAXN];
int dp[MAXX];

void read() {
    scanf("%d", &N);
    for (int i = 0; i < N; ++i) {
        scanf("%d", cost + i);
    }
    scanf("%d", &amount);
}

void work() {
    dp[0] = 0;
    for (int i = 1; i <= amount; ++i) {
        int tmp = INF;
        for (int j = 0; j < N; ++j) {
            if (cost[j] <= i) {
                getMin(tmp, dp[i - cost[j]]);
            }
        }
        dp[i] = tmp + 1;
    }
    printf("%d\n", dp[amount] >= INF ? -1 : dp[amount]);
}

int main() {
    int T;
    scanf("%d", &T);
    while (T--) {
        read();
        work();
    }
    return 0;
}

7. Sport App by Sergey Valiukh

Output

输盛名字排列拼接方案,要在有着可行方案中满意字典序最小。

题材大意

求第 \(K\) 个质数的值

6. Cafe Coupon App

Sample Input

3
1 2 3
2 1 2

这款手机互相模拟了诚实阅读中的体验,用滑动和点击这么些大家习惯的竞相,创制了一种经典和高雅的阅读经验。

参照代码

#include <stdio.h>
#include <math.h>

double a, b;
double x, y, width, height;

inline double dist(double x1, double y1, double x2, double y2) {
    return sqrt(pow(x1 - x2, 2.f) + pow(y1 - y2, 2.f));
}

int main() {
    while (~scanf("%lf%lf", &a, &b)) {
        scanf("%lf%lf%lf%lf", &x, &y, &width, &height);
        double res = dist(a / 2.f, b / 2.f, x + width / 2.f, y + height / 2.f);
        printf("%.3f\n", res);
    }
    return 0;
}

那款APP的指点页色彩鲜艳、活泼可爱,是一款颇有特色的竞相作品,在冗长的APP指点页为用户提供了一份极佳的感受。

Input

第一行输入正整数 \(T \leq 100\)
代表一起有 \(T\) 种情况。
接下来 \(T\) 行,每行包罗几个正整数
\(N < 10^5\) 和 \(M < 10^5\) 代表着该种情状中有 \(N\) 名男生和 \(M\) 名女生。

首要的特色是侧面菜单打开时内容展现的“橡胶效果”,在显示屏上开拓侧边菜单后,也能显得所有内容的详细新闻。色彩的陪衬非凡卓殊明亮,激励用户越来越的操作;动画中轻微的弹跳感,使得应用全体承接着满满运动风。

Sample Input

1
0 8
4 2
6 4
8 6
10 8
12 10
14 12
16 14
18 16

题目大意

给定一连串几何个职责,每个职分都有一个先验条件 precondition 和完毕消耗
cost ,现在具有有限的不足再生资源数量 N
,问最少需求补充多少资源才能做到所有任务。

该问题是“给定不可补充资源,问最多能完毕哪些任务”的变种,难度持平。

易错点解析

  1. 封存 3
    位小数是骗你的。因为斐波那契是个整数数列,即便用公式算,考虑上精度损失等题材后收获的依然个整数;
  2. 不作回想化处理的递归是会晚点的。递归空间是一棵二叉树,不作纪念化处理的话最大有
    80 层,复杂度高达 O(2^N) 指数爆炸算到地老天荒;
  3. 不作纪念化处理的递推是唯恐会晚点的。因为有多组输入数据呀,你的复杂度是
    O(80T) 哦;
  4. 用浮点数类型递推到终极精度不够是会 WA
    的。有些同学就做了优化,从奇怪的地点获得了第 79 、 80
    项平昔用字符串输出, emmm… 也是可以的。

手机UI中的交互是保持产品鲜活生命力的源动力。好的交互能够援助用户疾速地获得反馈,认知布局,增强体验感和沉浸感。那里为大家整理了12款不错并具有创见的竞相小说,为你的产品设计流入灵感。

Sample Input

4
AAAA
AAAD
CBCD
DDDD

1. History Animation by UISTAR

Output

请你告诉 ZetaGo 它的论断结果对不对,输出 “AC” 或者 “WA”
表示对或错(不包蕴引号)。

12. Photo Navigation Concept by Chapps

Output

对应每一组奖状数据输出奖状焦点和文字区域主导的几何距离,保留 3 位小数。

易错点解析

  1. 这题没有说了然是平行于 x 轴的长,是平行于 y
    轴的宽,举报出题人;
  2. 那题没有说清楚 a / x / l 一定对应以及 b / y / w
    一定对应,举报出题人;
  3. 输入输出:如果用 scanf / printf 作输入输出,前者要指定具体是 %f /
    %lf / %Lf 的哪些,而后者的 float / double 都是用 %f 输出,当然 long
    double 仍旧用 %Lf ;
  4. 数据漂移:由于要统计并出口浮点数,部分用 float
    的同窗有可能会遇上浮点数数据漂移问题;

这款APP会提须求你附近的停车场定位以及收费标准。当您点击了一个一定后,就能查到还有多少结余车位,同时也提供了预定车位的路子,不至于开过去后吃闭门羹。

Hint

更为多的在磨砺的时候使用移动装备,保存数据并跟踪进程。运动应用程序近年来可怜受欢迎。这一款拥有通过动画交互达成效益的安插意见。结构卓殊简单:由侧边菜单和重心内容结合。菜单从左道友移动显示基本选项。

Description

L2M 未来科学和技术开发商厦研制了一款新的智能机器人 ZetaGo
,它可以把任何事物都盘算出一个表征值,在经过重排后方可就此做出一多样的表决。
为了检查 ZetaGo 的重排能力,需求人工举办监控学习(supervised
learning)训练。 LLM 作为 L2M
手下的一名实验员,就要天天开展如此的苦差事。
后日的重排规则是那般的:已知一组特征值 A ,要求重新排列后的组成 B
能够满意任意四个相邻元素的乘积(\(B_i *
B_{i+1}\))为 4 的翻番。 ZetaGo
经过表决运算后会给出是还是不是存在那样一种重排方案, LLM
要按照决定结果报告它对不对,以便校勘学习模型。
明日 LLM 实在太累呀,想拜托你帮扶助。

时光就是金钱,那句话在哪些时候都不会过时。那款财务APP可以让用户管理消费和收入,创造拓展数据库以跟踪财务流量和转变,从而取得圆满的计算音讯。GIF中流畅地展示了当下财务意况变动的交互,并且弹出了每一日的限额提醒,颇有特色。

Sample Output

1.00
0.75
0.50
0.25

3. Bon App!

题目大意

给定多个矩形,其中小矩形一定被套在大矩形之中。给出大矩形的长宽,小矩形的左上角顶点坐标和长宽,求出五个矩形宗旨的几何距离。

4. Parking Search by SELECTO

参考思路

贪得无厌算法。时间复杂度 \(O(klogk)\)

要是当前最大可用能量为 N ,职务队列为 prob[] ,借使一个职分 \(prob_i\) 无法被成功,一定是它的先验要求
\(prob_i.m1 > N\) ,否则由于
\(m1 \leq m2\)
一定成立,任何一个义务都得以被选拔成功。

再假定存在多个职责 a 和 b 可以按顺序已毕,那么势须要 \(a.m2 + b.m1 < b.m2 + a.m1\)
,因为先成功的天职会先开销能量,若前方职务消耗得太多,则会招致不满足后边任务的先验条件,进而必要不停地补偿能量。假如一多元职责都能知足这一尺度,就可以尽量少地填补能量,使得能量利用作用最大化。由此大家得以依照这一思索给任务排序。
愈来愈也足以转正为 \(a.m1 – a.m2 > b.m1 –
b.m2\) 即对差值排序,思想也是看似的。

Output

对于每一组数据,输出能凑齐报废金额的最少的发票张数,若是不可以正好凑齐则输出
-1 。

那款购物APP丰硕地运用了iOS
11的规划语言,做出了优良的卡片式界面,交互清晰自然,内容分布简练。对于iOS
11在UI上新转变和的设计规范,还足以看看那篇作品。

Sample Output

10

9. Shopping Cards

Hint

double 和 long double 精度都不难,求 80 次方会存不下。

题材大意

有 \(N\) 种物品和一个容量为 \(X\)
的背包,每种物品都有无限件可以利用。若存在一种方案使得刚刚放满背包,求那种方案中所使用物品的细小件数。

Input

输入第一行是一个整数 n ( \(1 \le n \le
100000\) ),代表卡池里拥有卡牌的数量。
接下去是 n
行,每行三个大写字母,分别表示每个英灵的确实、敏捷、魔力、幸运。

参照代码

#include <stdio.h>

#define LL long long
#define lld "%lld"

const int MaxN = 80;

LL fib[MaxN + 1] = {0, 1};

inline void init() {
    for (int i = 2; i <= MaxN; ++i) {
        fib[i] = fib[i - 1] + fib[i - 2];
    }
}

int main() {
    int N;
    init();
    while (~scanf("%d", &N)) {
        printf(lld".000\n", fib[N]);
    }
    return 0;
}

Input

首先行输入一个正整数 T 表示数据组数,每组第 1 行七个数 n, k,接下去 k
行为八个正整数 m1, m2。
确保拥有数据 \(T, n, k, m1, m2 \leq
1000\),且 \(m1 \geq m2\) 。

H. CG 之争

Output

输出为一个数,表示符合条件的子串的个数。注意最后有一个换行符。

Sample Output

6 0
6 1
0 18
happy single dog!

参考思路

巴什博弈变种,找出先手必败态,发现 \(N =
3\mathbb{k}\) 先手必败。时间复杂度 \(O(1)\) 。

可以先枚举出前多少个数比如 1 ~ 10 观望先手的胜败情形,发现 \(N = 3\)
是首先个先手必败态,想办法将必败态转移给对方就能获得胜利。发现别的数总能加
1 或 2 成为 3 的倍数,而其余 \(3\mathbb{k}\) 都不可能整除 \(2^{\mathbb{p}}\) ,剩下的数总会是 \(3\mathbb{m} + 1\) 或 \(3\mathbb{m} + 2\) ,那样只必要拿走 1
个或 2 个就能将 \(3\mathbb{m}\)
的动静转移给对方,直到 \(N = 3\)
,因而我们得以确定 \(N =
3\mathbb{k}\) 是本游戏的先手必败态。

由于数量较小,也同意递推的做法,复杂度 \(o(NlogN)\) 。原理是那般的,如若当前有
\(N\) 个,如若取走 \(2^{\mathbb{p}}\)
个后对手是必败态,表明这一局先手是顺利的,遍历一回所有的依样葫芦即可。这一思想实际看似于
SG 函数,各位可以自行去打听 SG 函数的规律,把那些题当作 SG 的入门题hhh。

J. 训练 ZetaGo

题材大意

加以若干个物品,每个物品含有三个属性,每个属性又有四种值,当且仅当一个物品所有特性的值都低于等于另一个物料,才方可说那一个物品比另一个物品。求对于自由一个物品,比它的物料数。

B. 数发票

Description

cgy 协会了某外出活动准备到大学报废,高校给了她必然的路费报废金额。而
cgy
平常是一个老大青睐收集公交车发票的人,他的手上有成百上千张不相同面值的发票,现在她想计算最少要有些张发票能够恰好达到报废金额。
cgy
忙着整理那些发票,于是把那么些职分交给了共同出外的您,你必要细致总计否则就拿不到出门的交通费了。

问题大意

有 \(N\) 种物品,每种物品有 \(X_i\) 个且价值为 \(W_i\)
。可以轻易接纳物品,求使得所取物品总价值不一致的方案数。

Sample Output

3
-1

参考代码

没找到标程,以下由 ZYJ 提供:

#include <stdio.h>
#include <algorithm>

using std::sort;

const int MaxN = 1000;

struct Problem {
    int precond, cost;
    int priority;
    bool operator<(const Problem& cmp) const {
        return priority > cmp.priority;
    }
} prob[MaxN];

int n, k;

void read() {
    scanf("%d%d", &n, &k);
    for (int i = 0; i < k; ++i) {
        scanf("%d%d", &prob[i].precond, &prob[i].cost);
        prob[i].priority = prob[i].precond - prob[i].cost;
    }
}

void work() {
    sort(prob, prob + k);
    int res = 0;
    for (int i = 0; i < k; ++i) {
        if (n >= prob[i].precond) {
            n -= prob[i].cost;
        } else {
            res += prob[i].precond - n;
            n = prob[i].precond - prob[i].cost;
        }
    }
    printf("%d\n", res);
}

int main() {
    int T;
    scanf("%d", &T);
    while (T--) {
        read();
        work();
    }
    return 0;
}

M. 光棍节活动

易错点解析

  1. 偏序关系不可比:由于 C/C++
    函数库里的排序方法要求从严弱序,而那边是四维偏序,即随意多少个物品
    \(X\) 和 \(Y\) ,当且仅当 \(X.p1 \leq Y.p1\) 且 \(X.p2 \leq Y.p2\) 且 \(X.p3 \leq Y.p3\) 且 \(X.p4 \leq Y.p4\) 都满意时才有 \(X \preccurlyeq Y\) ,比如 \(ABCD \preccurlyeq AABB\) ,但 \(ABCD\) 和 \(BACD\)
    不可相比。你能够按照偏序关系的概念来协调声明一(Meadjohnson)下,不问可知是不得以一贯开展相比较排序(comparison
    sort)的,纵然 hash 成四进制数也至极(数字本身也是严厉序);
  2. 数量漂移:由于要统计并出口浮点数,部分用 float
    的同班有可能会遇见浮点数数据漂移问题;
  3. 卡牌可再度:一张卡牌只可能是个别的 256 种意况,卡池里 \(N\)
    张牌肯定有双重的;但结尾却要依据卡牌的输入顺序来输出(即相当于可重复但差别);
  4. 反向映射:因为本来的属性值是 ‘A’ – ‘D’ ,倘诺按那个顺序映射成 0 – 3
    的话,几乎就是 ‘D’ < ‘A’ 等价于 3 > 0
    ,那样要小心,对属性值的涉嫌相比较要反着来;若是 0 – 3 代表 ‘D’ – ‘A’
    就毫无费那脑细胞了。

问题大意

求斐波那契数列的第 \(k\) 项值。

Output

对此每种状态,请你辅助统计出完美分组数和假扮情侣数,在一行中输出,用空格隔开。
一经存在没有组队的幸运儿,你可以再为 ta 们输出且只输出一行 “happy single
dog!” (不包蕴引号)聊表庆祝。

Sample Input

3
hello
world
zyj

参照思路

打表 or 回想化递推。递推的岁月复杂度 \(O(80)\) ,还有 \(O(N)\) 的输入输出。

因为浮点数类型存不下 80 次方这么大的数(存储位数不够 or
表示精度不够),可以查找一下题材给出的公式,简单精晓是斐波那契数列的通项公式;也足以搜索一下
C/C++ 语言是怎么处理大数统计、高精度科学总计的,用高精算法求 80
次方也能够。

Sample Input

1
2

Hint

样例解释:
先是组数据中 11=5+5+1=5+3+3 ,最少要用 3 张
第二组数据中不管多少张都凑不齐 7 元,输出 -1

Sample Output

2
3
107
41

参照代码

\(O(L^3)\) 复杂度的解法:

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

char str[101];

void read() {
    scanf("%s", str);
}

void work() {
    int len = strlen(str);
    int res = 0;
    for (int i = 0; i < len; ++i) {
        for (int j = i; j < len; ++j) {
            int zeroCnt = 0, oneCnt = 0;
            for (int k = i; k <= j; ++k) {
                str[k] == '0' ? ++zeroCnt : ++oneCnt;
            }
            if (zeroCnt == oneCnt) {
                ++res;
            }
        }
    }
    printf("%d\n", res);
}

int main() {
    read();
    work();
    return 0;
}

\(O(L^2)\)
复杂度的解法只在一念之间,只要您愿意想:

void work() {
    int len = strlen(str);
    int res = 0;
    for (int i = 0; i < len; ++i) {
        int zeroCnt = 0, oneCnt = 0;
        for (int j = i; j < len; ++j) {
            str[j] == '0' ? ++zeroCnt : ++oneCnt;
            if (zeroCnt == oneCnt) {
                ++res;
            }
        }
    }
    printf("%d\n", res);
}

Description

zyj
又被叫去打印奖状啦!不过学院办公室的打印机实在太辣鸡,平日把奖状文字打歪。为了让大学更换打印机,
zyj
把温馨在高校得的有所奖状都拿出去,用以显示那打印机打出来的奖状到底歪成什么样子。为了有利于表示,
zyj
决定把每一张奖状的文字范围中央和奖状纸张主题的几何距离列举出来,用以表观地浮现打印机的误差。
zyj 每天都要打印奖状,日理万机,所以他请求你帮他成功这么些义务。

Input

先是行输入一个正整数 \(N < 10^6\)
代表名字数量。
接下来 \(N\)
行,每行输入一个只含小写字母的字符串(当然也不含空格),代表每个人的名字。
确保一个人的名字最大尺寸不超越 20 ,有限支撑所有人名字长度的总数小于 \(10^6\) 。

Output

对于每张泡泡纸,请您告知我故事的后果。
只如果 Oyk 最后捏完,输出 “Oyk Oyk!” (不包含引号,下同)。
即使是 Czj 最后捏完,输出 “diu,Czj!” 。

Hint

如若要用到排序,你可以调用 C 语言的 qsort 函数或者 C++ 的 sort 函数。

Sample Output

10

Description

自古,假如什么排列一份无序名单是一个具备争议性、颇为劳动的问题。平时的做法是根据姓名拼音的英文字母排字典序。
某一天 Zyj
突发奇想,能无法把所有人的名字拼在一起成为一个串,并且这几个串在所有拼接方案中字典序是不大的吗?比如有多少人的名字:zyh、zy、zyj,鲜明会有以下六种组成(出席空格是惠及阅读,实际排列不应该空格):

zyh zy zyj
zyh zyj zy
zy zyh zyj
zy zyj zyh
zyj zyh zy
zyj zy zyh

旗帜显然唯有第三种 zyhzyjzy 是独具方案中字典序最小的。
今日给您一份名单,你能找出那一个不大方案吧?

Sample Output

helloworldzyj

参照思路

动态规划,或回忆化搜索。
倘使限制了人口,求最大总质地,那就是多重背包问题,参看《背包九讲》。
此间只是要求方案数,拿个记号数组记录一下就好了,时间复杂度 \(O(N\sum{W_iX_i})\) 等。

问题大意

原题:与 hdu 1847 大致一模一样。
唯有一堆若干数额的物料,规定每人每一遍可以取 \(2^{\mathbb{k}}\)
个,取完者胜,问先手是或不是能赢。

Input

输入包蕴多组数据,每组数据各占一行,每一行有一个正整数 n ,表示 cgy
的绩点名次,输入到文件结尾截至( \(n \leq
100000\) ,数据组数 \(t \leq
1000000\) )。

Hint

字符串”00110011″中符合条件的子串分别为”01″(前一个),”10″,”01″(后一个),”0011″
(前一个),”0110″,”1100″,”1001″,”0011″(后一个),”011001″,”00110011″,共10个。

Input

输入第一行是一个正整数 T
表示数据组数。接下来是多组数据,每组数据第一行是正整数 n ,分别代表 cgy
有 n 种面值的发票(每种都有好多张),接下去一行有 n
个由空格隔开的正整数,表示那 n 种面值的高低,再下一行是一个正整数 x
表示报废金额(T,x<=1000; n<=100)。

K. 偏执性精神障碍伤者

参考思路

动态规划,完全背包问题变种,时间复杂度 \(O(NX)\) 等。
参考《背包九讲》。

Description

ljc
喜欢吃糖,每一颗糖可以给她提供一个单位的脑能量。对于每道题,他最少要有
m1 能量才会设想去做,且 AC 那道题需求花费 m2 能量(即 ljc 能量数超过等于
m1 时才能去 AC 那道题,AC 已毕后 ljc 剩余(当前能量值-m2)能量)。
前天 ljc 的起来能量为 n,竞赛题目数为 k,问若 ljc 想要 AK
(All-Killed,即 AC 所有题目),则他至少要预备多少颗糖?

Sample Output

Yes
No
Yes

参考代码

上面的代码已经考虑了平整 3 :

#include <stdio.h>

int N, M;

void swap(int &a, int &b) {
    const int t = a;
    a = b;
    b = t;
}

int gcd(int a, int b) {
    return b ? gcd(b, a % b) : a;
}

void read() {
    scanf("%d %d", &N, &M);
}

void work() {
    int perfect = 0, fake = 0;
    bool hasSingle = false;
    if (N > M) {
        swap(N, M);
    }
    if (N == M) {
        fake = N;
    } else if (N + 1 == M) {
        hasSingle = true;
        fake = N;
    } else {
        int groupCnt = 1;
        while (N && (1 == (groupCnt = gcd(M, N)) || N == groupCnt)) {
            ++fake;
            --N;
            --M;
        }
        if (!N) {
            hasSingle = true;
        } else {
            perfect = groupCnt;
        }
    }
    printf("%d %d\n", perfect, fake);
    if (hasSingle) {
        puts("happy single dog!");
    }
}

int main() {
    int T;
    scanf("%d", &T);
    while (T--) {
        read();
        work();
    }
    return 0;
}

Sample Input

2
3
1 3 5
11
2
3 5
7

Output

出口 n 行,每行一个浮点数(小数点后保留两位),代表每个英灵的评分。

易错点解析

  1. 唯恐会有同学想到枚举的点子,即假如总共有 P 个人,从选 1 私有到选 P
    个人不断整合出来,看有多少种差其余总质料不就好了吗?但要注意,最坏情状下可选方案数是小于等于
    \(C^1_P + C^2_P + \ldots + C^P_P =
    2^P – 1\) 的(当且仅当有着项目质料值 \(W_i\) 互质,且不存在 \(p \leq X_j \land q \leq X_i\)
    使得 \(W_i = p \land W_j = q\)
    时取等号),考虑到有 10 种质料且每种质料有 100 个人,总人数最多高达
    1000 那是要算到地老天荒的点子;

Input

率先行输入质料的种数 n
第二行输入每种质地的质料
其三行输入每种质料的人的总人口

E. Substring

Output

对此每一行输入,倘诺得以透过加括号成为整数就输出 Yes ,否则输出 No 。

参考代码

标程:

#include <stdio.h>

int main() {
    int N;
    while (~scanf("%d", &N)) {
        puts(N % 3 ? "Oyk Oyk!" : "diu,Czj!");
    }
    return 0;
}

递推解法(改自一个同校的付出):

#include <stdio.h>

const int MAXN = 1E6;
int win[MAXN + 1];

void init() {
    for (int i = 1; i <= MAXN; ++i) {
        for (int j = 1; j <= i; j <<= 1) {
            if (!win[i - j]) {
                win[i] = 1;
                break;
            }
        }
    }
}

int main() {
    init();
    int N;
    while (~scanf("%d", &N)) {
        puts(win[N] ? "Oyk Oyk!" : "diu,Czj!");
    }
    return 0;
}

Sample Output

74

参照思路

贪欲算法,须求先严厉弱序化(strict weak ordering)。

  1. 单串字典序不控制拼接串字典序。假设就英文字母串的习性来说,显明每个串都有一个“A-Za-z”的“字典序”,既然有一个约定成俗的字典序,它们中间自然是相比的,也可以排序;不过并不可能声明根据字典序排好的串拼接起来,得到的新串在具有拼接方案中,它也是按字典序的极小元或特大元。很简单找到反例:
    bacd 和 b 能够凑合成 bacdb 和 bbacd 三种, 尽管 b 是原串集合 {b,
    bacd} 中的极小元,但 bbacd 不是拼接串集合 {bacdb, bbacd}
    的极小元,由此 b 无法排在 bacd 的面前。
  2. 建立新关系。基于下面的思想,很不难想到将原串集合任意元素两两拼接相比较。对于任意串
    A 和 B ,大约有 3 种情形:

    • A 和 B 在初始处没有公共子串。直接按字典序排就好了,比如 AB <
      BA 分明能操纵出 A < B ;
    • A 和 B 在起来处有一个短的公共子串。那时 A 可以表明为 PQ 而 B
      可以解释为 PR ,对于 Q 和 R 的可比又再次来到了第一种情形;
    • A 是 B 在开班的子串,或反过来。如若是前者,则 B 可以表达为 AP
      ,对 AAP 和 APA 的可比实际是第二种处境,对 A 和 P
      的相比较。但只要 A 和 P 又在初叶处有国有子串,甚至是循环的吗?比如
      A 和 B ,而 B = AA..AP 甚至 B = AA..AQR 且 A = QSQS..QS 呢?那时
      A 相比短,先补齐到 B 的长度,有可能是 A/P 甚至是 S/Q 、 S/R 、
      Q/R 的可比,取决于循环节的长短。

I. 人形质地单位

参照代码

标程(\(O(N\sum{X_i\sum{W_iX_i}})\)):

#include<iostream>

using namespace std;
int main()
{
    int max=0;
    int n,w[305],x[105];
    bool p[300*100*10+5];
    cin>>n;
    for(int i=1;i<=n;i++)
        cin>>w[i];
    for(int i=1;i<=n;i++)
    {
        cin>>x[i];
        max+=x[i]*w[i];
    }
    for(int i=1;i<=max;i++) p[i]=false;
    p[0]=true;

    for(int k=1;k<=n;k++)
    {
        for(int i=1;i<=x[k];i++)
            for(int j=max;j>=w[k];j--)
            {
                if(p[j]==false && p[j-w[k]]==true) p[j]=true;
            }
    }
    int ans=0;
    for(int i=1;i<=max;i++)
    {
        if(p[i]) {ans++; }
    }
    cout<<ans;
}

\(O(N\sum{W_iX_i})\) :

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

const int MaxN = 10, MaxW = 301, MaxX = 101;
const int MaxM = MaxN * MaxW * MaxX;

int N, maxWeight;
int W[MaxW], X[MaxX], flag[MaxM];

void read() {
    scanf("%d", &N);
    for (int i = 0; i < N; ++i) {
        scanf("%d", W + i);
    }
    for (int i = 0; i < N; ++i) {
        scanf("%d", X + i);
        maxWeight += W[i] * X[i];
    }
}

int curr[MaxM];

void work() {
    int res = 0;
    flag[0] = 1;
    for (int i = 0; i < N; ++i) {
        memset(curr, 0, sizeof(curr));
        for (int j = W[i]; j <= maxWeight; ++j) {
            if (!flag[j] && flag[j - W[i]] && curr[j - W[i]] < X[i]) {
                flag[j] = 1;
                curr[j] = curr[j - W[i]] + 1;
                ++res;
            }
        }
    }
    printf("%d\n", res);
}

int main() {
    read();
    work();
    return 0;
}

参考代码

#include <stdio.h>

int gcd(int a, int b) {
    return b ? gcd(b, a % b) : a;
}

void work() {
    int M, a, b;
    scanf("%d%d%d", &M, &a, &b);
    b /= gcd(a, b);
    for (int i = 2; i < M; ++i) {
        scanf("%d", &a);
        b /= gcd(a, b);
    }
    puts(b == 1 ? "Yes" : "No");
}

int main() {
    int N;
    scanf("%d", &N);
    while (N--) {
        work();
    }
    return 0;
}

参考思路

原理题,总计数据关系。时间复杂度 \(\theta(N)\) 。

分类钻探,可以将数字分为三类: 4 的翻番、是 2 的翻番但不是 4
的倍数、奇数。

  1. 明确,任何数和 4 的翻番相乘,其结果仍旧是 4 的翻番,由此是万能搭配;
  2. 妇孺皆知,任意 2 的翻番唯有一个因子 2 ,因而它们只好两两间相乘才能博得 4
    的翻番,必须相邻地放一起;
  3. 对此自由奇数,和 2 的倍数相乘不符合题意,只可以和 4 的翻番相间搭配。

从而可以先排列所有 cnt1 个奇数,每五个奇数之间插入一个 4 的倍数,必要
\(cnt1 – 1\) 个 4 的翻番;若存在 2
的翻番,须求拿出一个 4 来连接它们,那样要求 \(cnt1\) 个 4 的倍数。判断一下 4
的翻番有多少个,是不是满足条件,并将判断结果跟机器人的相相比,得出答案。

Output

出口可以称量的质料种数

Input

zyj
得的奖状恒河沙数,所以输入文件包涵若干组奖状数据。每组奖状数据包涵两行,第一行是八个浮点数
a, b(a, b > 0) ,表示奖状的大小;第二行是几个浮点数 x, y, l, w(x, y
>= 0; l, w > 0)
,表示奖状上文字范围左上角的坐标和文字范围的长和宽。输入数据保险文字范围势必完全在奖状面积内。输入到文件结尾截止。

参考思路

多少关系规律题,枚举到能求最大公约数截止。
只要三个数据相当于则直接全体当成假扮情侣。
假若多少个数据相差 1 则肯定无法求 gcd 。
若是枚举进程中最大数可以整除最小数,则不知足规则 3 。
若是枚举战败,那就无法完善分组了。

参考思路

可以采取埃氏筛法(Sieve of Eratosthenes)、欧拉筛法(Sieve of
Euler)来做预处理,之后就足以一贯出口。
留神先总计出第 100000 个素数是 1299709 ,所以记录数组只要开到 马克斯(Max)N
,但标志数组要开到 马克斯(Max)P 。
光阴复杂度 \(O(NloglogN)\) 或 \(O(N)\) 。

Sample Input

3.0 4.0
1.0 1.0 1.0 1.0
2.0 2.0
1.0 1.0 1.0 1.0
3.0 3.0
0.0 0.0 3.0 3.0

Hint

  1. 本场竞技是网络初赛,除了不可能抄袭其余选手代码外,对别的文化和素材的物色获取不作限制;
  2. A 题并不是最简易的,题目难度不按顺序,请量力而为~
  3. 如有其余疑问请看补充表明 https://d.wps.cn/v/8pBAU

华南师大 2017 年 ACM 程序设计比赛新生初赛题解

华南地质学院第很多届 ACM 程序设计竞技新生赛(初赛)在 2017 年 11 月 20
日 – 27 日打响举行,共有 146 名校友有效参赛(做出 1
题)。进入决赛的资格初定为成功并经过 5 题或上述,决赛时间是 12 月 3
日,地方未定。

题目大意

原原题:《最大数》,1998 年 NOIP 全国联赛进步组,codevs 1860;
原题:《ZLM 的扑克牌》,2015 年华南师范高校 ACM 新生赛(逃;
加以若干个小写的英文字母串,求一种方案使得所有串按该方案的相继相邻首尾拼接后,得到的新串在所有方案中字典序最小。

Sample Input

1
2
28
13

Sample Output

WA
AC
AC

参考思路

贪欲 + 最大公约数,时间复杂度 \(O(N)\) 。

因为括号可以任意加,一定存在一种最优方案,使得除了首个数只可以当做除数外,其余数字的乘积为被除数,若它们的乘积跟首个数的最大公约数为
1
,则印证拥有的数乘起来都不可能整除第四个数,否则第一个数除以那几个最大公约数后其值为
1 (被除掉了,也足以精晓为被约分了)。

贪得无厌策略阐明:要是从最优方案中删除某一个括号,使得还有其余一组数跟第三个数相乘作为除数,若其余剩余的数的乘积不可能整除第四个数,当然也不可以整除那些新的更大的除数;若剩余的数的乘积能整除这个新除数,依据乘法结合律,它们也能整除单独的第三个数,因而得证。

Hint

样例 2 解释:1 4 2
样例 3 解释:1 4 2 2

参照代码

标程使用了埃氏筛法:

#include <stdio.h>
#include <math.h>

int n,cnt;
int notprime[10000010];
int prime[5000010];

int main(void)
{
    for (int i=2;i<=sqrt(10000000)+1;++i)
        if (!notprime[i])
            for (int j=2*i;j<=10000000;j+=i)
                notprime[j]=1;
    for (int i=2;i<=10000000;++i)
        if (!notprime[i])
        {
            ++cnt;
            prime[cnt]=i;
        }
    while (~scanf("%d",&n))
        printf("%d\n",prime[n]);

    return 0;
}

ZYJ 的欧拉筛解:

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

const int MaxN = 1E5;
const int MaxP = 1299709;

int primes[MaxN + 1], cnt;
char isPrime[MaxP + 1];

void init() {
    memset(isPrime, 0xff, sizeof(isPrime));
    for (int i = 2; i <= MaxP; ++i) {
        if (isPrime[i]) {
            primes[++cnt] = i;
        }
        for (int j = 1; j <= cnt && i * primes[j] <= MaxP; ++j) {
            isPrime[i * primes[j]] = 0;
            if (!(i % primes[j])) {
                break;
            }
        }
    }
}

int main() {
    int N;
    init();
    while (~scanf("%d", &N)) {
        printf("%d\n", primes[N]);
    }
    return 0;
}

刺探到计院方面教的是 cin/cout 的输入输出方法,由于某人出题事故导致
cin/cout
会被卡超时,公平起见放松了多少;进而导致优化的试除法可以险过(过滤偶数、循环外开方、用时总括),时间复杂度
\(O(N \sqrt{N})\) :

#include <stdio.h>
#include <math.h>

const int MaxN = 1E5;

int cnt = 1, primes[MaxN + 1] = {-1, 2};

int isPrime(const int& n) {
    int q = (int)sqrt(n) + 1;
    for (int i = 2; i < q; ++i) {
        if (!(n % i)) {
            return 0;
        }
    }
    return 1;
}

int getPrime(const int& n) {
    if (cnt < n) {
        for (int i = primes[cnt] + 1; cnt < n; ++i) {
            if ((n & 1) && isPrime(i)) {
                primes[++cnt] = i;
            }
        }
    }
    return primes[n];
}

int main() {
    int N;
    while (~scanf("%d", &N)) {
        printf("%d\n", getPrime(N));
    }
    return 0;
}

Output

对应于每一组 n 求出 \(\frac{(\frac{1+\sqrt{5}}{2})^{n}-(\frac{1-\sqrt{5}}{2})^{n}}{\sqrt{5}}\)
,保留 3 位小数。

Sample Input

00110011

参照代码

#include <stdio.h>

int T, N;
int cnt1, cnt2, cnt4;
char ans[4] = "yes";

void init() {
    cnt1 = cnt2 = cnt4 = 0;
}

void read() {
    int rd;
    scanf("%d", &N);
    for (int i = 0; i < N; ++i) {
        scanf("%d", &rd);
        if (rd & 3) {
            (rd & 1) ? ++cnt1 : ++cnt2;
        } else {
            ++cnt4;
        }
    }
    scanf("%s", ans);
}

void work() {
    puts(ans[0] == "ny"[cnt4 >= cnt1 - !cnt2] ? "AC" : "WA");
}

int main() {
    scanf("%d", &T);
    while (T--) {
        init();
        read();
        work();
    }
}

出题总计

题号 题目 ZYJ 预xia估cai难度 正确率(正确/提交) 通过率(正确人数/有效人数) 出题人
A 诡异的计数法 2.8 9.88%(100/1012) 61.64%(90/146) Cgy
B 数发票 4.0 11.43%(28/245) 13.01%(19/146) Cgy
C Ljc 吃糖 2.5 8.82%(30/340) 14.38%(21/146) Ljc
D 姓名字母排列 2.5 9.59%(21/219) 8.22%(12/146) Zyj
E Substring 2.0 51.08%(118/231) 74.66%(109/146) Zlm
F 法特狗 3.0 7.29%(25/343) 12.33%(18/146) Cgq
G Zyj 打印奖状 1.0 26.97%(140/519) 88.36%(129/146) Cgy
H Cg 之争 1.8 21.55%(86/399) 53.42%(78/146) Cgy
I 人形质量单位 4.0 20.00%(16/80) 6.85%(10/146) Lxy
J 训练 ZetaGo 3.0 21.02%(78/371) 47.95%(70/146) Zyj
K 强迫症患者 2.5 21.26%(44/207) 27.40%(40/146) Lxy
L Oyk 捏泡泡纸 3.0 59.90%(118/197) 74.66%(109/146) Zyj
M 光棍节活动 2.2 11.35%(43/379) 26.03%(38/146) Zyj

呃,文字性的东西辣么烦,怎么可能会有出题计算那种事物嘛。

G. zyj 打印奖状

Input

输⼊只有一行,为给定的字符串。字符串长度不当先100,且只包蕴’0’和’1’二种字符。

D. 姓名字母排列

Hint

double 类型的输入输出格式: scanf(“%lf”) / printf(“%f”)
大旨数据量大,请使用 scanf/printf ,使用 cin/cout 会导致超时

A. 诡异的计数法

Description

明显, cgq 和 cgy 名字中只差一个字。为了保住 CG 那几个称号, cgq
作为擂主给 cgy 出了个难题:假使 cgy 能在 1s 内答出 \(\frac{(\frac{1+\sqrt{5}}{2})^{n}-(\frac{1-\sqrt{5}}{2})^{n}}{\sqrt{5}}\)
,就能得到几回正式挑衅 cgq 的火候。 cgy 好菜呀,而且他的 1s
非常宝贵,于是求助于你,请你帮他求出那些数。

Input

一个平头 n(n<=100) 表示有几组数据
接下去输入 m(m<=1000) 表示有 m 个数字,再下来一行输入 m
个正整数(每个数字不超出 1000 ),表示式子中的数字。

Hint

1.00 = 4/4
0.75 = 3/4
0.50 = 2/4
0.25 = 1/4

题材大意

加以任意 01 串,求含有相同数量的 ‘0’ 和 ‘1’ 的总是子串有稍许个。

Description

一年一度的光棍节活动中,cgy
的班级想搞一个独具特色的移位,需要将班上的男生和女子完美分组,规则如下:

  1. 每个组之间男生数要一如既往,女孩子数也要一律;
  2. 同一个组中的男生数无法等于女子数;
  3. 每组中男生和女人分别要有 2 名或上述;
  4. 务需要分成 2 个或上述的组,组数也要硬着头皮的多才好玩;

设若无法圆满分组,将随机抽出一名男生和一名女孩子组成一队开展装扮情侣活动,重复举行(尽量少的次数)抽人直到剩余的孩子生人口恰好可以周到分组。
比方一味不设有完美分组,那么除了成功组队实行装扮情侣的外,可能会多出多少男生依旧女人没有组队哦(同性才是真爱!)。

cgy 陈设 lxy 实施那个方案,但 lxy 脸红心跳,想请你帮协理。

Description

每个人的身分可能同样,或许不一致。于是乎,倘若以人们的体重作为一个计量单位,那么可以有稍许种分化的构成呢?
设有 n(\(1 \leq n \leq 10\))
种区其他成色,第 i 种质地大小为
wi,第
i 个质料有
xi
个人(其总分量不当先 300000kg
),必要编程输出那么些人形能称出分裂质量的种数,但不包蕴一个人也不用的场合。

题材大意

有两堆数量不等的物料,要求对其进行分组,且已毕组数最大化;
不可以只分一个组,否则不叫分组;
不可以随便分组,每个组的状态要平等;
加盟规则 2 ,一个组中不相同序列物品数量不等;
进入规则 3 ,一个组中任意一种物品数量不为 1 。
(由于自身原先的顺序忘记考虑规则 3
,所以比赛中暂时删掉了,后来发觉数目也没卡掉,改不改都是对的)

最后

初赛并不是为了为难大家,而是让大家感受 ACM
程序设计比赛是哪些的,算法和数据结构是个什么事物,对于一个已知的问题,如何抽象出它的模子并找到确切的法门,在较好的性质内解决它。
本年理应也是首先年允许转专业的同桌参加,一起始还挺担心他们多学了半学期《数据结构》会不会太强了的(逃)。可能对于大多数同学来说,插手ACM
新生赛或许是率先次那样高密度地思索和缓解问题,但随便是萌新也好,仍旧转专业的同桌也好,希望大家本次竞赛可以是您踏上专业成长途径的首先步,相信也只是各位的很多生存历程的一小段,未来的活着还很长,可能你会像我同样不可捉摸地转了前端开发,可能你会做一些更有趣的事物,可能您之后会做一名老师,也可能你会连续深刻总结机科学的钻研中,甚至可能爱上算法比赛以及算法探讨与布署,往小了说后边还有
CTF 竞技(逃)。
好歹,希望这一次比赛可以让您感受到电脑科学的方法与程序设计的魅力,让您的编程能力有着陶冶和增进,让你的牵挂空间和知识面有所增加,而不光是栖息在表面上的“这几个太难了”“这些有啥用嘛”“我之后总会学到的”,谢谢!

本文基于葡京签到送彩金 1知识共享署名-非商业性利用-相同情势共享
4.0
国际许可协议
通知,欢迎引用、转发或演绎,然而必须保留本文的签名BlackStorm以及本文链接http://www.cnblogs.com/BlackStorm/p/SCNUCPCFF-2017-Solutions.html,且未经许可无法用来生意目标。如有疑问或授权协商请与自家关系

Description

cgy
太喜欢质数了以有关他计数也亟需用质数表示!在她看来,2(第一小质数)表示1,3(第二小质数)表示2……可正因为她的计数方法太奇葩,所以他的数学成就格外差而且拖累了她的绩点。
lxy 得知 cgy 的绩点名次之后打算告诉她,可是必须以极其麻烦的 cgy
质数计数法的方法意味着。 lxy 出重金 ¥(10000000 mod 10)
请你来为她解决那一个古怪的计数。

Input

兴许会有多行输入,请您平昔处理到文件尾。
每行会输入一个正整数 \(N \leq 10^6\)

题目大意

给定一组数据,问是或不是留存这么一种排列,使得重排后的数码,任意相邻元素两两相乘的值是
4 的翻番,再跟机器人输入的“它的论断结果”作相比较。

Description

盛名的剪纸大师 Oyk
二〇一九年不剪纸了,近日做事压力大,他改为捏泡泡纸来放松情感。由于 Czj
每一日上班摸鱼,他被抓复苏陪 Oyk 捏泡泡纸。
已知一张完整的泡泡纸上会有 \(N\)
个泡泡,他们预订每一次每个人都足以 paji 掉 2
的幂次(1,2,4,8,16,…,\(2^k\))个泡泡,并且两次三番由 Oyk
先捏,轮流下去直到捏完。他们都想由友好来捏完整张泡泡纸,且他们都丰富聪明,总会估计选用最有利于团结的政策。
看她们捏泡泡太无聊了,我想预先掌握他们哪个人可以刚好在终极捏完整张泡泡纸。

Sample Input

3
18 24
19 25
18 19

Hint

ljc 做题的顺序可以擅自排列,顺序分化, AK 所急需的糖数不肯定相同。
假定要用到排序,你能够调用 C 语言的 qsort 函数或者 C++ 的 sort 函数。

L. Oyk 捏泡泡纸

Sample Output

1.000
1.000

Hint

对此样例 3 ,无论 Oyk 先捏 1 / 2 / 4 个都转移不了泡泡纸最终被 Czj 捏完。

参考代码

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

const int MaxCount = 1E6 + 1;
const int MaxLength = 20 + 1;

int N;
char names[MaxCount][MaxLength] = {0};

void read() {
    scanf("%d", &N);
    for (int i = 0; i < N; ++i) {
        scanf("%s", names[i]);
    }
}

int namesCmp(const void* a, const void* b) {
    static char p[MaxLength << 1], q[MaxLength << 1];
    strcat(strcpy(p, (char*)a), (char*)b);
    strcat(strcpy(q, (char*)b), (char*)a);
    return strcmp(p, q);
}

void work() {
    qsort(names, N, MaxLength, namesCmp);
    for (int i = 0; i < N; ++i) {
        printf("%s", names[i]);
    }
    putchar('\n');
}

int main() {
    read();
    work();
    return 0;
}

初赛复盘

一起始我是没想过要把题目排成这么些顺序的,我们的背锅侠忘记调啦!于是只可以在
7
分钟发(英文名:)了条@全员说难度不按梯次,不过大家要么喜欢按顺序做(摊手.jpg)。于是就又有了一堆被打击信心的爆零啦
qwq

继而就由于并未丰盛验题,陆续发现了卡 cin
之类的意外问题,改了三次数据重判了多少次,又把原来 AC 的给重判成 TLE
了“咦重判完 AC 反而变少了”(药丸.jpg)。

下一场安利一下 qu 老师家的可能还算好用的金山 WPS
写得
;借助这些意外的著述(?)工具临时对发现的部分题目,一些没说清楚的事项作了个补充(固然觉得并从未人看),于是像
system("pause") 之类的到末代似乎没在运动员们的交给中冒出过了。

全部区分度卓绝,从最后名次来看,做对题目数呈阶段性分布;除了 A
题是个看起来大致其实大家都没学过的大坑外,对 H 题《CG
之争》难度揣测错误,明显大家都没听说过斐波那契的通项公式;对 M
题《光棍节活动》难度估计错误,固然与 K
题《网瘾病人》一样是要用到求最大公约数的算法,但题面鲜明较复杂,陈述有待优化,甚至出现出题人温馨都漏考虑之中一个尺码的情状;对
L 题《Oyk
捏泡泡纸》难度测度错误,显著我们找规律的力量或者挺强的,以前是认为那些博弈题相比难注脚,然则我们敢交题。。

完整题目质地卓越,除了个别题目题意有待提升、条件描述不纯粹或任何小题目外,涉及的知识点较全,没有重新出题;除了各自选手在
F
题用到批处理生成长段代码,正解解答代码量适中,涉及的个别程序语言知识大概相符教xue学xi进程。

题解

被你们虐了千百遍的问题和 OJ
也很累的,也想要休息,所以你们别想了,行行好放过它们,大家来看题解吧。。。