郑州大学2018新生训练赛第十场题解

　　比赛（补题）地址：http://222.22.65.164/problemset.php

　　题号为：4305 —— 4309

　　总述：这次新生赛难度偏于平和，但涵盖方面甚广，其中一道签到题是c语言题，并且有两道是hdu一百题的原题，一道简单的最小生成树，唯一“有些难度”的应该是一道数论题（毕竟本来自己就是搞数学的）。

 　　A.沙漠骆驼

　　　　　　

　　　　　　

　　这是一道经典的递推问题，原型为HDU 2044的“一只小蜜蜂…”。思路很简单，以第5个沙丘为例，到达第五个沙丘的方式有两种：从第3个向 右走，或从第4个向右上走。设dp[ i ]为从第一个沙丘走到第i个的路径数，我们容易得到递推方程：

　　　　　　　　　　　　　　　　　　　　dp[5] = dp[4] + dp[3]

　　那么依此类推，得到一般的递推方程：

　　　　　　　　　　　　　　　　　　　　dp[ i ] = dp[ i-1 ] + dp[ i-2 ]

　　而从第a个到第b个，则可以简化为第1个到第b-a个。

　　　　　　　　

ll f[100];
 
void init() {
    f[1] = f[2] = 1;
    for (int i = 3; i < 100; i++) {
        f[i] = f[i - 1] + f[i - 2];
    }
}
 
int main() {
    init();
     
    int t;
    scanf("%d", &t);
    int a, b;
    while (t--) {
        scanf("%d%d", &a, &b);
        printf("%lld\n", f[b - a + 1]);
    }
     
    return 0;
}

 

　　B.炉石传说真好玩！

　　水题，原题是 HDU 2052 的 “Picture”，直接放代码：

int main() {
    int n, m;
    while (~scanf("%d%d", &n, &m)) {
        putchar('+');
        for (int i = 0; i < n; i++) putchar('-');
        putchar('+');
        putchar('\n');
        for (int i = 0; i < m; i++) {
            putchar('|');
            for (int j = 0; j < n; j++) {
                putchar(' ');
            }
            putchar('|');
            putchar('\n');
        }
        putchar('+');
        for (int i = 0; i < n; i++) putchar('-');
        putchar('+');
        putchar('\n');
        putchar('\n');
    }
     
    return 0;
}

 

　　C.加油啊！奥托大人！

　　Emmm，这是一道裸的Kruskal，不理解的大家可以搜索一下，不想搜的也可以等数据结构老师讲，2333.

　　这道题的原题是 HDU 1863 的 “ 畅通工程”。

　　代码如下：

struct Edge {
    int from, to, w;
     
    Edge(int from = 0, int to = 0, int w = 0):
    from(from), to(to), w(w) {}
     
    bool operator < (const Edge &rhs) const {
        return w < rhs.w;
    }
} edge[MAXEDGE];
 
int parents[MAXVERTEX];
int vertices, edges;
 
void init() {
    for (int i = 1; i < MAXVERTEX; i++) {
        parents[i] = i;
    }
}
 
int find(int x) {
    if (parents[x] == x) {
        return x;
    } else {
        return parents[x] = find(parents[x]);
    }
}
 
bool unite(int x, int y) {
    x = find(x);
    y = find(y);
    if (x == y) {
        return true;
    } else {
        parents[y] = x;
    }
    return false;
}
 
int kruskal() {
    init();
    sort(edge, edge + edges);
    int ans = 0, counter = 1;
    for (int i = 0; i < edges; i++) {
        if (unite(edge[i].from, edge[i].to)) {
            continue;
        } else {
            ans += edge[i].w;
            counter++;
        }
        if (counter >= vertices) {
            break;
        }
    }
    if (counter >= vertices) {
        return ans;
    } else {
        return -1;
    }
}
 
int main() {
    int u, v, w;
     
    while (~scanf("%d%d", &edges, &vertices)) {
        if (edges == 0) break;
        for (int i = 0; i < edges; i++) {
            scanf("%d%d%d", &u, &v, &w);
            edge[i] = Edge(u, v, w);
        }
         
        int ans = kruskal();
        if (ans == -1) {
            printf("?\n");
        } else {
            printf("%d\n", ans);
        }
    }
     
    return 0;
}

 

　

