问题描述
输入一个正整数n，输出n!的值。
其中n!=1*2*3*…*n。
算法描述
n!可能很大，而计算机能表示的整数范围有限，需要使用高精度计算的方法。使用一个数组A来表示一个大整数a，A[0]表示a的个位，A[1]表示a的十位，依次类推。
将a乘以一个整数k变为将数组A的每一个元素都乘以k，请注意处理相应的进位。
首先将a设为1，然后乘2，乘3，当乘到n时，即得到了n!的值。
输入格式
输入包含一个正整数n，n<=1000。
输出格式
输出n!的准确值。
样例输入
10
样例输出
3628800
测试数据会非常大，将数组设置到一万位
/**
* Copyright (C), 2015-2019
* FileName: Factorial
* Author: zun
* Date: 2019/2/8 9:18
* Description: 高精度阶乘
* History:
* <author> <time> <version> <desc>
* 作者姓名 修改时间 版本号 描述
*/
import java.util.Scanner;
/**
* 〈一句话功能简述〉
* 〈高精度阶乘〉
*
* @author zun
* @create 2019/2/8
* @since 1.0.0
*/
public class Factorial {
public static void main(String[] args) {
int[] result = new int[10000];
result[0] = 1;
for (int i = 1; i < 10000; i++) {
result[i] = 0;
}
Scanner s = new Scanner(System.in);
int n = s.nextInt();
int temp = 1;
int j = 0;
for (int i = 1; i <= n; i++) {
for (int k = 0; k < 10000; k++) {
int r = result[k] * i;
int y = r % 10;
int c = (int) r / 10;
result[k] = (y + j) % 10;
j = c + (int) (y + j) / 10;
}
}
for (int i = 9999; i >= 0; i--) {
if (result[i] != 0) {
for(int t=i;t>=0;t--){
System.out.print(result[t]);
}
break;
}
}
}}
问题描述
输入两个整数a和b，输出这两个整数的和。a和b都不超过100位。
算法描述
由于a和b都比较大，所以不能直接使用语言中的标准数据类型来存储。对于这种问题，一般使用数组来处理。
定义一个数组A，A[0]用于存储a的个位，A[1]用于存储a的十位，依此类推。同样可以用一个数组B来存储b。
计算c = a + b的时候，首先将A[0]与B[0]相加，如果有进位产生，则把进位（即和的十位数）存入r，把和的个位数存入C[0]，即C[0]等于(A[0]+B[0])%10。然后计算A[1]与B[1]相加，这时还应将低位进上来的值r也加起来，即C[1]应该是A[1]、B[1]和r三个数的和．如果又有进位产生，则仍可将新的进位存入到r中，和的个位存到C[1]中。依此类推，即可求出C的所有位。
最后将C输出即可。
输入格式
输入包括两行，第一行为一个非负整数a，第二行为一个非负整数b。两个整数都不超过100位，两数的最高位都不是0。
输出格式
输出一行，表示a + b的值。
样例输入
20100122201001221234567890
2010012220100122
样例输出
20100122203011233454668012
/**
* Copyright (C), 2015-2019
* FileName: Add
* Author: zun
* Date: 2019/2/8 11:26
* Description: 高精度加法
* History:
* <author> <time> <version> <desc>
* 作者姓名 修改时间 版本号 描述
*/
import java.util.Scanner;
/**
* 〈一句话功能简述〉
* 〈高精度加法〉
*
* @author zun
* @create 2019/2/8
* @since 1.0.0
*/
public class Add {
public static void main(String[] args){
Scanner s=new Scanner(System.in);
int[] result=new int[101];
for(int i=0;i<101;i++){
result[i]=0;
}
String a=s.next();
String b=s.next();
char[] a_temp=a.toCharArray();
char[] b_temp=b.toCharArray();
char[] a1=new char[101];
char[] b1=new char[101];
int a_length=a_temp.length-1;
int b_length=b_temp.length-1;
int max=b_length;
for(int i=100;i>=0;i--){
if((100-i)<=a_length){
a1[i]=a_temp[a_length-100+i];
}
else{
a1[i]='0';
}
}
for(int i=100;i>=0;i--) {
if ((100-i)<= b_length) {
b1[i] = b_temp[b_length-100+i];
} else {
b1[i] = '0';
}
}
int j=0;
for(int i=0;i<101;i++){
result[i]=(a1[100-i]+b1[100-i]-96+j)%10;
j=(a1[100-i]+b1[100-i]-96+j)/10;
}
for (int i = 100; i >= 0; i--) {
if (result[i] != 0) {
for(int t=i;t>=0;t--){
System.out.print(result[t]);
}
break;
}
}
}
}
Huffman树在编码中有着广泛的应用。在这里，我们只关心Huffman树的构造过程。
给出一列数{pi}={p0, p1, …, pn-1}，用这列数构造Huffman树的过程如下：
1. 找到{pi}中最小的两个数，设为pa和pb，将pa和pb从{pi}中删除掉，然后将它们的和加入到{pi}中。这个过程的费用记为pa + pb。
2. 重复步骤1，直到{pi}中只剩下一个数。
在上面的操作过程中，把所有的费用相加，就得到了构造Huffman树的总费用。
本题任务：对于给定的一个数列，现在请你求出用该数列构造Huffman树的总费用。
例如，对于数列{pi}={5, 3, 8, 2, 9}，Huffman树的构造过程如下：
1. 找到{5, 3, 8, 2, 9}中最小的两个数，分别是2和3，从{pi}中删除它们并将和5加入，得到{5, 8, 9, 5}，费用为5。
2. 找到{5, 8, 9, 5}中最小的两个数，分别是5和5，从{pi}中删除它们并将和10加入，得到{8, 9, 10}，费用为10。
3. 找到{8, 9, 10}中最小的两个数，分别是8和9，从{pi}中删除它们并将和17加入，得到{10, 17}，费用为17。
4. 找到{10, 17}中最小的两个数，分别是10和17，从{pi}中删除它们并将和27加入，得到{27}，费用为27。
5. 现在，数列中只剩下一个数27，构造过程结束，总费用为5+10+17+27=59。
输入格式
输入的第一行包含一个正整数n（n<=100）。
接下来是n个正整数，表示p0, p1, …, pn-1，每个数不超过1000。
输出格式
输出用这些数构造Huffman树的总费用。
样例输入
5
5 3 8 2 9
样例输出
59
/**
* Copyright (C), 2015-2019
* FileName: Huffman
* Author: zun
* Date: 2019/2/10 10:19
* Description: 哈夫曼树
* History:
* <author> <time> <version> <desc>
* 作者姓名 修改时间 版本号 描述
*/
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Scanner;
/**
* 〈一句话功能简述〉
* 〈哈夫曼树〉
*
* @author zun
* @create 2019/2/10
* @since 1.0.0
*/
public class Huffman {
public int mini(ArrayList nums) {
int mini = 999999;
for (Object num : nums) {
int n = (int) num;
if (n < mini) {
mini = n;
}
}
return mini;
}
public static void main(String[] args){
Scanner s=new Scanner(System.in);
int n=s.nextInt();
s.nextLine();
ArrayList nums=new ArrayList();
for(int i=0;i<n;i++){
int t=s.nextInt();
nums.add(t);
}
int sum=0;
Huffman huffman=new Huffman();
while(nums.size()!=1){
// System.out.println(nums.size());
int mini=huffman.mini(nums);
nums.remove((Object)mini);
//System.out.println(nums.size());
// System.out.println(mini+"mini");
int mini1=huffman.mini(nums);
nums.remove((Object)mini1);
//System.out.println(mini1+"mini1");
nums.add(mini+mini1);
sum=sum+mini+mini1;
}
System.out.print(sum);
}
}
动态数组remove方法，数组中村的内容为整数时，直接remove（3），会导致删除下标为3的内容，应该转换为object删除该整数对象
给定一个n*n的棋盘，棋盘中有一些位置不能放皇后。现在要向棋盘中放入n个黑皇后和n个白皇后，使任意的两个黑皇后都不在同一行、同一列或同一条对角线上，任意的两个白皇后都不在同一行、同一列或同一条对角线上。问总共有多少种放法？n小于等于8。
输入格式
输入的第一行为一个整数n，表示棋盘的大小。
接下来n行，每行n个0或1的整数，如果一个整数为1，表示对应的位置可以放皇后，如果一个整数为0，表示对应的位置不可以放皇后。
输出格式
输出一个整数，表示总共有多少种放法。
样例输入
4
1 1 1 1
1 1 1 1
1 1 1 1
1 1 1 1
样例输出
2
样例输入
4
1 0 1 1
1 1 1 1
1 1 1 1
1 1 1 1
样例输出
0
/**
* Copyright (C), 2015-2019
* FileName: Queen
* Author: zun
* Date: 2019/2/10 20:32
* Description:
* History:
* <author> <time> <version> <desc>
* 作者姓名 修改时间 版本号 描述
*/
/**
* 〈一句话功能简述〉
* 〈〉
*
* @author zun
* @create 2019/2/10
* @since 1.0.0
*/
import java.util.Scanner;
public class Queen{
private static int cnt = 0;//共有多少种方法
private static int[] posWhite;
private static int[] posBlack;
private static int[][] grid;
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
grid = new int[n][n];//棋盘
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
grid[i][j] = in.nextInt();
}
}
in.close();//读取棋盘
posBlack = new int[n];
posWhite = new int[n];
dfsWhite(0, n);//深度遍历白皇后
System.out.println(cnt);
}
/**
* 判断是否在同一行，同一列
* @param row
* @param pos
* @return
*/
private static boolean isNoAdjcent(int row, int[] pos) {
for (int i = 0; i < row; i++) {
if (pos[i] == pos[row] || row - i == Math.abs(pos[row] - pos[i])) {
return false;
}
}
return true;
}
private static boolean isNotEqual(int row) {
if (posWhite[row] == posBlack[row]) {
return false;
}
return true;
}
private static void dfsBlack(int row, int n) {
if (row >= n) {
cnt++;
return;
}
for (posBlack[row] = 0; posBlack[row] < n; posBlack[row]++) {
if (grid[row][posBlack[row]] == 1 && isNoAdjcent(row, posBlack) && isNotEqual(row)) {
dfsBlack(row + 1, n);
}
}
}
private static void dfsWhite(int row, int n) {
if (row >= n) {
dfsBlack(0, n);
return;
}
for (posWhite[row] = 0; posWhite[row] < n; posWhite[row]++) {
if (grid[row][posWhite[row]] == 1 && isNoAdjcent(row, posWhite)) {
dfsWhite(row + 1, n);
}
}
}
}
（参考githubhttps://github.com/hdvsyu/LanqiaoOJ/tree/master/BASIC/basic27）
不太懂，再看看
