洛谷P1480（C语言，高精度除以低精度、高精度除以高精度）

本题要求是高精度除以低精度，但是我也写了高精度除以高精度的题解，主要是想讲解一下两种算法的解法，本篇文章写完，高精度算法系列就结束啦

A/B Problem

题目描述

输入两个整数 $a,b$，输出它们的商。

输入格式

两行，第一行是被除数，第二行是除数。

输出格式

一行，商的整数部分。

样例 #1

样例输入 #1

10
2

样例输出 #1

5

提示

$0\le a\le 10^{5000}$，$1\le b\le 10^9$。

分析

高精度除以高精度算法花了我比较长的时间，我这里打字讲解可能不够清晰，我会配图一步一步分析的

高精度除低精度

点击查看其他高精度算法

1. 不管是哪种高精度算法，我们都是用数组存储要输入的操作数，这里我不在赘述，相信大家学了其他高精度算法看到这里都明白了，我也不在赘述其他步骤，就讲一下注意事项和思路吧；
2. 还记得我们小时候（当然我现在也这样算）怎么算除法吗？列竖式，逐位试商，这里也是差不多的思路，只不过用的是数组模拟；
3. 核心代码如下：

	//核心代码
	long long yuShu = 0;//这里注意是long long类型的
	for (int i = 0; i < lena; i++) {
		yuShu = yuShu*10 + a[i];
		c[i] = yuShu / n;
		yuShu = yuShu % n;
	}

4. 图解
   
5. 具体的我也不知道该怎么打字描述，希望我的图可以看懂。

高精度除以低精度代码

#include <stdio.h>
#include <string.h>

int main () {
	char s[5010];
	int a[5010], c[5010], n;
	scanf("%s", s);
	scanf("%d", &n);
	int lena = strlen(s);
	
	//将 char 转为 int
	for (int i = 0; i < lena; i++) 
		a[i] = s[i] - '0';
	
	//核心代码
	long long yuShu = 0;//这里注意是long long类型的
	for (int i = 0; i < lena; i++) {
		yuShu = yuShu*10 + a[i];
		c[i] = yuShu / n;
		yuShu = yuShu % n;
	}
	
	//前导0	
	int k = 0;
	while (c[k] == 0 && k < lena-1)
		k++;
	
	//输出		
	for (int i = k; i < lena; i++) {
		printf("%d", c[i]);
	}
	
	return 0;
}

高精度除以高精度

1. 高精度除以高精度就是比较麻烦的了，不是一般的除法，而是通过多次减法来获取最终的值，而且用到了高精度减法，代码比较长，为了看起来简单些，我还写了几个方法封装，代码里都有注释的。
2. 核心代码：

while (n >= 0) {
			//移动b，将移动后的b赋值给数组temp
			//n表示移动位数
			int temp[5050] = {0};
			mov_b (b, temp, n, lenb);
			int lent = n + lenb;			
			int flag = compare(a,temp,lena,lent);
			while (flag != 0) {	
				for(int i = 0; i < lena; i++) {
					//高精度减法
					if (a[i] < temp[i]) {
						a[i] += 10;
						a[i+1] -= 1;
					}
					a[i] = a[i] - temp[i];
				}
				c[n]++;
				
				//改变数组a的值后再次比较，就是去除数组a的"前导0"
				lena = deleteZero (a, lena);				
				flag = compare(a,temp,lena,lent);	
			}
			n--;
		}

3. 看图理解吧
   
   为了更好理解，我带你们写一个例子吧，唔，不要嫌弃我的字哈，感觉得加文字结合才好理解
   

高精度除以高精度代码

#include <stdio.h>
#include <string.h>

//char型转成int型，顺便实现翻转
void change(char s[5010], int arr[5010], int len) {
	for (int i = 0; i < len; i++) {
		arr[i] = s[len-i-1] - '0';
	}
}

//实现数组b的移动，n表示移动的位数
void mov_b (int b[5010], int temp[5010], int n, int lenb) {
	for (int i = 0; i < lenb; i++) {
		temp[i+n] = b[i];
	}
}


//比较数组a与数组temp的大小,由于数组是反转的，所以我们倒着比较
int compare (int a[5010], int temp[5010], int lena, int lent) {
	if (lena < lent) 
		return 0;
	if (lena == lent) {
		for (int i = lena-1; i >= 0; i--) {
			if (a[i] > temp[i])
				return 1;
			if (a[i] < temp[i])
				return 0;
		}
	}
	return 1;
}


int deleteZero (int a[5010], int lena) {
	lena = lena-1;
	while (a[lena] == 0) {
		lena--;
	}
	return (lena+1);
}

int main () {
	char s1[5010], s2[5010];
	int a[5010] = {0}, b[5010] = {0}, c[5010] = {0};
	scanf("%s", s1);
	scanf("%s", s2);
	int lena = strlen(s1);
	int lenb = strlen(s2);
	
	change(s1,a,lena);
	change(s2,b,lenb);
	
	//当被除数小于除数或者被除数为0时直接输出0
	if (lena < lenb || a[lena-1] == 0) {
		printf("0");
	} else {
		int index = lena - lenb;
		int n = index;//用n先存在一下index的值
		while (n >= 0) {
			//移动b，将移动后的b赋值给数组temp
			//n表示移动位数
			int temp[5050] = {0};
			mov_b (b, temp, n, lenb);
			int lent = n + lenb;			
			int flag = compare(a,temp,lena,lent);
			while (flag != 0) {	
				for(int i = 0; i < lena; i++) {
					//高精度减法
					if (a[i] < temp[i]) {
						a[i] += 10;
						a[i+1] -= 1;
					}
					a[i] = a[i] - temp[i];
				}
				c[n]++;
				
				//改变数组a的值后再次比较，就是去除数组a的"前导0"
				lena = deleteZero (a, lena);				
				flag = compare(a,temp,lena,lent);	
			}
			n--;
		}
		
		//去除数组c的前导0，不用传参数，咱不调用那个方法
		while (c[index] == 0) {
			index--;
		}
		
		//输出
		for (int i = index; i >= 0; i--)
			printf("%d", c[i]);
	}
	
	return 0;
}

如若有错，欢迎大家斧正！
写在最后的碎碎念，会有人看到这里吗？至此，所有的高精度算法都写完啦，建议大家自己动手模拟一下过程，印象会更加深刻哦，如果有什么想看的关于C语言的题，可以告诉我，如果我会写的话，我会回复的哈，已读未回，百分之九十是我不会写，哈哈哈哈哈哈哈。
最后最后，我其实是个小菜鸡，代码只是个思路，还是有待优化的，我相信你们可以的！ヾ(◍°∇°◍)ﾉﾞ

2024.1.13