SCNU ACM 2016新生赛决赛 解题报告

新生初赛题目、解题思路、参考代码一览

A. 拒绝虐狗

Problem Description

CZJ 去排队打饭的时候看到前面有几对情侣秀恩爱,作为单身狗的 CZJ 表示很难受。
现在给出一个字符串代表 CZJ 前面的队列。你可以帮他一把把那些情侣分开吗?

Input

第一行是一个\(T\),代表数据的组数\(T\)（\(T\leq 100\)）。
每组一个只包含大写字母的字符串\(p\)（\(1\leq len_{p}\leq 1000\))，表示 CZJ 前面的队列，保证不会有连续三个及以上相同的字母序列

Output

将队列中相同且相相邻的字母用“1”隔开并输出。

Sample Input

2
AABB
ABBA

Sample Output

A1AB1B
AB1BA

解题思路

• 签到题，由于保证不会出现3个及以上的连续相同字符，所以每次判断一下上一个字符就好；
• 直接在线处理，时间复杂度\(O(len_{p})\)。

参考代码

#include <stdio.h>

int main() {
    int T;
    // 读入数据组数，并忽略本行回车
    scanf("%d%*c", &T);
    while (T--) {
        // 每次先初始化上一次读入的字符为EOF
        int readChar, lastChar = EOF;
        // 不断读入一个字符，直到回车
        while (readChar = getchar(), readChar != '\n') {
            // 如果读入的字符和上次读入字符相同，则先输出'1'分开
            if (readChar == lastChar) putchar('1');
            // 经过前面的处理后，把本次读入的字符输出
            putchar(readChar);
            // 重置上次读入的字符
            lastChar = readChar;
        }
        // 单个数据结束，输出换行
        putchar('\n');
    }
    return 0;
}

比赛提交代码中发现的问题

1. 有选手直接提交了exe、txt文件而不是源码文件，导致编译错误；
2. 部分选手对于循环理解有偏差，for(i=0; i<=n; i++)是执行n+1遍的，而数据只有n组，导致一直卡输入直至超时；
3. 部分选手误认为要读入全部数据后才能输出；实际上可以计算完一个情形后再读入下一个情形计算；
4. 接上一点，其中又有部分选手因此开了像char a[105][1600];的数组。在内存限制范围内开数组没问题，但是不能在main()等函数中开这么大的数组；详见C/C++堆栈空间分配；
5. 接上一点，其中又有部分选手开了大小刚好为1000的数组；实际上是对字符串的存储理解有偏差，字符串需要额外存储一个结束符'\0'，因此导致越界访问内存；
6. 有选手使用了C++的string类，但可惜基本功不扎实，存在错误使用；
7. 有选手一开始提交的代码中出现了“Please input ...”这样的输出，导致WA；
8. 有选手把==写成了=（比如if(a==1)成了if(a=1)），导致循环不结束直至TLE。

### B. Zyj 消极比赛

Problem Description

ACM 比赛剩下最后 10 分钟，其他人都已经收拾好东西准备走人，Zyj 才从睡梦中醒来。
Zyj 可以看到所有其他人的过题情况，他希望得到的名次在 a 到 b 之间，问有几种可选择的方案?
(假设其他人的提交时间即使加上罚时也早于 Zyj 的提交,毕竟剩下 10 分钟了都)

Input

第一行为 T （0 < T < 100），代表有 T 组数据。
每组数据中第一行为两个数字 m n a b，由空格隔开，代表这次比赛有 m 道题 (由于字母数量的限制，0 < m < 27)、
n 个其他人、Zyj 希望得到的名次 x 满足 a < x < b （ −1 < n, a, b < 1000）。
下一行为 Zyj 解决每道题需要的秒数 \(0\leq t_i < 999\)。
下面 n 行为每个人每道题的通过情况，1 为已通过，0 为未通过。

Output

对每个样例，输出 Case #k: ans，其中 k 为样例编号，ans 为方案数量。

Sample Input

1
4 1 0 2
300 300 300 300
0 0 0 1

Sample Output

Case #1: 6

Hint