　　D.大家快来%啊！

　　这。。。签到题就不用讲，也不用放代码了吧。

　　唯一需要注意的是纯c选手输出时需要将%转义。

　　　　

　　E.R.I.P.

　　根据算数基本定理，任何一个自然数都可以唯一地分解为若干个素数的乘积，如果我们列出这个数所有的质因数，并写成幂的乘积的形式，则称其为标准素因数分解式：

　　比如：对于120，120 = 2*2*2*3*5，写成标准素因数分解式就是：

　　　　　　　　　　　　　　　　　　　　120 = 2³ * 3¹ * 5¹

　　那么我们就可以轻易地得到 120 因子个数：所有幂次+1的乘积 

　　也就是：                                       ( 3 + 1 ) * ( 1 + 1 ) * ( 1 + 1 ) = 16　　

　　.....在此证明过程不再赘述　

　　知道了这些，我们来考虑让一个数因子个数扩大到二倍（我们称其为一次“扩展”）的 “ 费用 ” ： 

　　我们可以将总的费用写为素因子幂的乘积的形式。

　　考虑这样实现：将总费用维护为一个堆（为什么要维护成堆？请认真思考），每个素因子的费用都保存在一个含有“ 底数，指数，值 ”的结构体中。

　　初始时堆中没有元素，通过不断进行“ 扩展 ”，逐渐向堆中增加元素，直到因子个数符合要求（500500）。

　　那么 最后每一个结构体中的值再除以底数（为什么要除以底数？请认真思考） 的乘积就是总的费用。

　　在考虑操作方法，不外乎有两种：                                                     

　　　　1、扩展一个新的（指数为0）的素因子（比如说取了 2），并标记为“新素数”（以待后用）。

　　　　　　同时对这个素因子的费用进行更新 2^{（0+1）->(1 + 1)}　　　　　　　　　　　

　　　　2、在堆中取扩展费用最小的素数，进行扩展（更新其指数），同时更新其费用。

　　　　　　如果这个素数是一个“新素数”，那么我们从打好的素数表中，取下一个素数（比如说取了2）进堆，将其指数初始化为0。

　　下边来看一下代码实现：

#include<bits/stdc++.h>
#define ll long long
using namespace std;
int MAXN=600000,curnum=0;
bool vis[10000000];
vector<int> sushu;
int cursushu=0;
struct node{
    int dishu;
    int zhishu;
    ll zhi;

};
bool operator<(node a,node b)
{
    return a.zhi>b.zhi;
}

priority_queue<node> dui;
ll ans=1;

void dabiao(){
    for(ll i=2;;i++){
        if(!vis[i]){
            sushu.push_back(i);
        }
        if(sushu.size()>500500){
            break;
        }
        for(ll j=i*i;j<10000000;j+=i){
            vis[j]=true;
        }
    }
}
void addnew(int x){
    node p;
    p.dishu=sushu[x];
    p.zhishu=1;
    p.zhi=p.dishu;
    dui.push(p);
}


void update_old_node(node tmp){
    node a;
    a.dishu=tmp.dishu;
    a.zhishu=tmp.zhishu*2;
    a.zhi=1;
    for(int i=0;i<a.zhishu;i++){
        a.zhi*=a.dishu;
    }
    dui.push(a);
}

void act(){
    node tmp=dui.top();
    dui.pop();
    if(tmp.dishu==sushu[cursushu-1]){
        addnew(cursushu++);
        update_old_node(tmp);
    }
    else{
        update_old_node(tmp);
    }
}

int main()
{
    cout<<"Input N:"<<endl;
    int n;
    cin>>n;
    dabiao();
    addnew(cursushu++);
    for(int i=0;i<n;i++)
        act();
    while(!dui.empty()){
        ans*=(dui.top().zhi/dui.top().dishu%500500507);
        ans%=500500507;
        dui.pop();
    }
    cout<<ans;
}

 

　　　更新得这么迟实在不好意思，抱歉耽误大家时间了，QAQ！