蓝桥杯：基础练习 Huffuman树、FJ的字符串、阶乘计算、高精度加法

基础练习 Huffuman树  

时间限制：1.0s   内存限制：512.0MB

       

问题描述

　　Huffman树在编码中有着广泛的应用。在这里，我们只关心Huffman树的构造过程。
　　给出一列数{ pi}={ p 0,  p 1, …,  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个正整数，表示 p 0,  p 1, …,  pn -1，每个数不超过1000。

输出格式

　　输出用这些数构造Huffman树的总费用。

样例输入

5
5 3 8 2 9

样例输出

59

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main{

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n, i, smallNumberA, smallNumberB, length;
		int count = 0;
		//int countB = 0;
		int sum = 0;
		n = sc.nextInt();
		List<Integer> array = new ArrayList<Integer>();
		for (i = 0; i < n; i++) {
			array.add(sc.nextInt());
		}
		length = array.size();
		while (length > 1) {
			smallNumberA = array.get(0);
			count = 0;
			for (i = 0; i < length; i++) {
				if (array.get(i) < smallNumberA) {
					smallNumberA = array.get(i);
					count = i;
				}
			}
			array.remove(count);
			length = array.size();
			smallNumberB = array.get(0);
			count = 0;
			for (i = 0; i < length; i++) {
				if (array.get(i) < smallNumberB) {
					smallNumberB = array.get(i);
					count = i;
				}
			}
			array.remove(count);
			array.add(smallNumberA + smallNumberB);
			sum = sum + smallNumberA + smallNumberB;
			length = array.size();
		}
		System.out.println(sum);
	}
}

基础练习 FJ的字符串  

时间限制：1.0s   内存限制：512.0MB

       

问题描述

　　FJ在沙盘上写了这样一些字符串：
　　A1 = “A”
　　A2 = “ABA”
　　A3 = “ABACABA”
　　A4 = “ABACABADABACABA”
　　… …
　　你能找出其中的规律并写所有的数列AN吗？

输入格式

　　仅有一个数：N ≤ 26。

输出格式

　　请输出相应的字符串AN，以一个换行符结束。输出中不得含有多余的空格或换行、回车符。

样例输入

3

样例输出

ABACABA

import java.util.Scanner;

public class Main{

	private char c = 'A';
	private int j = 0;
	private StringBuilder sb = new StringBuilder();
	private String s = "";
	private String FJString(int i, int n) {

		if (i <= n) {
			if (i <= 1) {
				s = "A";
				sb.append(s);
				i++;
			} else {
				sb.append((char)(c + j));
				sb.append(s);
				s = sb.toString();
				i++;
			}
			j++;
			return FJString(i, n);
		} else {
			return s;
		}
	}

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int i = 1;
		String st = new Main().FJString(i, n);
		System.out.println(st);
	}

}

基础练习 阶乘计算  

时间限制：1.0s   内存限制：512.0MB

       

问题描述

　　输入一个正整数 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

import java.util.Scanner;

public class Main{

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int number = sc.nextInt();
		int[] array = new int[10000];
		array[0] = 1;
		int i, j;
		int count = 1;
		for (i = 1; i <= number; i++) {
			for (j = 0; j < array.length; j++) {
				array[j] = array[j] * i;
			}
			for (j = 0; j < array.length; j++) {
				if (array[j] > 9) {
					array[j + 1] = array[j + 1] + array[j] / 10;
					array[j] = array[j] % 10;
				}
				if (array[j] > 0) {
					count = j + 1;
				}
			}
		}
		for (i = count - 1; i >= 0; i--) {
			System.out.print(array[i]);
		}
	}
}

基础练习 高精度加法  

时间限制：1.0s   内存限制：512.0MB

       

问题描述

　　输入两个整数 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

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main{

	public static void main(String[] args) {
		String sa = "";
		String sb = "";
		int i, j, count;
		int[] a = new int[1000];
		int[] b = new int[1000];
		Scanner sc = new Scanner(System.in);
		sa = sc.nextLine();
		sb = sc.nextLine();
		int saLength = sa.length();
		int sbLength = sb.length();
		for (i = saLength - 1; i >= 0; i--) {
			a[saLength - 1 - i] = Integer.parseInt(sa.substring(i, i + 1));
		}
		for (i = sbLength - 1; i >= 0; i--) {
			b[sbLength - 1 - i] = Integer.parseInt(sb.substring(i, i + 1));
		}
		if (saLength > sbLength) {
			count = saLength;
		} else {
			count = sbLength;
		}
		for (i = 0; i < count; i++) {
			a[i] = a[i] + b[i];
		}
		for (i = 0; i < count; i++) {
			if (a[i] > 9) {
				a[i + 1] = a[i + 1] + a[i] / 10;
				a[i] = a[i] % 10;
			}
		}
		if (a[count] != 0) {
			count = count + 1;
		}
		for (i = count -1; i >= 0; i--) {
			System.out.print(a[i]);
		}
	}
}