样例解释:
Zyj 必须做出至少 2 题,又因为每个题的解题时间为 300 秒即 5 分钟,Zyj 也只能做最多 2 题,
所以 Zyj 做两题有 \(C_4^2 = 6\) 种方案。

解题思路

• 初赛这题是求组合数。但是你有没有想过为什么能用求组合数的方法来做呢？
• 还记得吗？初赛这道题没有对Zyj做每题作出限制。也正因为如此，Zyj无论做哪一题都是等价的，所以对于无序集合，我们可以求组合数。
• 但是这里更接近实际情况，Zyj做每一题的时间都是不一样的。有可能这道题做了，剩下的题就没时间做了。由于剩下的时间有限，这是个求满足特定条件的子集的问题。
• 能不能用枚举的方法呢？
  • 选一道题，根据剩下的时间再选一道题，重复下去，总能把所有情况列举出来。
  • 但是你想啊，一个大小为\(m\)的集合，它的非空子集有 $2^m-1 $个；
  • 一个不小心你可能需要 \(O(2^m)\) 到甚至 \(O(m!)\) （姿势不对时）的复杂度把所有可行子集都枚举出来。
• 枚举太暴力了，我们可以记忆化搜索。
  • 我们定义一个数组 dp[i][j][t] （\(j\leq i\)）来表示在总共有 \(i\) 道题，Zyj睡醒后剩下 \(t\) 时间的情况下，Zyj做 \(j\) 题的方案数。
  • 显然，对于任意 \(1\leq i\leq 26\)， \(0\leq t\leq 600\) （10分钟=600秒）， dp[i][0][t]=1 恒成立，均可算作1种情况。
  • 设 c[i] 代表Zyj做第 \(i\) 题所需的时间，显然， dp[i][i][t] = dp[i-1][i-1][t-c[i]]；
  • 而Zyj做 \(0<j<i\) 题时（dp[i][j][t]），不做第 \(i\) 题的方案数为 dp[i-1][j][t]，做第 \(i\) 题并在前面的题选做 \(j-1\) 题的方案数为 dp[i-1][j-1][t-c[i]]。
  • 综上，我们可以得出 dp[i][j][t] = { dp[i-1][j][t] + dp[i-1][j-1][t-c[i]], if \(j\leq i\) }, { 0, if j > i }, { 1, if j = 0 }。
• 时间复杂度 \(O(300m^2)\)；空间复杂度 \(O(600m^2)\)，用滚动数组优化到 \(O(600m)=15600\)。

参考代码

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

const int MaxTime = 600;
int m, n, a, b;
int dp[27][601];// dp[j][t]代表Zyj在t时间内做j题
int solveCount[27];// solveCount[i] 记录其他人做i题的人数

void init() {
    memset(dp, 0x0, sizeof(dp));
    for (int iterTime = 0; iterTime <= MaxTime; ++iterTime)
        dp[0][iterTime] = 1;
    memset(solveCount, 0x0, sizeof(solveCount));
}

void prepare() {
    int costTime;// 读入Zyj做每一题所需的时间
    for (int iterProb = 1; iterProb <= m; ++iterProb) {
        scanf("%d", &costTime);
        // j=0 的情况不需要处理，已经初始化好了
        // 由于使用了滚动数组，从大到小更新
        for (int iterSolv = iterProb; iterSolv > 0; --iterSolv)
            // 直接从Zyj解该题所需时间考虑，剩下时间小于该时间的话Zyj也解不出来
            for (int iterTime = costTime; iterTime <= MaxTime; ++iterTime)
                dp[iterSolv][iterTime] += dp[iterSolv - 1][iterTime - costTime];
    }
}

void readSolves() {
    // 读入n个人的做题情况
    for (int iterPerson = 0; iterPerson < n; ++iterPerson) {
        int acc = 0, solvedTag;// acc用于累加每个人做题总数，solvedTag表示是否解题
        for (int iterProb = 0; iterProb < m; ++iterProb) {
            scanf("%d", &solvedTag);
            acc += solvedTag;
        }
        // 累加总共做出acc道题的人数
        ++solveCount[acc];
    }
}

void read() {
    scanf("%d%d%d%d", &m, &n, &a, &b);
    prepare();
    readSolves();
}

