高精度算法+KMP学习报告

鹤雲溯笙

已于 2024-02-15 20:15:09 修改

阅读量883

点赞数 5

文章标签：学习

于 2024-02-08 20:58:17 首次发布

本文链接：https://blog.csdn.net/2302_80039469/article/details/136081572

版权

一.高精度算法

高精度算法意义

在C语言中常规模式下对数的存储类型均有其限制

例如int最大数为(2^31)-1=2147483647 即使是unsigned int条件下也仅为 0～4294967295

long long也才-9223372036854775808~9223372036854775807

当出现了大于这些范围的极端情况例如 $2^{1000}$ 的运算就不能用c语言中常规的变量运算

但假使我们调转思路将其每一位数字独立出来进行运算仿佛就不受数值大小限制

对于被独立出来的各个单元我们有了储存他们更合适的方式-数组。

1.高精度加法

模板题：

洛谷P1601 A+B

关注到此题给出的输入范围即测试数据的数值范围可见是远超常规所用数值范围

故应用高精度加法来解决

既然我们已经提出是用数组来解决数值过大的问题

我们便也能简单的想到利用字符串输入的方式储存输入的数据

	scanf("%s%s",a,b);//以字符串形式储存两个数据

以字符串储存后转化为数组形式

	a1[0]=strlen(a);
	b1[0]=strlen(b);//确认数值位数
	for(int i=1; i<=a1[0]; i++) a1[i]=a[a1[0]-i]-'0';
	for(int i=1; i<=b1[0]; i++) b1[i]=b[b1[0]-i]-'0';
//存入数组中 同时注意此处将字符串倒序储存

将数值存入数组的部分以完成那如何将其进行运算？

其实我们回想到我们平时手头对大数笔算时所用方法即可

即是列竖式运算

例如ABC+EFG

结果的个位数即是(C+G)%10

