1.下载jar包
2.将mail.jar 和 activation.jar两个jar包导入项目
3.发送邮件代码如下
|
|
4.需要导入的包
|
|
FuckTheCode
Code is lovely
JavaWeb项目配置Hibernate
2.将lib目录下的所有jar包拷贝到WEB-INF的lib目录下
3.新建一个测试实体
|
|
4.在src文件夹下新建hibernate.cfg.xml，并添加如下代码
|
|
注意修改连数据库的url（ip地址和域名均可）和数据库名，以及用户名和密码
Tomcat使用JKS格式证书配置HTTPS
1.上传jks证书
2.在conf目录下的server.xml添加如下代码
|
|
注意修改文件名和密码
如何将本地项目上传到GitHub
- 注册GitHub 新建仓库
- 下载安装Git工具
- 右键项目，选择菜单Git Bash Here
- 执行下面代码
git init
git add .
git commit -m ‘first_commit’
#链接是你自己的项目的https链接
git remote add origin https://github.com/zhazhapan/PracticalToolBox.git
git push origin master - 可能遇到的错误
- fatal: remote origin already exists
执行：
git remote rm origin
然后再执行：git remote add origin https://github.com/zhazhapan/PracticalToolBox.git
- error:failed to push some refs to…….
执行：
git pull origin master
然后再执行：git push origin master
- fatal: refusing to merge unrelated histories
执行：
git pull origin master –allow-unrelated-histories
然后再执行：git push origin master
- fatal: remote origin already exists
动态规划法求解矩阵中最长的递增路径的长度
给定一个整数矩阵,找到增加最长路径的长度。
从每一个单元格,你可以移到四个方向:左,右,向上或向下。你不能移到对角线移动或移动以外的边界(即缠绕是不允许的)。
Example 1:
nums = [ [9,9,4], [6,6,8], [2,1,1] ]Return
4
The longest increasing path is [1, 2, 6, 9].
Example 2:
nums = [ [3,4,5], [3,2,6], [2,2,1] ]Return
4
The longest increasing path is [3, 4, 5, 6]. Moving diagonally is not allowed.
Here is my code
/**
*
*/
package com.zhazhapan.algorithm.dynamicprogramming;
import java.util.Arrays;
/**
* @author pantao
* @date 2017-04-04
*
*/
public class PathProblem {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int[][] test={{1,6,12,1,3},{8,4,6,10,5},{12,11,7,12,2},{2,3,4,1,13},{14,6,0,14,13}};
System.out.println(longestIncreasingPath(test));
}
static int[][] Lens;
public static int longestIncreasingPath(int[][] matrix) {
if (matrix.length == 0) {
return 0;
}
Lens = new int[matrix.length][matrix[0].length];
int pathLen = 0;
for (int i = 0; i < Lens.length; i++) {
for (int j = 0; j < Lens[i].length; j++) {
Lens[i][j] = -1;
}
}
for (int i = 0; i < matrix.length; i++) {
for (int j = 0; j < matrix[i].length; j++) {
pathLen = Math.max(pathLen, requestPathLength(matrix, i, j));
}
}
return pathLen + 1;
}
public static int requestPathLengths(int[][] matrix, int i, int j) {
if (Lens[i][j] != -1) {
return Lens[i][j];
}
int a = 0;
if (i - 1 > -1 && matrix[i][j] < matrix[i - 1][j]) {
a = 1 + requestPathLength(matrix, i - 1, j);
}
int b = 0;
if (i + 1 < matrix.length && matrix[i][j] < matrix[i + 1][j]) {
b = 1 + requestPathLength(matrix, i + 1, j);
}
int c = 0;
if (j - 1 > -1 && matrix[i][j] < matrix[i][j - 1]) {
c = 1 + requestPathLength(matrix, i, j - 1);
}
int d = 0;
if (j + 1 < matrix[0].length && matrix[i][j] < matrix[i][j + 1]) {
d = 1 + requestPathLength(matrix, i, j + 1);
}
Lens[i][j] = Math.max(Math.max(a, b), Math.max(c, d));
return Lens[i][j];
}
}
回溯算法求解数独
写一个程序，解决数独求解的问题
空的格子用字符 ‘.’代替。
你可以假设只有一个解
一个数独 …
…红色的数字就是解.
下面是我的代码
/**
*
*/
package com.zhazhapan.algorithm.backtracking;
/**
* @author pantao
* @date 2017-04-06
*
*/
public class SudokuSolve {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
String[] string = { "..9748...", "7........", ".2.1.9...", "..7...24.", ".64.1.59.", ".98...3..", "...8.3.2.",
"........6", "...2759.." };
char[][] board = new char[9][9];
// 初始化数独
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
board[i][j] = string[i].charAt(j);
}
}
new SudokuSolve().solveSudoku(board);
}
public void solveSudoku(char[][] board) {
if (board == null || board.length != 9 || board[0].length != 9) {
return;
}
if (solve(board, 0, 0)) {
// 打印结果
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
System.out.print(board[i][j] + " ");
}
System.out.println();
}
}
}
public boolean solve(char[][] board, int i, int j) {
if (j == 9) {
if (i == 8)
return true;
i++;
j = 0;
}
if (board[i][j] != '.') {
return solve(board, i, j + 1);
}
for (char k = '1'; k <= '9'; k++) {
if (isValid(board, i, j, k)) {
board[i][j] = k;
if (solve(board, i, j + 1))
return true;
else
board[i][j] = '.';
}
}
return false;
}
public boolean isValid(char[][] board, int i, int j, char c) {
for (int k = 0; k < 9; k++) {
if (board[i][k] != '.' && board[i][k] == c)
return false;
if (board[k][j] != '.' && board[k][j] == c)
return false;
if (board[i / 3 * 3 + k / 3][j / 3 * 3 + k % 3] != '.'
&& board[i / 3 * 3 + k / 3][j / 3 * 3 + k % 3] == c)
return false;
}
return true;
}
}
单词变换
题目描述：
有一个单词列表，一个初始单词和一个最终单词，初始单词需要通过单词列表逐步变换到最终单词，求变换所需的最短变换路径长度。
变换规则：每次只能变动1个字母（不可交换位置，如：从abc变成cba属于变动了2个字母），每次变换只能从单词列表中选取。
例如：初始单词hot，最终单词dog，单词列表[got, dot, god, dog, lot, log]，最短变换路径为[hot,dot,dog]，最短变换路径长度为3。
注：单词列表中包含最终单词，不包含初始单词；列表中每一项单词长度与初始单词、最终单词相同；列表中单词不重复；所有字母均为小写。
输入
输入数据有三行，第一行为初始单词；第二行为最终单词；第三行为单词列表，单词和单词之间以空格分割。
输出
最短变换路径长度。
样例输入
hot
dog
got dot god dog lot log
样例输出
3
提示
寻找最短路径相关算法。
下面是我的答案（写得不好的地方请指正哦），如果你有最好的解决方案，请在下面评论，大家一起交流学习！
import java.util.ArrayList;
import java.util.Scanner;
public class TestAgain {
static int[][] matrix;// 邻接矩阵
static int len;// 单词个数
static ArrayList<Integer> path;// 单条路径记录
static ArrayList<ArrayList<Integer>> paths;// 所有路径
public static void main(String[] args) {
// 接收输入参数
Scanner scanner = new Scanner(System.in);
String init = scanner.nextLine();
String end = scanner.nextLine();
String list = scanner.nextLine();
scanner.close();
// 将所有单词存入数组
len = list.split(" ").length + 1;
String[] vocabulary = new String[len];
vocabulary[0] = init;
int start = 0; // 最终词所在的索引
for (int i = 1; i < len; i++) {
vocabulary[i] = list.split(" ")[i - 1];
if (vocabulary[i].equals(end)) {
start = i;
}
}
// 构建邻接矩阵
matrix = nearMatrix(vocabulary);
path = new ArrayList<Integer>();
paths = new ArrayList<ArrayList<Integer>>();
// 开始搜索
look(start);
// 寻找最短路径
int min = Integer.MAX_VALUE;
for (int i = 0; i < paths.size(); i++) {
int k = paths.get(i).size();
if (k < min && paths.get(i).get(k - 1) == 0) {
min = k;
}
}
System.out.println(min + 1);
}
public static void look(int start) {
for (int i = 0; i < len; i++) {
if (matrix[start][i] == 1 && !path.contains(i)) {
path.add(i);
if (i != 0) {
look(i);
} else {
break;
}
}
}
// 添加路径
paths.add(path);
path = new ArrayList<Integer>();
int length = paths.get(paths.size() - 1).size();
for (int i = 0; i < length - 1; i++) {
path.add(paths.get(paths.size() - 1).get(i));
}
}
// 构建邻接矩阵
public static int[][] nearMatrix(String[] vac) {
int[][] matrix = new int[vac.length][vac.length];
for (int i = 0; i < vac.length; i++) {
for (int j = 0; j < vac.length; j++) {
matrix[i][j] = compare(vac[i], vac[j]);
}
}
return matrix;
}
// 比较两个单词是否可变换
public static int compare(String s1, String s2) {
int k = 0;
for (int i = 0; i < s1.length(); i++) {
if ((s1.charAt(i) + "").compareTo((s2.charAt(i) + "")) != 0) {
k++;
if (k > 1) {
return Integer.MAX_VALUE;
}
}
}
return k;
}
}
i++
例题1：下列程序的输出结果是多少？
public class Test {
static {
int x = 5;
}
static int x, y;
public static void main(String[] args) {
x--;
myMethod();
System.out.println(x + y++ + x);
}
public static void myMethod() {
y = x++ + ++x;
}
}
解析
public class Test {
static {
int x = 5;//在第一次被载入JVM时运行，但由于是局部变量，x = 5不影响后面的值
}
static int x, y;//初始化 x = 0; y = 0
public static void main(String[] args) {
x--;//x = -1
myMethod();
System.out.println(x + y++ + x);//1 + 0 + 1 = 2;
}
public static void myMethod() {
y = x++ + ++x;//y = -1 + 1;
}
}
//输出结果为2
例题2：下列程序的输出结果是多少？
import java.util.*;
public class Test {
public static void main(String[] args) {
int j = 0;
for (int i = 0; i < 100; i++) {
j = j++;
}
System.out.println(j);
}
}
解析：因为Java用了中间缓存变量的机制，所以j=j++可换成如下写法：
temp = j;
j = j + 1;
j = temp;
//所有输出结果为0
例题3：下列代码的执行结果是多少？
import java.util.*;
public class Test {
public static void main(String[] args) {
int i = 0;
i = i++ + ++i;
int j = 0;
j = ++j + j++ + j++ + j++;
int k = 0;
k = k++ + k++ + k++ + ++k;
int h = 0;
h = ++h + ++h;
int p1 = 0, p2 = 0, q1 = 0, q2 = 0;
q1 = ++p1;
q2 = p2++;
System.out.println("i " + i);
System.out.println("j " + j);
System.out.println("k " + k);
System.out.println("h " + h);
System.out.println("p1 " + p1);
System.out.println("p2 " + p2);
System.out.println("q1 " + q1);
System.out.println("q2 " + q2);
}
}
//输出结果：i = 2, j = 7, k = 7, h = 3, p1 = 1, p2 = 1, q1 = 1, q2 = 0
进制转换
进制转换
时间限制：C/C++语言 2000MS；其他语言 4000MS
内存限制：C/C++语言 65536KB；其他语言 589824KB
题目描述：
用英文字母a-z来分别表示数值0-25, 形成一个26进制的数值表示法。需要你写一个方法，将用a-z表示的26进制数值的字符串，转化为对应的10进制数值。
输入
输入数据有多组，每组占一行，包含多个a-z之间的字符。
输出
所对应表示的10进制数。
样例输入
ba
bcd
gibbon
goodboy
样例输出
26
731
74962693
2026285376
下面是我的答案，如果你有更好的解决方案，请下面评论哦，大家一起学习交流！
import java.util.ArrayList;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
ArrayList value = new ArrayList();
while(scanner.hasNext()) {
String ss = scanner.nextLine();
if(ss.length() < 1) {
break;
}
value.add(ss);
}
for (String string : value) {
System.out.println(solution(string));
}
}
public static long solution(String s){
long result = 0;
int len = s.length();
for(int i = 0; i < len; i++){
result += (s.charAt(i) - 'a') * Math.pow(26, len - i - 1);
}
return result;
}
}
水仙花数
水仙花数
（编程题须知） （参考答案）
时间限制：C/C++语言 2000MS；其他语言 4000MS
内存限制：C/C++语言 32768KB；其他语言 557056KB
题目描述：
春天是鲜花的季节，水仙花就是其中最迷人的代表，数学上有个水仙花数，他是这样定义的：
“水仙花数”是指一个三位数，它的各位数字的立方和等于其本身，比如：153=1^3+5^3+3^3。
现在要求输出所有在m和n范围内的水仙花数。
输入
输入数据有多组，每组占一行，包括两个整数m和n（100<=m<=n<=999）。
输出
对于每个测试实例，要求输出所有在给定范围内的水仙花数，就是说，输出的水仙花数必须大于等于m,并且小于等于n，如果有多个，则要求从小到大排列在一行内输出，之间用一个空格隔开;
如果给定的范围内不存在水仙花数，则输出no;
每个测试实例的输出占一行。
样例输入
100 120
300 380
样例输出
no
370 371
下面是我的答案，如果你有更好的解决方案，请在下面评论哦，大家一起交流学习！
import java.util.ArrayList;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
ArrayList value = new ArrayList();
while (scanner.hasNext()) {
String string = scanner.nextLine();
// exit
if (string == "q" || !string.contains(" ")) {
break;
}
value.add(string);
}
for (String s : value) {
System.out.println(solution(Integer.parseInt(s.split(" ")[0]), Integer.parseInt(s.split(" ")[1])));
}
}
public static String solution(int m, int n) {
String result = "";
if (m > 99 && n < 1000) {
while (m <= n) {
if (m == Math.pow(m / 100, 3) + Math.pow(m % 100 / 10, 3) + Math.pow(m % 10, 3)) {
result += m + " ";
}
m++;
}
}
return result == "" ? "no" : result;
}
}
缺失模块。
1、请确保node版本大于6.2
2、在博客根目录（注意不是yilia根目录）执行以下命令：
npm i hexo-generator-json-content --save
3、在根目录_config.yml里添加配置：
jsonContent:
meta: false
pages: false
posts:
title: true
date: true
path: true
text: false
raw: false
content: false
slug: false
updated: false
comments: false
link: false
permalink: false
excerpt: false
categories: false
tags: true
热爱编程，<br/>崇尚开源，<br/>喜欢折腾，<br/>Linux爱好者，<br/>追求编写极致优雅的代码。