int work() {
    // rank代表Zyj做i题以上能拿的名次
    // Zyj有拿第一的可能，但也一定是同题数的最后一名
    int rank = 1, result = 0;
    // 从全做m题开始遍历到只做1题
    for (int iterSolv = m; iterSolv > 0; --iterSolv) {
        rank += solveCount[iterSolv];
        if (a < rank && rank < b)
            result += dp[iterSolv][MaxTime];
    }
    // 若做0题，则与其他做0题的人并列排名
    if (a < rank && rank < b)
        result += dp[0][MaxTime];
    return result;
}

int main() {
    int T;
    scanf("%d", &T);
    for (int cse = 1; cse <= T; cse++) {
        init();
        read();
        printf("Case #%d: %d\n", cse, work());
    }
    return 0;
}

### C. 星界游神 llm

Problem Description

L2m 向星界游神学艺，星界游神教会他一种技能后大笑“后继有人”后溘然长逝。于是 L2m 成了新的星界游神。
L2m 比较强，可以收集红蓝绿三种调和之音。但是原本的星界游神比较弱，教给 L2m 的技能要消耗同等数量的调和之音才能发出。
Zyj 就想知道，L2m 最多能发多少次技能，好在 L2m 技能用光后打败他。

Input

第一行只有一个正整数 T （\(T\leq 1000\)），代表了 T 个情形。
接下来的 T 行，分别是三个整数 \(0<R,B,G<10^9\)，代表大佬 L2m 所拥有的红、蓝、绿三种调和之音。

Output

请你对于每种情况输出大佬能发出多少次技能。

Sample Input

1
1 3 2

Sample Output

1

解题思路

• 这是2015年广东省赛原题，我改了下题面作为签到题放上来啦。
• 因为需要消耗同等数量的调和之音，所以三个变量之间存在制约，释放技能次数取决于三者的最小值。
• 求最小值应该很好求吧，1. if-else； 2. 条件表达式(a<b)?(a<c?a:c):(b<c?b:c)； 3. 使用min函数std::min(a,b)； 4. 自己写个min函数int min(int a,int b){return a<b?a:b;}
• 时间复杂度：O(1)

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

using std::min;

int main() {
    int T, R, B, G;
    scanf("%d", &T);
    while (~scanf("%d%d%d", &R, &B, &G)) {
        printf("%d\n", min(min(R, B), G));
    }
    return 0;
}

比赛提交代码中发现的问题

1. 交错代码了..把别的题目的代码交上来了..；
2. 又提交了exe、txt上来..；
3. 恶意提交exe，当我想打开源码看交了什么鬼时，程序卡了好久..；
4. 提交的代码中含有system("pause");，导致编译错误or超时（大概是用VC6.0写的？我建议选手们除了写作业和考试外不要使用VC6.0）；
5. 对R，G，B三个数字做奇怪的加权or除法，没看懂为什么要这么做；
6. 想将计算结果保存后再一次性输出..结果保存的还不对；还有输出漏了一个for(i=1;i<T;i++)；呃..再强调一遍，我们是可以计算完一个情形后立刻输出的；
7. 输出的时候忘记换行。你想啊，比如你要分别输出1和2，结果你输出了12，能一样吗；
8. 有选手把所有情形的答案全部加起来了才输出，啊，咋回事啊，是我的题面阅读性差嘛QAQ

### D. Oyk 剪纸

Problem Description

Oyk 又和 Zlm 剪纸了。因为以往的剪纸都是一个方向的，他们决定换个方式。
把一张矩形纸分割为 a*b 的网格，每次可以剪去 n 个格子以内组成的矩形。
Oyk 希望能剪到最后一个格子，那么他应该先剪还是后剪?

如 n=5 时，下列方案中 1,2,5 为可行方案，3 不是(因为它不是个矩形)，4 也不是(因为由 6>5 个格子组成)
注意，剪完之后如果纸断开了，可以任选一部分剪，如同它们没有断开一样，只是不可能同时剪到其中的多个部分；剪出来的部分就扔了，不再动。

Input

