蓝桥杯算法公式

㈠ 蓝桥杯都是考啥

c/c++

填空题以暴力枚举，DFS搜索，字符串处理为主。

第1，2题会围绕数据处理考，这种题考的就是你做题的细节和思维（短时间内出结果的方法），分值偏低且短时间内不容易出答案，麻烦就先做后面的题。

第3，4，5，6题会围绕DFS搜索回溯和字符串处理和模拟题为主，需要看看队列，栈，map，vector，优先队列，set等容器，图形处理，简单的动态规划（公式或模板）为辅进行考，代码填空题看完题直接将代码复制到DEV上进行添加代码和运行。结果填空题如果有复杂方法，想不到简单方法，在时间复杂度允许的情况（10^9以下都可以等它出结果，最多10^11的代码就不要运行了）下，可以让它在后台运行着去看后面的题，要确保运行的复杂代码出现的结果是对的（你自己必须认为这样做是对的，如果对复杂的代码的思想比较模糊就不要去打，直接去看下面的题，根据分值进行合理安排）。

代码大题会以思维题和高效算法进行出题，代码大题要想满分考的基本上都是nlog(n)的算法，最最常用的算法就是二分算法，其次就是二分算法思想，复杂的动态规划，树型结构（树型结构题目不会太难，就考思想和性质，线段树出现的概率很大，可以选择性的用线段树和树状数组做）的题目，归并算法是二分算法的扩展，出现的概率也很高。代码大题也会用到容器的知识，还有很多的算法也会出现，比如数论和图论等。

㈡ 参加蓝桥杯需要会什么算法 c/c++ 本科B组

好像什么都不不需要都有三等奖，要准备算法可以看看算法导论。

㈢ 蓝桥杯 ADV-151 算法提高 金陵十三钗 求解题思路

对于70%的数据,直接用全排列枚举出每个女生对应的人然后求解,取最大值,时间复杂度是O(n*n!),对于n<=10，是可以接受的

对于100%的数据，可以采用状态压缩的办法进行动态规划：

dp[i][j]表示现在进行到i个女人，被占用学生的状态为j的最大制。

将状态j表示成二进制，第k位为1表示第k个学生已经被占用了。

比如j=3,二进制是00000011,表示第1和第2个学生已经被占用。

对于初始状态：

dp[0][j]=0

转移方程是：

