bf演算法java

Ⅰ 求一個串中出現的第一個最長重復子串

在編寫程序猿的時候，你需要仔細的去對照每一個字，因為如果出現一個字錯誤的話，那麼就會導致編程不成功。

Ⅱ java遞歸演算法模擬簡單手機輸入法

public class T9 {
static private char[][] alpha = {{'a','b','c'},
{'d','e','f'},
{'g','h','i'},
{'j','k','l'},
{'m','n','o'},
{'p','q','r'},
{'r','s','t'},
{'u','v','w'},
{'x','y','z'}};
private int[] number;
private int length;
private boolean[][] used;

public void permutation(){
StringBuffer out = new StringBuffer();
this.length = number.length;
this.used = new boolean[length][3];
invoke(0,out);
}

public void invoke(int i,StringBuffer out){
if(i == length){

System.out.println(out);
return;

}else{

for(int j = 0; j<3; j++){
if(used[i][j])
continue;
else{
out.append(alpha[i][j]);
used[i][j] = true;
invoke(i+1, out);
used[i][j] = false;
out.setLength(out.length()-1);
}
}
}
}

public void setNumber(int...number){
this.number = number;
}

public static void main(String[] args){
T9 instance = new T9();
instance.setNumber(1,2,5);
instance.permutation();
}
}

Ⅲ 蟲蝕演算法是什麼,請給出該演算法的思想和一個java的實例

所謂蟲食演算法，就是原先的算式中有一部分被蟲子啃掉了，需要我們根據剩下的數字來判定被啃掉的字母。來看一個簡單的例子：
43#9865#045
+ 8468#6633
= 44445509678
其中#號代表被蟲子啃掉的數字。根據算式，我們很容易判斷：第一行的兩個數字分別是5和3，第二行的數字是5。
現在，我們對問題做兩個限制：
首先，我們只考慮加法的蟲食算。這里的加法是N進制加法，算式中三個數都有N位，允許有前導的0。
其次，蟲子把所有的數都啃光了，我們只知道哪些數字是相同的，我們將相同的數字用相同的字母表示，不同的數字用不同的字母表示。如果這個算式是N進制的，我們就取英文字母表午的前N個大寫字母來表示這個算式中的0到N-1這N個不同的數字：但是這N個字母並不一定順序地代表0到N-1)。輸入數據保證N個字母分別至少出現一次。
BADC
+ CRDA
= DCCC
上面的算式是一個4進制的算式。很顯然，我們只要讓ABCD分別代表0123，便可以讓這個式子成立了。你的任務是，對於給定的
N進制加法算式，求出N個不同的字母分別代表的數字，使得該加法算式成立。輸入數據保證有且僅有一組解，
輸入：
輸入文件中包含若干個測試用例。每個測試用例佔4行，第一行有一個正整數N(N<=26)，後面的3行每行有一個由大寫字母組成
的字元串，分別代表兩個加數以及和。這3個字元串左右兩端都沒有空格，從高位到低位，並且恰好有N位。
輸出：
對應每一組測試用例，以一行的形式輸出N個數字，分別表示A，B，C……所代表的數字，相鄰的兩個數字用一個空格隔開，
不能有多餘的空格。
樣例輸入：
5
ABCED
BDACE
EBBAA
*/

蟲食算 窮舉法實例：
import java.io.*;
class Bug
{
static int tmp1[];
static int tmp2[];
static int sum[];
static int position=0;
static boolean flag=false;
public static void main(String[] args) throws Exception
{
BufferedReader bf=new BufferedReader(new FileReader("bug.in"));
int n=Integer.parseInt(bf.readLine());
String str1=bf.readLine();
String str2=bf.readLine();
String str3=bf.readLine();
tmp1=new int[n];
tmp2=new int[n];
sum=new int[n];
for(int i=0;i<tmp1.length;i++)
tmp1[i]=n+i;
if(compare(str1,str2))go(0,str1,str2,str3);
else go(0,str2,str1,str3);
}
public static void go(int position,String str1,String str2,String str3)throws Exception
{
int p;
if(position==tmp1.length)
{
if(check(str1,str2,str3,tmp1.length))
{
flag=true;
print(tmp1.length,str1);
}
return;
}
for(int i=0;flag==false&&i<=tmp1.length-1;i++)
{
if((p=str1.lastIndexOf(str1.charAt(position),position-1))==-1)
tmp1[position]=i;
else {tmp1[position]=tmp1[p];}
if(!isExist(i,position))
go(position+1,str1,str2,str3);
}
}
public static boolean isExist(int num,int position)
{
for(int i=0;i<position;i++)
if(num==tmp1[i])
return true;
return false;
}
public static boolean check(String str1,String str2,String str3,int n)//n代表幾進制
{
int carry=0;//進位初始化
for(int i=0;i<tmp2.length;i++)
tmp2[i]=tmp1[str1.indexOf(str2.charAt(i))];

for(int i=tmp2.length-1;i>=0;i--)
{
sum[i]=tmp1[i]+tmp2[i]+carry;
if(sum[i]>=n)
{
carry=(sum[i]-sum[i]%n)/n;
sum[i]=sum[i]%n;
}
else carry=0;
}
for(int i=0;i<tmp2.length;i++)
if(tmp1[str1.indexOf(str3.charAt(i))]!=sum[i])
return false;
return true;
}
public static void print(int n,String str1)
{
for(int i='A';i<'A'+n;i++)
System.out.print(tmp1[str1.indexOf((char)i)]+" ");
}
public static boolean compare(String str1,String str2)
{
for(int i=0;i<str1.length();i++)
if(str1.indexOf(str2.charAt(i))==-1)
return false;
return true;
}
}

