一、对昨天的补充TreeMap
TreeMap 是一个有序的key-value集合，它是通过红黑树实现的。
TreeMap 继承于AbstractMap，所以它是一个Map，即一个key-value集合。
TreeMap 实现了NavigableMap接口，意味着它支持一系列的导航方法。比如返回有序的key集合。
TreeMap 实现了java.io.Serializable接口，意味着它支持序列化。该映射根据其键的自然顺序进行排序。
遍历TreeMap的键值对：
第一步：根据entrySet()获取TreeMap的“键值对”的Set集合。
第二步：通过Iterator迭代器遍历“第一步”得到的集合。
package sfxl;
import java.util.Iterator;
import java.util.Map;
import java.util.TreeMap;
public class t194_test {
public static void main(String[] args) {
// System.out.println(1<<3);
// System.out.println(3<<1);
TreeMap<Integer,Integer> tm=new TreeMap<Integer,Integer>();
tm.put(1, 2);
tm.put(4,0);
tm.put(2, 1);
tm.put(3, 7);
Integer integ = null;
Iterator iter = tm.entrySet().iterator();
int key;
while(iter.hasNext()) {
Map.Entry entry = (Map.Entry)iter.next();
// 获取key
key = (Integer) entry.getKey();
// 获取value
integ = (Integer)entry.getValue();
System.out.println(key+","+integ);
}
}
}
最终的输出结果是
1,2
2,1
3,7
4,0
二、字符串匹配（KMP）
子串cbcba的next数组是-1 0 0 1 2
next[ i ]代表本位置 i 之前有几位“回文”，在子串与串不匹配的时候，进行回溯多少位
子串cbcba与串acbcbcba从下标为3的地方开始匹配
package sfxl;
public class KMP_test {
public static void main(String[] args) {
String s="acbcbcba";
String z="cbcba";
System.out.println(pp(s,z));
}
/**
* 获取next[]，这是KMP的关键
* */
public static void getNext(String s,int []next){
int k=-1;
int j=0;
next[0]=-1;
while(j<s.length()-1){
if(k==-1||s.charAt(k)==s.charAt(j)){
k++;
j++;
next[j]=k;
}else{
k=next[k];
}
}
for(int i=0;i<next.length;i++){
System.out.print(next[i]+" ");
}
System.out.println();
}
/**
* 开始字符串匹配
* */
public static int pp(String s,String z){
int i=0;
int j=0;
int next[]=new int[z.length()];
getNext(z, next);
while(i<s.length()&&j<z.length()){
if(s.charAt(i)==z.charAt(j)){
i++;
j++;
}else{
if (next[j] == -1) {
i++;
j = 0;
} else {
j = next[j];
}
}
if(j==z.length()){
return i-j;
}
}
return -1;
}
}
三、字典树（Trie）
字典树把单词的公共部分给拎出来，这样一层一层往上拎直到得到每个节点都是不可分的最小单元。字典树是一种非常快的单词查询结构。
致敬前辈
解释：根Node有本身的属性如repeat_num，pre_num，leaf，同时也包含子节点，Node child[]，意味着子节点也是Node。例如插入a，就相当于child[0]这个Node存在。不插入b，child[1]就不存在，即root.child[1]==null。如果插入abf，就为root创建child[0]，再将child[0]作为root，为root创建child[1]，再将child[1]作为root，为root创建child[5]。
下面代码实现插入、查找、遍历、单词联想（找公共前缀）等基本功能。
1.构建树
package sfxl;
import java.util.HashMap;
public class test_trie_tree {
//定义节点结构
class Node{
int repeat_num;//该字串的重复数目
int pre_num;//以该字串为前缀的字串数
Node child[];//孩子节点
boolean leaf;//是否结束
public Node(){
repeat_num=0;
pre_num=0;
child=new Node[26];
leaf=false;
}
}
Node root;//定义树根
public test_trie_tree(){
root=new Node();
}
/**
* 插入串
* */
public void insert(String word){
this.insert(root, word);
}
public void insert(Node root,String word){
char[]w=word.toLowerCase().toCharArray();//转为小写字符数组
//开始对根添加树枝
for(int i=0;i<w.length;i++){
int index=w[i]-'a';
if(root.child[index]!=null){
root.child[index].pre_num++;
}else{
root.child[index]=new Node();
root.child[index].pre_num++;
}
if(i==w.length-1){//本字串到了结束，就做个标记，chi在这里做标记。但是对于构造china也会经过这个树枝，但是不会停止。
root.child[index].leaf=true;
root.child[index].repeat_num++;
}
root=root.child[index];//这一步最关键！！！
}
}
/**
* 遍历树，开始查询所有
* @return
* */
public HashMap<String, Integer> getAll(){
return getAllK(root, "");
}
/**
* 以空为前缀，查询所有树叶的路径，及树叶出现的次数
* @return
* */
public HashMap<String, Integer> getAllK(Node root,String pre){
HashMap<String, Integer> map=new HashMap<String, Integer>();
if(root!=null){
if(root.leaf==true){
map.put(pre, root.repeat_num);
}
for(int i=0;i<root.child.length;i++){
if(root.child[i]!=null){
char ch=(char) (i+'a');
String p=pre+ch;
map.putAll(getAllK(root.child[i], p));
}
}
}
return map;
}
/**
* 查询指定前缀的字符串
* @return
* */
public HashMap<String, Integer> getPre(String word){
return getPre(root, word);
}
public HashMap<String, Integer> getPre(Node root,String word){
char []cc=word.toLowerCase().toCharArray();
if(root!=null){
for(int i=0;i<cc.length;i++){
if(root.child[cc[i]-'a']!=null){
root=root.child[cc[i]-'a'];
}else{
return null;
}
}
return getAllK(root, word);
}
return null;
}
/**
* 查询是否包含某个字符串
* */
public boolean exist(String word){
return exist(root, word);
}
public boolean exist(Node root,String word){
char[]ws=word.toLowerCase().toCharArray();
for(int i=0;i<ws.length;i++){
if(root.child[ws[i]-'a']!=null){
root=root.child[ws[i]-'a'];
}else{
return false;
}
if(i==ws.length-1){
if(root.leaf==true){
return true;
}else{
return false;
}
}
}
return false;
}
}
2.对树进行操作测试
package sfxl;
import java.util.HashMap;
public class test_trie_query {
public static void main(String[] args) {
test_trie_tree t3=new test_trie_tree();
t3.insert("i");
t3.insert("am");
t3.insert("am");
t3.insert("amy");
t3.insert("fine");
HashMap<String, Integer> hm=new HashMap<String, Integer>();
//查询所有字符串和出现的次数
// hm=t3.getAll();
// for(String s:hm.keySet()){
// System.out.println(s+","+hm.get(s));
// }
//
//查询指定前缀的字符串
// hm=t3.getPre("am");
// for(String s:hm.keySet()){
// System.out.println(s+","+hm.get(s));
// }
//查询是否包含某个字符串
System.out.print(t3.exist("am"));
}
}
四、素因子去重（运行时错误）
十分气恼的一道题…题意要求是乘法，我用了加法，40分，后来发现错误，改成加法，20分…我选择放弃这个…
算法训练 素因子去重
时间限制：1.0s 内存限制：256.0MB
问题描述
给定一个正整数n，求一个正整数p，满足p仅包含n的所有素因子，且每个素因子的次数不大于1
输入格式
一个整数，表示n
输出格式
输出一行，包含一个整数p。
样例输入
1000
样例输出
10
数据规模和约定
n<=10^12
样例解释：n=1000=2^353，p=2*5=10
package sfxl;
import java.util.Scanner;
import java.util.Vector;
public class p190 {
public static void main(String[] args) {
int []num=su();
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
if(n==1){
System.out.println(1);
}else if(zh(n)){
System.out.println(n);
}else{
System.out.println(fj(num, n));
}
}
/**
* 对用户输入的n进行分解
* */
public static long fj(int[] num,int n){
int []res=new int[10];
int r=0;//r始终指向本个
for(int i=1;;){
if(n%num[i]==0){
if(r==0){
res[r]=num[i];
// System.out.println(res[r]+" "+r);
r++;
}else if(num[i]!=res[r-1]){
res[r]=num[i];
r++;
// System.out.println(res[r-1]+",,,"+(r-1));
}
n=n/num[i];
// System.out.println(n+"**");
i=1;
if(n==1){
break;
}
}else{
i++;
}
// System.out.println(i);
}
// System.out.println();
long sum=1;
for(int i=0;i<10;i++){
if(res[i]!=0){
sum*=res[i];
}
// System.out.print(res[i]+" ");
}
return sum;
}
/**
* 判断是不是质数
* */
public static boolean zh(int n){
for(int i=2;i<n/2;i++){
if(n%i==0){
return false;
}
}
return true;
}
/**
* 查找100以内的素数
* */
public static int[] su(){
int []s=new int[100];
for(int i=0;i<100;i++){
s[i]=i+1;
}
int i=1;
while(i<100){
if(s[i]!=0){
for(int j=i+1;j<100;j++){
if(s[j]!=0){
if(s[j]%s[i]==0){
s[j]=0;
}
}
}
}
i++;
}
Vector<Integer> vi=new Vector<Integer>();
for(int ii=0;ii<100;ii++){
if(s[ii]!=0){
vi.add(s[ii]);
}
}
int res[]=new int[vi.size()];
for(int t=0;t<vi.size();t++){
res[t]=vi.get(t);
}
return res;
}
}
五、P0505
妈耶…这个题真简单…开心！！！！
一个整数n的阶乘可以写成n!，它表示从1到n这n个整数的乘积。阶乘的增长速度非常快，例如，13！就已经比较大了，已经无法存放在一个整型变量中；而35！就更大了，它已经无法存放在一个浮点型变量中。因此，当n比较大时，去计算n!是非常困难的。幸运的是，在本题中，我们的任务不是去计算n!，而是去计算n!最右边的那个非0的数字是多少。例如，5！=12345=120，因此5!最右边的那个非0的数字是2。再如，7！=5040，因此7！最右边的那个非0的数字是4。再如，15！= 1307674368000，因此15！最右边的那个非0的数字是8。请编写一个程序，输入一个整数n(0<n<=100)，然后输出n!最右边的那个非0的数字是多少。
输入：
7
输出：
4
import java.util.Scanner;
/**
* 获得最后四位
* */
public class p189 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
// System.out.println(jc_4(n));
long res=jc_4(n);
// System.out.println(res);
while(res%10==0){
res/=10;
}
System.out.println(String.valueOf(res).toCharArray()[String.valueOf(res).length()-1]);
}
public static long jc_4(int n){
long t=1;
for(long i=2;i<=n;i++){
t=(t*i)%1000000000;
if(t%1000==0){
t=t/1000;
}
}
return t;
}
}
六，三个数的最小公倍数
原来还能这样计算…nb
package lijie_1;
import java.io.ObjectInputStream.GetField;
import java.util.Scanner;
/**
* 本质：求最小公倍数
*
* 先求最大公约数
* 辗转相除法
* */
public class t1 {
public static void main(String[] args) {
// System.out.println(max_gy(12, 8));
Scanner sc=new Scanner(System.in);
int a=sc.nextInt();
int b=sc.nextInt();
int c=sc.nextInt();
System.out.println(lcm(lcm(a, b), c));
}
/**
* 最小公倍数
* */
public static int lcm(int m,int n){
return m*n/max_gy(n, m);
}
/**
* 求解最大公因数，
* */
public static int max_gy(int n,int m){
if(n<m){
int t=n;
n=m;
m=t;
}
if(n==m){
return m;
}else{
int r = n % m;
while (r != 0) {
n = m;
m = r;
r = n % m;
}
return m;
}
}
}
扫一扫
2261
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
