蓝桥杯官网练习系统历届真题详解

欢迎评论指出错误，提出疑问，或者不介意给出更好的解法，有交流才有进步。

 

PREV-3(带分数)

这道题就简单的求1-9九个数组成的带分数来表示数值n的个数

枚举1-9九个数组成的全排列，然后把每种排列分成整数、分子、分母三段

然后简单判断以下每个带分数是否和n相等

这里的剪枝在于枚举整数、分子、分母分别的位数

分母的位数肯定小于等于分子的位数

整数的位数肯定小于等于n的位数

<C++> Code

#include<stdio.h>

int n,a[10],ans,len;
bool f[10];//标记是否已加入排列中

//计算a[]中从第s位起长l位的整数大小 
int getNum(int s,int l){
    int num = 0;
    for(int i = 0 ; i < l ; i++){
        num = num * 10 + a[s+i];
    }
    return num;
}

//判断全排列中是否有组成满足条件的带分数 
void JudgeNum(){
    //现在枚举带分数 整数、分母、分子的位数 
    for(int zs = 1 ; zs <= len ; zs++){//整数的位数 
        int NumZS = getNum(0 , zs);//整数 
        int Len = 9 - zs;//分子加分母的位数 
        for(int fm = 1 ; fm <= Len/2 ; fm++){ 
            int NumFM = getNum(zs , fm);//分母 
            int fz = Len - fm;
            int NumFZ = getNum(zs + fm , fz);//分子
            if(NumFZ%NumFM == 0 && (NumZS + NumFZ/NumFM) == n)
                ans++;
        }
    }
}


//dfs遍历1-9组成的全排列 
void dfs(int k){
    if(k == 9){//生成了一种排列 
        JudgeNum();
        return;
    }
    for(int i = 1 ; i < 10 ; i++){//枚举第k位上的数 
        if(!f[i]){
            a[k] = i;
            f[i] = true;
            dfs(k+1);
            f[i] = false;
        }
    }
}


void work(){
    //因为全局变量自动初始化为0(false),所以省了初始化 
    int x = n;
    while(x){//求n的位数len
        len++;
        x /= 10;
    }
    dfs(0);
    printf("%d\n",ans);
}


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

我觉得在getNum()上还可以优化一下

 

PREV-9(大臣的旅费)

题目给定n个城市，n-1条路，显然题意是要在一棵树上求任意两点距离的最大值

/----------------------------------接下来两段可忽略------------------------------------/

题目没给定n的范围，所以贸然用Floyd来求两点间的最短距离是不可取的

Floyd的时间复杂度为O(n^3),n随便取大一点就很容易超时

再者，这题不需要求两点间的最短距离，因为任意两点间的距离都是固定的(这个可以自己想想)

 

在一棵树上求两点的距离，或许会想到两点的最近公共祖先，用算法LCA来求

求任意两点的最近祖先，得查询C(n,2)次，时间复杂度为O(n^2) 这样仍然不能保证全过

听说有一种将最近公共祖先转换成RMQ问题的时间复杂度为O(nlogn)的在线算法(可自行度娘)

当然这题也不应该用关于两点的最近公共祖先的算法来求，在n未知的情况下，时间复杂度还是太高了

/----------------------------------以下才是关键------------------------------------/

题目只要求最大值，完全可以用树形动归来，dfs遍历一遍所有边就好，时间复杂度O(n)

任意取一点作为根结点，dfs深搜，从叶子节点向上动归

DP[i]维护以i为根节点的子树中节点i到叶子节点的最长距离

MAX[i]维护以i为根节点的子树中经过节点i的最大两点间距离 答案自然是MAX[]中的最大值

<C++> Code

#include<cstdio>
#include<algorithm>
using namespace std;
#define MAXN 100010 //不知n为多大，随便定义了个，可以定义更大，也可以想想用vector容器 
#define LL long long

int n;
LL Dp[MAXN],Max[MAXN],ans;//全区变量自动初始化为0 
 
//链式前向星  
int head[MAXN],m=1;//因为head[]中元素都为0，所以m从1计数就不用初始化head[]了 
struct Edge{
    int to,next,w;
}e[MAXN];

//链式前向星添加边 
void add_edge(int u,int v,int w){
    e[m].to = v;
    e[m].w = w;
    e[m].next = head[u];
    head[u] = m++;
}


bool f[MAXN];//标记节点是否已被访问过 
void dfs(int s){
    int k = head[s];
    while(k > 0){
        int t = e[k].to;//t为s的孩子节点 
        if(!f[t]){
            f[t] = true;
            dfs(t);
            Max[s] = max(Max[s] , Dp[s] + Dp[t]+e[k].w);//以s为根节点的子树中 经过s的最大两点间距离
            Dp[s] = max(Dp[s] , Dp[t]+e[k].w);//s到叶子节点的最长距离 
        }
        k = e[k].next;
    }
    ans=max(ans,Max[s]);
}


void work(){
    f[1]=true;
    dfs(1);//以节点1为根节点深搜 ，深搜前标记1被访问 
    printf("%I64d\n",ans*(21+ans)/2);
}


void init(){
    scanf("%d",&n);
    int p,q,d;
    for(int i = 1 ; i < n ; i++){
        scanf("%d%d%d",&p,&q,&d);
        add_edge(p,q,d);
        add_edge(q,p,d);//双向边建图，方便dfs 
    }
}


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