输入有多组（少于1000组）数据，处理到文件尾。每行有三个数字，a，b和 n（均为小于10000的正整数)，由空格隔开。

Output

对每个样例。输出 1 如果应该先走，否则输出 2。

Sample Input

1 3 1
1 3 3

Sample Output

1
1

Hint

1 3 1 中，不管剪哪一个格子，总会剩下两个，Zlm 再剪一个剩下一个，Oyk 能剪到最后一个。
1 3 3 中，Oyk 可以一次把整个纸剪了，Oyk 还是能剪到最后一个。

解题思路

• 找规律题，但我不会。于是又让Oyk教了我一次剪纸....
• Oyk：推荐先思考的经典问题：
  • 一个圆桌上放硬币，先放满（剩余空间不能再容纳）为胜，先手怎么放才能获胜；
  • 变种：一个直径d圆桌放直径p圆盘，先放满为负，问先手能不能赢；
  • 一维剪纸：一条长纸带划为n格；一条环形纸带划为n格；
• 首先观察任意大小的矩形网格纸，知道无论先手剪去哪部分，后手总能根据对称性剪去一样的部分；如果先手能够先挖掉矩形纸的中间一块，而使得剩下的纸仍然具有中心对称的性质，则获得了后手必胜局势（注意不连续的纸不能同时剪，并必须剪小矩形）。
• 由于对称性的存在，我们构造最小不同例子，分别是边长为\(1\times 1\)、\(1\times 2\)、\(2\times 2\)的矩形纸：
  • 先验证它们是最小不同例：
    1. 对于\(1\times 1\)的情况，先手总是胜。在边的两侧同时添加一行或一列不影响对称性，在边的单侧添加会由于对称性而转变为另两种情况；
    2. 对于\(1\times 2\)的情况，先手只能全部拿完才获胜。在边的两侧同时添加一行或一列不影响对称性，在边的单侧添加会由于对称性而转变为另两种情况；
    3. 对于\(2\times 2\)的情况，先手只能全部拿完才获胜。在边的两侧同时添加一行或一列不影响对称性，在边的单侧添加会由于对称性而转变为另两种情况；
    4. 不失一般性，考察\(2\times 1\)的情况，发现旋转后与\(1\times 2\)的情况等价，不需另外考虑。
  • 对于三个不同情况的等价类，边长的奇偶性相同，因此得出三种先手必胜策略：同为奇取1，同为偶取4，一奇一偶取2；
  • 显然，如果需要取的最少格子数不大于N的话，先手无法占先取得对称局势，而后手总能在第一局补齐获取对称局势所需的格子，从而获得胜利。
• 总结：根据两边长奇偶性考察N的大小。
• 时间复杂度：O(1)

参考代码

#include <stdio.h>

int main() {
    int a, b, n;
    while (~scanf("%d%d%d", &a, &b, &n))
        puts(4 >> (a % 2 + b % 2) > n ? "2" : "1");
    return 0;
}

### E. Zyj 穿越到古代

Problem Description

Zyj 又消极比赛了，这次他被 SCNU 的大佬们追杀穿越到了古代。他成了古希腊的一个将军，但是他的军队被 Hyr 带领 SCNU 的大佬们围困在山顶。眼看突破无望，但是 Zyj 军队里的将士又不肯投降,就想以死殉职。但是 Zyj 就不愿意了。他想：宝宝心里苦啊，不就是比赛的时候睡个觉嘛。于是他想出一个方法让自己逃脱制裁。
将军队里面剩下的所有人从 1 到 N 开始编号，每次数 M 个人，从 1 开始数。被数到的那个人以死殉职。然后下一个人继续从 1 开始数。Zyj 要逃脱就只能成为最后一个殉职的人，这样他就能乖乖投降了。请你告诉 Zyj 要选编号是多少才能逃脱制裁。
比如有 3 个人，编号 1,2,3。每次数 2 个，第一个殉职：2。剩下 1,3。第 2 个殉职：1。只剩下3。于是 zyj 一开始选择编号 3 可以逃脱。

Input

有多组数据，数据不超过 100 组，输入到文件尾结束。每组数据共一行两个数，第一个数 N 代表人的总数，第二个数 M 代表每次数多少个人（\(0\leq N\leq 1000\)，\(0\leq M\leq 1000000000\)）。

