❶ 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演算法 表達式求值
這兩天看到的內容是關於棧和隊列，在棧的模塊發現了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;}輸出的結果為:希望能幫助你哈(這是我在自己網路空間共享的解法有注釋應該能明白吧)