CSDN编程竞赛第5期简要题解

legend_yst

已于 2022-09-15 15:38:44 修改

阅读量1.1k

点赞数

分类专栏： ACM 文章标签： acm竞赛算法 c++ golang

于 2022-09-09 17:20:07 首次发布

本文链接：https://blog.csdn.net/u010834463/article/details/126689700

版权

ACM 专栏收录该内容

16 篇文章 1 订阅

订阅专栏

序

点击直达比赛页面

退役OI/ACM选手。曾个人获NOI铜奖，组队获ACM亚洲区域赛金奖。有重回激情燃烧的岁月的感觉（笑~）

之前竞赛一般用C++，不过最近Golang用的多一些，高精度的题当然用Python比较方便，所以基本上想起什么用什么。
因为已经退役多年了，上次CSDN编程竞赛第4期得了六十多分……
这次题比较简单，结果得了95分，还算不错。一开始是第3，后来掉到第7了……

感觉比赛内容和OI/ACM类似，但形式不太一样：中文题目，有部分分而且即时出分数，不过不能看别人的做题顺序。

第4期比赛遇到过切换题目导致之前题目代码丢失的情况，第5期好像已经修复了？在线IDE果然不如JetBrains的IDE好用，也可能是我不太会用……

1.寻因找祖

题目大意

寻找因子个数为n的最小整数x
1<=n<=1000
（最小整数x应该说的是最小正整数）

简要题解

数学上有个质因数分解，就是把正整数分解成质数幂的乘积比如540=2² * 3³ * 5¹ ，然后可以得到因子个数(2+1)*(3+1)*(1+1)。

所以我初步的想法就是把n拆成若干个数相乘的形式，分配给每个质数的次数，显然 540=2² * 3³ * 5¹ 不如360 = 2³ * 3² * 5¹ 小。

但是会有一些问题，比如拆分的多细最优，2^(6-1) = 32 > 2^(3-1) * 3^(2-1) = 12，但其实也不是全是质因数最好，反例比如2^(4-1) * 3^(2-1) * 5^(2-1) = 120 < 2^(2-1) * 3^(2-1) * 5^(2-1) * 7^(2-1) * 11^(2-1) = 2310

最后时间来不及了……

更新：第一题没这么难，看来我想多了。看了别人的题解，应该是枚举就可以，但像我这样简单粗暴的枚举不行……

C++代码（20分/满分25分）

// 80%
#include <iostream>
#include <string>
#include <sstream>
#include <vector>
#include<algorithm>

using namespace std;

int solution(int n) {
    int result;
// TODO:
    if (n == 1) {
        return 1;
    }
    if (n > 40) {
        int v[100] = {}, tot = 0;
        for (int i = 2; i * i <= n; i++) {
            if (n % i == 0) {
                while (n % i == 0) {
                    v[tot++] = i;
                    n /= i;
                }
            }
        }
        if (n != 1) {
            v[tot++] = n;
        }
        // 2^4+3^4+5+7
        sort(v, v + tot);
        int p[10] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29};
        result = 1;
        for (int i = tot - 1; i >= 0; i--) {
            for (int j = 0; j < v[tot - i - 1] - 1; j++) {
                result *= p[i];
            }
        }
    } else {
        for (result = 1;; result++) {
            int i;
            int count = 0;
            for (i = 1; i * i < result; i++) {
                if (result % i == 0) {
                    count += 2;
                    if (count > n)break;
                }
            }
            if (i * i == result) count++;
            if (count == n)break;
        }
    }
    return result;
}

int main() {
    int n;
    std::cin >> n;
    int result = solution(n);
    std::cout << result << std::endl;
    return 0;
}

2.通货膨胀-x国货币

题目大意

X国发行货币最高面额为n。次高面额为n的因子。以此类推。 X国最多发行多少种货币。
n好像最大是1e9

简要题解

直接分解质因数，每次从上一种面额中除掉一个质因数，作为新面额。

C++代码（满分）

#include <iostream>
#include <string>
#include <sstream>
#include <vector>

int solution(int n) {
    int result;
// TODO:
    result = 1;
    for (int i = 2; i * i <= n; i++) {
        while (n % i == 0) {
            n /= i;
            result++;
        }
    }
    if (n != 1) {
        result++;
    }
    return result;
}