Output

输出一行，一个整数代表 zyj 一开始要选哪个编号才能活着。

Sample Input

5 3
4 6

Sample Output

4
3

解题思路

• 不是我出的题，只是我造的数据。数据如下：

500 999999999
500 999999797
500 999999792
500 643242600
500 123456789
491 999999999
499 999999797
503 999999792
509 643242600
521 123456789
500 1
523 1

• 可能大家都在课本上学过循环数数的方法，但这是很慢的，复杂度高达\(O(NM)\)，妥妥的TLE。
• 当然，如果你不死心，一定要模拟循环数数，那也可以的，因为只有\(N\)个人，当\(M>N\)时，数到最后一个人只会再从第一个人开始数起，不可能数出第\(M\)个人来，所以循环数数的长度应该是\(M\%N\)。时间复杂度\(O(\sum^{N}_{i=2}M\%i)=o(N^2)\)。
• 我认为我的题是必须良心的，所以放过了\(O(N^2)\)的算法，因此用一个数组标记每个人，每次你算出那个人（数组元素的下标）之后，直接把数组后面的元素往前移就相当于删掉那个人了，也就是重新标号。无论是int数组前移，还是结构体数组重标号，还是vector删除元素，都是\(O(N^2)\)的时间复杂度。
• 可惜场上没有多少同学想到要\(M\%N\)，几乎都直接循环\(M\)的长度。我真的不知道原因在哪里，是C语言课上的太水了吗？请你们在自己的电脑上测试一下，你的电脑跑\(10^9\)长度的循环需要多长时间。
• 正解：
  • 假设当前数号到\(num\)，好的他已经出局了，原来的第\(num+1\)个人成了新的第\(num\)个人；
  • 要从新的第\(num\)个人开始往后数出第\(M\)个人出局，而总人数只有\(N\)个人，所以下一次会数号到\(num'=(num+M)\%N\)，第\(num'\)个人出局，类推。
  • 因此得到一个递推公式：\(R_i=(R_{i-1}+M)\%N\)，当\(i=N\)时，总人数只剩下一个人，\(R_N\)就是Zyj想要的编号。
• 时间复杂度：\(O(N)\)

参考代码

#include <stdio.h>

int main() {
    int n, m, i, s = 0;

    while (~scanf("%d%d", &n, &m)) {
        s = 0;
        for (i = 2; i <= n; i++) {
            s = (s + m) % i;
        }
        printf("%d\n", s + 1);
    }
    return 0;
}

比赛提交代码中发现的问题

1. 跑了长度为\(M\)的循环，不再多说；
2. 以为数据还会输入一个整数\(T\)，但是这里是要读到EOF的；
3. 有同学用了链表..但是链表不能做到随机查询的话，还是模拟循环数数而已；

### F. 贪吃蛇

Problem Description

贪吃蛇是一个很有名的游戏。小蛇每吃掉一个食物,就会长长一格；撞到障碍物或自己，就会结束游戏。
这里把贪吃蛇的规则略作修改:

1. 蛇所在世界的长为 W，高为 H，坐标为左上角 (1,1) 至右下角 (W,H)。
2. 刚开始时，蛇长度为 1，位于 (1,1) 处，初始方向向东。
3. 每秒可以按下 W 表示向上，A 表示向左，S 表示向下，D 表示向右，或不按按钮，来试图对蛇进行转向，但只有试图的转向与当前方向垂直时，转向有效。
4. 每秒在尝试转向后，向新方向移动 1 格（如果转向成功）。如果吃到食物，长度增加 1，否则长度不变。
5. 世界是环形的，即从右边离开边界会从左边重新进入，以此类推
6. 撞到自己，蛇长度恢复为 1，方向、位置不变。

Input

有多组样例，处理到文件结束。每组样例第一行为三个数字 W,H,N(0<W，H<500，0<N<100000)
下面 N 行，每行：第一个字符为 WASDNwasdn 之一，字母表示那一秒的按键，N 表示那一秒不按键；大写表示吃到食物，小写表示没有。后面紧接一个空格，然后一个 64 位无符号整数\(a_i\)。

