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