Ⅳ java實現漢諾塔的代碼，求注釋，具體到每一行代碼，急求，，，

這樣應該可以了
如果還有那個地方不懂的，建議你研究下漢諾塔演算法
import
java.io.BufferedReader;//引入IO包中的BufferedReader
import
java.io.IOException;//引入IO包中的IO異常處理
import
java.io.InputStreamReader;//引入IO包中的InputStreaReader
public
class
Hinoi
{
//主類
static
int
m=0;//定義移動的次數
//主程序入口--main方法
public
static
void
main(String[]
args)
{
//創建BufferedReader對象,InputStream輸入流
BufferedReader
bf
=
new
BufferedReader(new
InputStreamReader(System.in));
System.out.println("請輸入盤子的個數:");
try
{
int
sl
=
Integer.parseInt(bf.readLine().toString());//接收總盤子個數
toMove(sl,"A","B","C");//調用移動方法
A-->C
}
catch
(NumberFormatException
e)
{捕獲NumberFormatException異常
//
TODO
Auto-generated
catch
block
e.printStackTrace();//列印異常
}
catch
(IOException
e)
{//捕獲IOException異常
//
TODO
Auto-generated
catch
block
e.printStackTrace();//列印異常
}
System.out.println("總共移動了:"+m+"
次數");//列印移動次數
}
//移動方法
private
static
void
toMove(int
sl,
String
one,
String
two,String
three)
{
if(sl==1){//如果只有一個盤子，則直接移動到C柱
System.out.println("盤子"+sl+"
從
"+one+"---->"+three);
}else{//如果總盤數大於1，則遞歸調用移動方法
//把所有的數量為sl-1的盤子全部從A移到到B(C作為一個過渡)，好提供一個最下面的位置給最大盤子到C;
toMove(sl-1,one,three,two);
System.out.println("盤子"+sl+"
從
"+one+"---->"+three);
//把所有的剩餘的盤子從B移動到C(A作為一個過渡)
toMove(sl-1,two,one,three);
}
m++;
}
}

Ⅳ Java編程實現字元串的模式匹配

傳統的字元串模式匹配演算法（也就是BF演算法）就是對於主串和模式串雙雙自左向右，一個一個字元比較，如果不匹配，主串和模式串的位置指針都要回溯。這樣的演算法時間復雜度為O（n＊m），其中n和m分別為串s和串t的長度。

KMP 演算法是由Knuth，Morris和Pratt等人共同提出的，所以成為Knuth－Morris－Pratt演算法，簡稱KMP演算法。KMP演算法是字元串模式匹配中的經典演算法。和BF演算法相比，KMP演算法的不同點是匹配過程中，主串的位置指針不會回溯，這樣的結果使得演算法時間復雜度只為O（n＋m）。

Ⅵ 一個php加密方法，怎麼用java實現，高分！

先找出來是什麼演算法，JAVA 裡面的現成的演算法還是較多的。

看加密的方法，應該是 blowfish 請網路 還是較容易找到的 blowfish JAVA 實現

Ⅶ 求助：用java實現哈夫曼編碼壓縮與解壓縮演算法。

你好，由於內容比較多，先概述一下先。如圖所示，為我寫的一個壓縮軟體，原理是利用哈弗曼演算法實現的。我將資料整理好稍後就發到你郵箱，但在這里簡要說明一下代碼。

請看我的空間

http://hi..com/%D2%B6%BF%C6%C1%BC/blog

中的文章共5篇（太長了）

http://hi..com/%D2%B6%BF%C6%C1%BC/blog/item/93c35517bb528146f2de32fd.html

1.HuffmanTextEncoder類完成壓縮功能，可直接運行，壓縮測試用文本文件。

2.HuffmanTextDecoder類完成解壓縮功能，可直接運行，解壓縮壓縮後的文本文件。

3.BitReader,工具類，實現對BufferedInputStream的按位讀取。

4.BitWriter,工具類，實現按位寫入的功能。該類來自網路。

5.MinHeap<T>,模板工具類，實現了一個最小堆。生成Huffman樹時使用。

Ⅷ 求java教程，最好是視頻，適合零基礎學習的

鏈接:

鏈接: https://pan..com/s/1vixdauVNb42rnRosJxwA4A