Output

对每个样例，输出一行，其值为 \(\sum_{t=1}^{N}a_t \sum_{x=1}^{W}\sum_{y=1}^{H}3^{yW+x}c_{txy} mod 2^{64}\)，其中 \(c_{txy}\) 表示第 t 秒 (x,y) 处,有蛇为 1,没有蛇为 0

Sample Input

3 2 8
a 0
s 0
D 0
N 0
n 0
w 1
s 0
n 1

Sample Output

15552

样例解释：

输出为 \(1(3^{1\times 3 + 2} + 3^{2\times 3 + 1} + 3^{2\times 3 + 2}) + 1\times 3^{1\times 3 + 2} mod 2^{64} = 9234\)

解题思路

• 模拟题。直接模拟就好，没什么特别的技巧。
• 时间复杂度：O(玄学)

参考代码（出题人的代码）

#include <stdio.h>
#include <stdlib.h>
#include <queue>
int z[500][500], q;
unsigned long long vu[300000]={1};
inline void setp(int x, int y) {
    z[x][y]=q;
}
inline void clrp(int x, int y) {
    z[x][y]=0;
}
inline bool seep(int x, int y) {
    return z[x][y]==q;
}
int main() {
    int w,h,n;
    for (n=1; n<300000; n++) {
        vu[n] = vu[n-1] * 3;
    }
    while (~scanf("%d%d%d",&w,&h,&n)) {
        char c[2];
        unsigned long long val=0, ali, map=vu[w+1];
        q++;
        int x=1, y=1, d='d';
        std::queue<int> L;
        L.push(w+1);
        while (n--) {
            scanf("%s%llu", &c, &ali);
            c[1]=c[0]<'a';
            if(c[1]) c[0]+=32;
            switch (c[0]) {
            case 'd': case 'a':
                if(d=='w' || d=='s') d=c[0]; break;
            case 'w': case 's':
                if(d=='a' || d=='d') d=c[0]; break;
            }
            switch (d) {
            case 'a':
                x--;
                if(x==0) x=w;
                break;
            case 's':
                y++;
                if(y>h) y=1;
                break;
            case 'd':
                x++;
                if(x>w) x=1;
                break;
            case 'w':
                y--;
                if(y==0) y=h;
                break;
            }
            if (c[1]) {
                //got new
            } else {
                int t=L.front()-1;
                L.pop();
                int y=t/w, x=t%w+1;
                clrp(x,y);
                map-=vu[w*y+x];
            }
            if (seep(x,y)) {
                map=0;
                q++;
                std::queue<int>t;
                std::swap(L,t);
            }
            L.push(y*w+x);
            setp(x,y);
            map+=vu[w*y+x];
            val+=ali*map;
        }
        printf ("%llu\n", val);
    }
}

### G. equation

Problem Description

给出一个各项系数均非负的多项式\(f(x)\)，是否存在\(x>0\)使得\(f(x)=1\)？

Input

每行一个样例，有多个数字（均小于25000，最多精确到6位小数）分别表示各项系数。具体地说，第\(i\)个数字表示\(f\)的\((i-1)\)次方项系数。没有列出的数字系数为0。

Output

若有解则输出解，若有多个解则从小到大输出，精确到四位小数，若无解输出空行。

Sample Input

0.5 1

Sample Output

0.5000

Hint

该输入表示\(f(x)=1x+0.5=1\)解为\(x=0.5\)

解题思路

• 二分法。
• 当各项系数非负，且\(x\geq 0\)时，\(f(x)\geq 0\)恒成立且\(f(x)\)在\([0, +\infty)\)上单调递增。
  • 如果\(\exists x>0, f(x)-1=0\)，则\(f(0)-1<0\)，即\(f(0)<1\)；
  • 考察增长最慢的一个有解函数\(f(x)=1\times 10^{-6}x=0.000001x\)（所给数据只精确到6位小数），也存在\(f(10^6)=1\)，取最近的素数\(f(10^6+3)>1\)；
  • 综上，我们可以在\((0, 10^6+3)\)区间上二分出满足\(f(x)=1\)的答案。二分精度为\(10^{-6}\)。