若C+G>10即给高一位加一即可

	for(j=1; j<=max(a1[0],b1[0])+1; j++)//保证运算到最大一位
       {
		c1[j]=a1[j]+b1[j];
		if(c1[j]>=10) {
			c1[j]%=10;
			a1[j+1]++;
		}

类似于按位运算用数组同一位进行常规加减即可

	for(int i=c1[0]; i>=1; i--) {//删除前置0 同时避免个例0不被输出
		if(x==0&&c1[i]==0) continue;
		x=1;
		cout<<c1[i];
	}
	if(!x) cout<<0;

2.高精度乘法

模板题

洛谷P1303 A*B

同样我们对乘法是手算方法依然是列竖式也就意味着我们可以用类似的方法解决此题

例如

ab

* cd

答案中个位数即是bc+bd+ad

十位数即为bc+ac+ad

满十进一

此处需要注意其中结果位数与因子位数之间存在一个关系

	c[0]=a[0]+b[0]-1;

（结果位数小于等于因子数和-1）

for(j=1;j<=b[0];j++)
	{
		for(i=1;i<=a[0];i++)
		{
			c[i+j-1]+=a[i]*b[j];
			c[i+j]+=c[i+j-1]/10;
			c[i+j-1]%=10;        //进位
		}
	}

3.高精度减法

洛谷P2142 A-B

在日常运算中我们也都是将减法和除法当加法和乘法的逆运算在这里也是一个道理

 int maxl = max(a.size(), b.size());
 /*
 找到两个数中的最大位，为for循环服务 
 如果两个数位数不相等，相减也无妨，因为位数少的数那部分被0补齐，减下去不影响
 */
 for(int i = 1; i <= maxl; i ++)
 {
 	if(na[i] < nb[i])//减不够
 	{
 		na[i + 1] --;//借位
 		na[i] += 10;//到低位去
 	}
 	ans[i] = na[i] - nb[i];//相减
 }

其中存在一个问题那就是我们需要保证永远是大数减小数如果出现负数再加上负号就行

if((a < b && a.size() == b.size()) || a.size() < b.size())
	{
		swap(a, b);
		pd = true;

4.高精度除法

洛谷P2002 A/B

除法在此较为特殊我们不能拆开进行除法

我们就可以将其视为减法每次减去当前除数补0后所构造的新减数减到负数时停止且不计入次数

记录下进行了几次减法

#include<iostream>
#include<sstream>
#include<string>
#include<algorithm>
#include<cstring>
using namespace std;
string itos(int x) //将数据转化成字符串，stringstream神器ovo，方便下面按照字符串存起来，好比较
{
    stringstream s;
    s<<x;
    return s.str();
}
bool greater_dif(string x,string y) //字符串大于比较：优先级为符号>位数>大小关系（nc的c++比较字符串是一位一位比ASCII啊......）
{
    if(x[0]!='-'&&y[0]=='-') return true; //先比符号
    if(x[0]=='-'&&y[0]!='-') return false;
    if(x.size()>y.size() || (x.size()==y.size() && x>y)) return true; // 再比位数和大小
    return false; //其它情况直接false
} 
bool smaller_dif(string x,string y) //字符串小于比较，效果同上
{
    if(x[0]=='-'&&y[0]!='-') return true;
    if(x[0]!='-'&&y[0]=='-') return false;
    if(x.size()<y.size() || (x.size()==y.size() && x<y)) return true;
    return false; 
} 
string highmin(string x,string y) //高精度减法运算
{
    int w=0;
    int z=max(x.size(),y.size());
    int tp[z+5];
    memset(tp,0,sizeof(tp)); //数组清零
    string result="";
    if(smaller_dif(x,y)) //支持小数减大数的操作，采取绝对值法，即小数减大数等于大数减小数的绝对值
    {
        swap(x,y);
        result+="-"; 
    }
    reverse(x.begin(),x.end()); //倒序存储
    reverse(y.begin(),y.end());
    for(int i=0;i<z+5;i++) //然后就是直接减
    {
        int p=int(x[i]-'0');
        int q=int(y[i]-'0');
        if(i>=x.size()) p=0;
        if(i>=y.size()) q=0;
        tp[i]=p-q;
    }
    for(int i=0;i<=z;i++) //退位，由于是倒序的所以应当倒着退位
    {
        if(tp[i]<0)
        {
            tp[i+1]-=1; //倒着退位
            tp[i]+=10;
        }
        if(tp[i]!=0) w=i; //记录最靠前的非零位置，方便输出
    }
    for(int i=w;i>=0;i--)
    {
        string z1=itos(tp[i]);
        result+=z1;
    }
    return result;
}
string divide(string x,string y) //高精度除法模块
{
    string result_d=""; 
    int q=max(x.size(),y.size());
    int tmp[q+5];
    memset(tmp,0,sizeof(tmp)); //仍然是先数组存
    int ans=0;
    int w=0;
    string y_l=y; //便于y初始化
    while(greater_dif(x,"0")) //这块参考上面思路
    {
        while(greater_dif(x,y+"0") || x==y+"0") //预先判断防止减完小于0了还要恢复过来
        {
            y+="0"; //补“0”
            ans++;
        }
        tmp[ans]++;
        if(ans>w) w=ans;
        ans=0; //ans初始化
        x=highmin(x,y);
        if(x[0]=='-') 
        {
            tmp[ans]-=1; //防止减多了
            break;
        }
        y=y_l; //y初始化
    }
    for(int i=w;i>=0;i--)
    {
        string z_d=itos(tmp[i]);
        result_d+=z_d;	
    } 
    return result_d;
}
int main()
{
    string a,b;
    cin>>a>>b;
    cout<<divide(a,b)<<endl; //输出除法结果
    return 0;
}

二.KMP算法

洛谷P3375 KMP

KMP算法是尽可能在对此字符串遍历一遍的情况下找到所求要点

因此创建了另一个next数组

对其中相符字段进行标记计数

当出现不同点的时候根据计数标识回退避免重复遍历

#include <cstdio>
#include <cstring>

char p[1000005], t[1000005];
int len1, len2;
int next[1000005], next2[1000005];

void do_next()
{
    next[0] = 0;
    int i = 1;
    int len = 0;

    while (i < len2)
    {
        if (t[i] == t[len])
            next[i++] = ++len;
        else
        {
            if (len > 0)
                len = next[len - 1];
            else
                next[i++] = len;
        }
    }
}

void kmp()
{
    int i = 0, j = 0;
    next2[0] = -1;
    
    for (int i = 1; i < len2; i++)
        next2[i] = next[i - 1];
    
    while (i < len1)
    {
        if (j == len2 - 1 && p[i] == t[j])
        {
            printf("%d\n", i - j + 1);
            j = next2[j];
            if (j == -1)
                j++;
        }
        if (p[i] == t[j])
        {
            j++;
            i++;
        }
        else
        {
            j = next2[j];
            if (j == -1)
            {
                i++;
                j++;
            }
        }
    }
}

int main()
{
    scanf("%s%s", p, t);
    len1 = strlen(p);
    len2 = strlen(t);

    do_next();

    kmp();

    for (int i = 0; i < len2; i++)
        printf("%d ", next[i]);

    return 0;
}