int main() {
    int n;
    std::cin >> n;
    int result = solution(n);
    std::cout << result << std::endl;
    return 0;
}

3.题目名称：莫名其妙的键盘

题目大意

有一个神奇的键盘，你可以用它输入a到z的字符，然而每当你输入一个元音字母(a,e,i,o,u其中之一)的时候，已输入的字
符串会发生一次反转！比方说，当前输入了tw，此时再输入一个o，此时屏幕上的字符串two会反转成owt。现给出一个
字符串，若用该键盘输入，有多少种方法可以得到？

最大长度好像是200

简要题解

如果根本没有元音，显然只有1种答案。

只要有元音，至少有一个在最终字符串开头，否则没有方法得到。因为不可能把非元音，加到被反转到开头的元音的前面。

可以倒退最终结果是怎么来的：
最后一个元音之后的非元音，在最终数组中显然只能是按顺序依次在后面追加的。
之前加入的是最终结果最前的元音，加入后反转了，这也没有其它方案。
这样一直倒推，删掉末尾非元音，反转，以此类推……
但最后只有两个元音的时候情况不一样了，比如abca，可能的顺序有acba, caba, bcaa，可以发现这取决于最后两个元音的间距。

注意考虑长度分别为奇数和偶数的情况。

Golang代码（满分）

package main
import "fmt"
func solution(str string){
	// TODO: 请在此编写代码
	pos := []int{}
	for i, s := range str{
		if s=='a'||s=='e'||s=='i'||s=='o'||s=='u'{
			pos = append(pos, i)
		}
	}
	length := len(pos)
	if length==0{
		fmt.Println(1)
	}else if pos[0]!=0{
		fmt.Println(0)
	}else{
		if length==1{
			fmt.Println(len(str)-pos[0])
		}else if length%2==1{
			fmt.Println(pos[length/2+1] - pos[length/2])
		}else{
			fmt.Println(pos[length/2] - pos[length/2-1])
		}
	}
}
func main() {
	var str string
	fmt.Scan(&str)
	solution(str)
}

4.三而竭

题目大意

一鼓作气再而衰三而竭。小艺总是喜欢把任务分开做。小艺接到一个任务，任务的总任务量是n。第一天小艺能完成x份
任务。第二天能完成x/k。。。。第t天能完成x/(k^(t-1))。小艺想知道自己第一天至少完成多少才能完成最后的任务。

简要题解

注意按给的例子这个份必须是整份，不然直接套等比数列求和公式，取极限，然后解不等式就行了。

可以从最后一次完成的份数倒推，比如一共(t+1)天，最后一天完成了x0，显然有0<x0<k。
倒数第二天完成了x1+k*x0，有0<=x1<k。
倒数每天完成的任务可以表示为
x0
x1+kx0
x2+k(x1+kx0)
……
xt+k(x(t-1)+……+k(x1+kx0))……)
总共完成份数为(k^t + k^t-1 +……+1)x0 + …… +(k+1)x(t-1) + xt时，第一天完成了xt+k(x(t-1)+……+k(x1+kx0))……)

总任务是已知的，可以按类似高精度的思想拆分，除以(k^t + k^t-1 +……+1)求商x0和余数，再除(k^t-1 + k^t-2 +……+1)求商x1和余数。
求出x0……xt，带入到第一天完成的xt+k(x(t-1)+……+k(x1+kx0))……)，就是k^t x0+k^t-1 x1+……+xt

Golang代码（满分）

package main

import "fmt"

func solution(arr [2]int) {
	// TODO: 请在此编写代码
	n := int64(arr[0])
	k := int64(arr[1])
	base := []int64{}
	kp := []int64{}
	for sum, b := int64(1), k; sum <= n; sum, b = sum+b, b*k {
		base = append(base, sum)
		kp = append(kp, b/k)
		//fmt.Println(sum, b/k)
	}
	var ans int64
	for i := len(base) - 1; i >= 0; i-- {
		x := n / base[i]
		ans += kp[i] * x
		n -= base[i] * x
	}
	fmt.Println(ans)
}
func main() {
	var arr [2]int
	for i := 0; i < 2; i++ {
		fmt.Scan(&arr[i])
	}
	solution(arr)
}