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算法 表达式求值
这两天看到的内容是关于栈和队列，在栈的模块发现了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。如果大家还有更好的，更适用的算法，欢迎在评论中给出地址，谢谢。
转载
❸ 一道关于java排序算法的题目（蓝桥杯编程题）
import java.io.BufferedInputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;
public class Main
{
int re = 0;
public String doFilter()
{
//在这里我把断号和重号的初始值都设置成0，实际情况是不可能出现0的情况，所以设置成0.
int m = 0;// 表示断号
int n = 0;// 表示重号
List<String[]> list = new ArrayList<String[]>();
List<Integer> numList = new ArrayList<Integer>();
Scanner scan1 = new Scanner(System.in);
Scanner scan2 = new Scanner(new BufferedInputStream(System.in));
int rowNum = scan1.nextInt();
// 把输入所有行的数据放到numList里
for (int i = 0; i < rowNum; i++)
{
String s = scan2.nextLine().trim();
String[] nums = s.split(" ");
for (String str : nums)
{
if (str.trim().length() != 0)
{
numList.add(Integer.valueOf(str));
}
}
}
// 使用工具类对numList进行排序
Collections.sort(numList, new Comparator<Integer>()
{
@Override
public int compare(Integer a, Integer b)
{
if (a > b)
{
return 1;
}
return -1;
}
});
for (int i = 0; i < numList.size() - 1; i++)
{
//得到断号
if (numList.get(i) == numList.get(i + 1))
{
n = numList.get(i);
continue;
}
//得到重号
if ((numList.get(i) + 1) != numList.get(i + 1))
{
m = numList.get(i) + 1;
}
}
return m + " " + n;
}
public static void main(String[] args)
{
//测试下
System.out.println(new Main().doFilter());
}
}
❹ “蓝桥杯【算法提高】打包”这道题怎么写
思路：
1 最大单个包与平均包重取大取整的大者作为初始答案
2 检查答案符合否
3 不符合就最小步伐扩大
4 2、3循环直至符合
❺ java 蓝桥杯的一个算法题问题;
publicclasslanqiao6{
publicstaticvoidmain(String[]args){
intcount=0;
for(inta=1;a<10;a++)
for(intb=1;b<10;b++)
for(intc=1;c<10;c++)
for(intd=1;d<10;d++)
for(inte=1;e<10;e++){
Set<Integer>set=newHashSet<Integer>();
set.add(a);
set.add(b);
set.add(c);
set.add(d);
set.add(e);
if(set.size()!=5)
continue;
intsum1=(a*10+b)*(c*100+d*10+e);
intsum2=(a*100+d*10+b)*(c*10+e);
if(sum1==sum2)
count++;
}
System.out.print(count);
}
}//-_-|| 让你用深度优先搜索你整5个for循环真的好吗？
❻ 蓝桥杯的算法题k好数是什么意思，完全不明白要干什么，不要代码，解释这题是干吗的
就是要你求满足以下条件的序列的个数
1.有L个数
2.每个数在0到k的范围内
3.相邻的数差不等于一
4.第一个数不是0
方法就是递推，f[i][j]表示共i位最后一位为j时的方案数。
❼ JAVA蓝桥杯题库算法训练
不知道你在说什么，你到底要干嘛阿？
❽ 蓝桥杯的题 十六进制转八进制 我的解法哪里错了
虽然你没有上传完整题目
但从你数组开到20000000来看
输入的16进制很可能是很长的
这样 sscanf(a[i],"%x",&b[i]);
整型的b很可能是存不下的 导致错误。
比如输入
1234567890ABCDEF
转成8进制应该是
110642547422052746757
明显你这个代码会得出错误结果。
❾ 蓝桥杯 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;
}
❿ 蓝桥杯算法提高 递推求值
楼主你好(网络终于显示我的回答了^_^)解题思路：首先不难发现对于一个分数可能的答题情况有:2^20=1024种正确为1，错误为0显然这就需要用到二进制数了也就是遍历整数：0~1023每一个整数的二进制数代表一个答题方案(0就表示0000000000十道题全错；1023表示1111111111十道题全对)具体实现代码如下：(非递归算法)#includevoidfun(intn,intscore)//输出答题情况{inta[11],i=1,k=512,sum=10;while(i<11)//求出当前答题情况的二进制表达式(正序求余){a[i]=(n/k)%2;sum=a[i]?sum*2:sum-i;k/=2;i++;}if(sum==score)//如果当前分数等于预定分数就输出答题情况{for(i=1;i<11;i++)printf("%d",a[i]);printf("\n");}}intmain(){inti,score;printf("Enterthescore:");scanf("%d",&score);for(i=0;i<1024;i++)//遍历所有的答题情况fun(i,score);return0;}输出的结果为:希望能帮助你哈(这是我在自己网络空间共享的解法有注释应该能明白吧)