• 当常数项大于或等于1，则\(\forall C\geq 1, \forall x>0, f(x)=g(x)+C>1\)恒成立，此时无解。
• 当\(f(10^6+3)<1\)，说明出现比\(1\times 10^{-6}\)更小的系数，即系数全为0，此时无解。
• 时间复杂度：设\(f(x)\)最多有N项，最坏\(O(N log_2((10^6+3)\times 1/10^{-6}))=O(40N)\)

参考代码（出题人的代码）

#include <stdio.h>
#include <stdlib.h>
double g[1000007];
int n=0;
double f(double x) {
    double ans=0, leg=1;
    for (int i=0; i<n; i++) {
        ans+=g[i]*leg;
        leg*=x;
    }
    return ans;
}
int main() {
    char c;
    while (~scanf("%lf%c",g+n++,&c)) {
        if(c=='\n') {
            if (g[0]>=1 || f(1000009)<1) puts("");
            else {
                double L=0, R=1000009;
                for (; R-L>1e-6; ) {
                    double M=(L+R)*.5;
                    if (f(M)<1) L=M;
                    else R=M;
                }
                printf("%.4f\n", L);
            }
            n=0;
        }
    }
}

01/22/17更新：牛顿迭代法

由于逆天出题人二分时没有考虑精度误差，导致部分数据与实际事实不符。这里给出牛顿迭代解
注：

1. 已与Mathematica对比正确；
2. deriv()是近似求导；
3. 实际上我更倾向于迭代若干次，比如100次，而不是迭代到指定精度。

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

const int MAXM = 1000003;
const double Eps = 1e-7;

int count = 0;
double coeff[1000007];

std::pair<double, double> calc(double x) {
    double func = .0, deriv = .0, p = 1.0;
    for (int i = 0; i < count; ++i) {
        double item = coeff[i] * p;
        func += item;
        deriv += i * item;
        p *= x;
    }
    return std::make_pair(func, deriv);
}

double func(double x) {
    double res = .0, p = 1.0;
    for (int i = 0; i < count; ++i) {
        res += coeff[i] * p;
        p *= x;
    }
    return res;
}

double deriv(double x) {
    return (func(x + Eps / 2.) - func(x - Eps / 2.)) / Eps;
}

inline int test() {
    return coeff[0] < 1 && func(MAXM) > 1;
}

void work2() {
    if (test()) {
        double x0 = .0, x = 1.0;
        while (fabs(x - x0) > Eps) {
            x0 = x;
            //x = x - (func(x) - 1) / deriv(x);
            std::pair<double, double> newton = calc(x);
            x = x - (newton.first - 1) / newton.second;
        }
        if (x > 0) printf("%.4f", x);
    }
    putchar('\n');
}

int main() {
/*    freopen("new_in.txt", "r+", stdin);
    freopen("new_out2.txt", "w+", stdout);*/
    char c;
    while (~scanf("%lf%c", &coeff[count++], &c)) {
        if (c != '\n') continue;
        work2();
        count = 0;
    }
    return 0;
}

### H. 续时间

Problem Description

Czj快毕业了，但他还想留在学校里，于是找到了SCNU最强大的魔法师Wwj买时间。
Wwj觉得他太蠢了，想要为难他一下，就用了分身术boom的一下变成了好多个Wwj。
Ccr经过一番侦查，发现\(N\)个Wwj的法力不一，第\(i\)个Wwj只能给Czj延长\(T_i\)的在校时间，但收费取决于心情，是心情的\(P_i\)倍，而当前Wwj的心情是\(D_i\)。
Hyr经过一番侦查，发现魔法值不一定要完全用完，比如当前Wwj收费\(C\)，Czj可以拿出\(C * a\%\)的财宝，来换取对应只有\(T_i * a\%\)的时间。
即使Czj家财万贯，天天请Lht奶茶喝，也经不住如此高昂的花费。所以他只带总共价值为M的财宝，去找Wwj的魔法分身换时间。
Lzp想知道Czj最多能延迟多长的在校时间。

Input

