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

本文介绍了Huffman树的构造过程及其应用,并通过实例详细解释了如何计算构造Huffman树的总费用。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

基础练习 Huffuman树  
时间限制:1.0s   内存限制:512.0MB
      
问题描述
  Huffman树在编码中有着广泛的应用。在这里,我们只关心Huffman树的构造过程。
  给出一列数{pi}={p0p1, …, pn-1},用这列数构造Huffman树的过程如下:
  1. 找到{pi}中最小的两个数,设为papb,将papb从{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。
输入格式
  输入的第一行包含一个正整数nn<=100)。
  接下来是n个正整数,表示p0p1, …, 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来表示一个大整数aA[0]表示a的个位,A[1]表示a的十位,依次类推。
  将a乘以一个整数k变为将数组A的每一个元素都乘以k,请注意处理相应的进位。
  首先将a设为1,然后乘2,乘3,当乘到n时,即得到了n!的值。
输入格式
  输入包含一个正整数nn<=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
      
问题描述
  输入两个整数ab,输出这两个整数的和。ab都不超过100位。
算法描述
  由于ab都比较大,所以不能直接使用语言中的标准数据类型来存储。对于这种问题,一般使用数组来处理。
  定义一个数组AA[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。
输出格式
  输出一行,表示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]);
		}
	}
}


评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值