dp[i][j]=max(dp[i-1][k]+like[i][t]）

其中t是j中其中1个1的位置，k是j把第t位变成0的数，把所有t找一边取个最大值再+like[i][t],就是dp[i][j]

答案就是dp[n][2^n-1]

时间复杂度应该是O(n*2^n)

考虑到对于所有i，只和i-1项有关，所以可以减少一维空间消耗

对于n<=13是可以秒出的。

最后再贴一份刚写的新鲜的代码:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#defineMAXN15
usingnamespacestd;
constintmaxzt=(1<<13);//最大的状态数,
intdp[maxzt];
intlike[MAXN][MAXN],n;
intnumberOfOne(intnum){//num二进制中1的个数
intcnt=0;
while(num){
cnt+=(num&1);
num>>=1;
}
returncnt;
}
intlowbit(intx){//num二进制中只保留最后一个1如:num=20二进制10100返回二进制100，也就是4
returnx&(-x);
}
intposOfOne(intnum){//num二进制中最后一个1的位置如:num=18二进制10010返回2
intpos=0;
while(num){
pos++;
if(num&1)
returnpos;
num>>=1;
}
returnpos;
}
voidwork(intx){
intmaxstatus=1<<n;
for(inti=0;i<maxstatus;i++){
intnowstatus=i,t=numberOfOne(nowstatus);
if(t!=x)continue;//第x位女人有x个1，不是就继续找下一个数
while(t--){
intpos=lowbit(nowstatus);
dp[i]=max(dp[i],dp[i-pos]+like[x][posOfOne(pos)]);
nowstatus-=pos;
}
}
}
intmain(){
scanf("%d",&n);
for(inti=1;i<=n;i++)
for(intj=1;j<=n;j++)
scanf("%d",&like[i][j]);
memset(dp,0,sizeof(dp));
for(inti=1;i<=n;i++)
work(i);
printf("%d
",dp[(1<<n)-1]);
return0;
}

㈣ 蓝桥杯省赛(C语言)一般考什么

还是跟选拔赛一样的题型
考的是算法类的题目

㈤ 蓝桥杯的算法题k好数是什么意思，完全不明白要干什么，不要代码，解释这题是干吗的

就是要你求满足以下条件的序列的个数
1.有L个数
2.每个数在0到k的范围内
3.相邻的数差不等于一
4.第一个数不是0
方法就是递推，f[i][j]表示共i位最后一位为j时的方案数。

㈥ java/C 求幸运数字 蓝桥杯试题，求解答！求算法！

package com.sise.hhz.LQB;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;
import java.util.Scanner;
public class LuckyNumber
{
static Integer count = 0;
static Integer index = 1;
public static void getLuckyNum(LinkedList al, Integer min, Integer max, Integer luckyNum)
{
ListIterator lt = al.listIterator();
Integer maxSize = al.size();
boolean judge = true;
for(Integer i = 1; i <= maxSize; i++)
{
lt.next();
if(i % luckyNum == 0)
{
judge = false;
lt.remove();
}
}
if(judge)
{
lt = al.listIterator();
while(lt.hasNext())
{
if((Integer)lt.next() > min)
{
count =al.size() - lt.previousIndex();
return;
}
}
return;
}
luckyNum = (Integer)al.get(index++);
getLuckyNum(al, min, max, luckyNum);
}
public static void main(String []src)
{
LinkedList al = new LinkedList();
Integer min = 0;
Integer max = 0;
Scanner sn = new Scanner(System.in);
min = sn.nextInt();
max = sn.nextInt();
for(int i = 1; i < max; i++)
{
al.add(i);
}
getLuckyNum(al, min, max, 2);
System.out.println(count);
}
}

㈦ 蓝桥杯java常考哪些算法

可以到java 黄埔军校看看，有很多java问题的解决办法

㈧ 算法训练 2的次幂表示(蓝桥杯C++写法)

这里用了递归的算法，具体思路是：将输入的数b先拆分成2的n次幂的和，再将各个幂次方（即指数）拆分成2的n次幂的和……知道幂次方为0或1为止。很明显，这是函数递归的思想。
大佬的思路是，先判定b是否满足要求（幂次方为1或0），如果是，输出2（0）或2，如果不是，从最接近b的2的n次方开始分解，分解完再减去2的n次方，再从剩下的数中开始分解......直到满足要求为止。

㈨ 蓝桥杯单片机比赛，会51单片机可以参加吗

蓝桥杯单片机比赛会51单片机是可以参蓝桥杯比赛的。

单片机设计与开发（本科组，高职高专组）需要具备模拟、数字电路，传感器及MCS51系列单片机的相关知识，常用仪器使用方面的知识，程序编译调试和下载软件使用方面的知识。每位选手只能参加其中一个组别的竞赛。

(9)蓝桥杯算法公式扩展阅读

蓝桥杯比赛时长

软件比赛：4小时，全程封闭。

电子类比赛：5小时，全程封闭。

蓝桥杯比赛形式

软件类：全程机考。

选手机器通过局域网连接到各个分赛区的竞赛服务器。

选手答题过程中无法访问互联网，也不允许使用本机以外的资源（如USB连接）。

以“服务器-浏览器”方式发放试题、回收选手作答。

电子类：动手操作

注意事项

1、选手必须符合参赛资格，不得弄虚作假。资格审查中一旦发现问题，则取消其报名资格；竞赛过程中发现问题，则取消竞赛资格；竞赛后发现问题，则取消竞赛成绩，收回获奖证书及奖品等，并在大赛官网上公示。

2、参赛选手应遵守竞赛规则，遵守赛场纪律，服从大赛组委会的指挥和安排，爱护竞赛赛场地的设备。

㈩ 蓝桥杯算法训练 java算法 表达式求值

这两天看到的内容是关于栈和队列，在栈的模块发现了Dijkstra双栈算术表达式求值算法，可以用来实现计算器类型的app。

编程语言系统一般都内置了对算术表达式的处理，但是他们是如何在内部实现的呢？为了了解这个过程，我们可以自行搭建一套简易的算术表达式处理机制，这里就用到栈特性和本篇提到的Dijkstra算法。

概述：
算术表达式可能是一个数、或者是由一个左括号、一个算术表达式、一个运算符、另一个算术表达式和一个右括号组成的表达式。为了简化问题，这里定义的是未省略括号的算术表达式，它明确地说明了所有运算符的操作数，形式如下：

（1+（（2+3）*（4*5）））

思路：

表达式由括号、运算符和操作数构成，我们根据以下4中情况从左至右逐个将这些实体送入栈处理：

1.将操作数压入操作数栈；

2.将运算符压入运算符栈；

3.忽略左括号；

4.在遇到右括号时，弹出一个运算符，弹出所需数量的操作数，并将运算后的结果压入操作数栈；

在处理完最后一个右括号时，操作数栈上只会剩下一个值，它就是表达式的计算结果。这种方法咋一看难理解，但要证明它能计算得到正确的值很简单：

每当算法遇到一个括号包围，并由一个运算符和两个操作数组成的子式时，他都将运算符和操作数运算结果压入操作数栈。这样的结果就像是在输入中用这个值代替了该子表达式，因此用这个值代替子表达式得到的结果和原表达式相同。我们可以反复应用这个规律并得到一个最终值。

例如：

（1+（（2+3）*（4*5）））

（1+（5*（4*5）））

（1+（5*20））

（1+100）

101

代码实现：

这里我采用C#来实现，最终运行效果完全符合预期，证明了此算法的正确性，代码如下：

using System;
using System.Collections.Generic;
using System.Linq;

namespace Evaluate
{
class Program
{
static void Main(string[] args)
{
string testExpress = "(1+((2+3)*(4*5)))";
Console.WriteLine(Evaluate(testExpress));
}

//DijkStra
static double Evaluate(string express)
{
var expressChars = express.ToArray();
Stack ops = new Stack();
Stack vals = new Stack();
if (express.Length > 0)
{
foreach (var opt in expressChars)
{
switch (opt)
{
case '+':
case '-':
case '*':
case '/':
ops.Push(opt);
break;
case ')':
var op = ops.Pop();
var v = vals.Pop();
switch (op)
{
case '+':
v += vals.Pop();
break;
case '-':
v = vals.Pop() - v;
break;
case '*':
v *= vals.Pop();
break;
case '/':
v = vals.Pop() / v;
break;
}
vals.Push(v);
break;
case ' ':
case '(':
break;
default:
vals.Push(double.Parse(opt.ToString()));
break;
}
}
return vals.Pop();

}
return double.MaxValue;
}
}
}
总结：

Dijkstra算法充分利用了栈的特性，具备较高的执行效率，经过进一步的扩充修改，就完全可以实现具备科学计算功能的复杂计算类app。如果大家还有更好的，更适用的算法，欢迎在评论中给出地址，谢谢。
转载