第一行为一个正整数\(T<50\)，代表有\(T\)种情况。
第二行输入每种情况的\(N\)和\(M\)，均是正整数，\(N\leq 1000\)，\(M\leq 10000\)。
接下来\(N\)行，每行有三个正整数，分别是\(T_i\)、\(P_i\)、\(D_i\)，均不大于\(100\)。

Output

对于每种情况，输出Czj最大能延长的时间，由题意知可能存在小数，请保留4位小数。

Sample Input

1
3 10
10 3 2
5 2 2
5 3 2

Sample Output

15

解题思路

• 我出的题都是良心题。这题是用贪心法做。我知道新生想在短时间内想出来还是挺难的，定位是中等题（什么叫难题？你看上面那两个..正常人会做的？）
• 本来我的题面是有强调 a% 的，但是我写LaTeX公式时没有对百分号 % 做转义处理，导致pdf上没显示出来，影响部分同学没看懂题，十分抱歉。
• 正解：
  1. 因为财富是一定的，所以隐含了要花最少的代价，买到最多的商品。想通了这点，你就知道应该要去计算性价比（或单价）（单价与性价比互为倒数）；
  2. 但这里的价格计算方式不一样，因为最终的花费是\(P_i\times D_i\)，所以性价比是\(\frac{T_i}{P_i\times D_i}\)；
  3. 对所有种类商品的性价比进行排序，优先买性价比最高（单价最低）的。最后由于可以买部分数量商品而不需要全买（即允许购买 a%），把剩余的钱数跟性价比一乘，就是还能买的 a% 数量的商品。
• 贪心策略证明：
  • 如果在一个可行的购买方案中，存在性价比更高的商品有剩余（没购买），那么购买该性价比更高的商品，而不够买原方案中相应总价的性价比最低商品，总能获得更多数量的商品。
  • 因此所有购买性价比最高商品的局部最优解的总和是全局最优解。

参考代码（这里采用结构体排序，并用了C++语法）

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

void generate() {
    FILE *outFile = freopen("in.txt", "w+", stdout);
    int T = rand() % 10 + 11;
    fprintf(outFile, "%d\n", T);
    while (T--) {
        int N = rand() % 1000 + 1;
        int M = rand() % 10000 + 1;
        fprintf(outFile, "%d %d\n", N, M);
        while (N--) {
            int Ti = rand() % 100 + 1;
            int Pi = rand() % 100 + 1;
            int Di = rand() % 100 + 1;
            fprintf(outFile, "%d %d %d\n", Ti, Pi, Di);
        }
    }
}

struct Magic {
    int T, P, D, cost;
    double ratio;

    bool operator<(const Magic &c) const {
        return fabs(ratio - c.ratio) > 1e-7 && ratio < c.ratio;
    }
} magic[1010];

int main() {/*
  generate();
  freopen("in.txt", "r+", stdin);
  freopen("out.txt", "w+", stdout);*/
    int T, N, M;
    scanf("%d", &T);
    while (T--) {
        scanf("%d%d\n", &N, &M);
        for (size_t i = 0; i < N; ++i) {
            int Ti, Pi, Di;
            scanf("%d%d%d\n", &magic[i].T, &magic[i].P, &magic[i].D);
            magic[i].cost = magic[i].P * magic[i].D;
            magic[i].ratio = (double) magic[i].T / magic[i].cost;
        }
        std::sort(magic, magic + N);
        double res = 0.;
        for (size_t i = N - 1; i >= 0; --i)
            if (M > magic[i].cost) {
                M -= magic[i].cost;
                res += magic[i].T;
            } else {
                res += M * magic[i].ratio;
                M = 0;
                break;
            }
        printf("%.4f\n", res);
    }
    return 0;
}

出题及解题总结

我校ACM吃枣药丸

建议、意见、吐槽

欢迎在下方评论区提出问题，12月内我都会回复and更新。

本文基于知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议发布，欢迎引用、转载或演绎，但是必须保留本文的署名BlackStorm以及本文链接http://www.cnblogs.com/BlackStorm/p/SCNUCPC_2016_For_Freshman_Final_Solution.html，且未经许可不能用于商业目的。如有疑问或授权协商请与我联系。