CRJ巨佬的gjd算法模板

数组高精度

定义:

int N[20000], len, flag;
bignum() {
  memset(N,0,sizeof(N));
  len = 0;
  flag = 1;
}  

赋值运算:

void operator =(long long a) {
  int i=0;
  while(a!=0) {
     N[i]=a%10;
     a/=10;
     i++;
  }
  len=i;}
  void operator = (string g) {
  for(int i=0;i<g.size();i++)    N[i]=g[g.size()-1-i]-48;
  len=g.size();}
    

输出:

void pt()
{
    if(flag==0) printf("-");
    for(int i=len;i>=0;i--) printf("%d",N[i]);
}

三则运算:

    friend bignum operator + (bignum f,bignum g)
    {
        bignum ans;
        ans.len=max(f.len,g.len)+1;
        int tp=0;
        for(int i=0;i<=ans.len;i++)
        {
            ans.N[i]=f.N[i]+g.N[i]+tp;
            tp=ans.N[i]/10;
            ans.N[i]%=10;
        }
        int i=ans.len;
        while(ans.N[i]==0&&i>0)
        {
            ans.len--;
            i--;
        }
        return ans;
    }

    friend bignum operator * (bignum f,bignum g)
    {
        bignum ans;
        ans.len=f.len+g.len;
        int tp=0;
        for(int i=0;i<f.len;i++)
        {
            for(int j=0;j<g.len;j++)
            {
                ans.N[i+j]+=f.N[i]*g.N[j];
                ans.N[i+j+1]+=ans.N[i+j]/10;
                ans.N[i+j]%=10;
            }
        }
        int i=ans.len;
        while(ans.N[i]==0&&i>0)
        {
            ans.len--;
            i--;
        }
        return ans;
    }

    friend bignum operator - (bignum f,bignum g)
    {
        bignum ans;
        if(f<g)
        {
            swap(f,g);
            ans.flag=0;
        }

        ans.len=max(f.len,g.len);
        for(int i=0;i<f.len;i++)
        {
            ans.N[i]=f.N[i]-g.N[i];
            if(ans.N[i]<0)
            {
                f.N[i+1]--;
                ans.N[i]+=10;
            }
        }
        int i=ans.len;
        while(ans.N[i]==0&&i>0)
        {
            ans.len--;
            i--;
        }
        return ans;
    }

比较运算:

    friend bool operator < (bignum f,bignum g)
    {
        if(f.len<g.len) return true;
        else if(f.len==g.len)
        {
            bool flg=1;
            for(int i=0;i<g.len;i++)if(f.N[i]<g.N[i])    return true;
            return false;
        } else return false;
    }

完整代码:

  1 #include<iostream>
  2 #include<cstring>
  3 #include<cstdio>
  4 #include<algorithm>
  5 using namespace std;
  6
  7 struct bignum
  8 {
  9     int N[20000],len,flag;
 10
 11     bignum()
 12     {
 13         memset(N,0,sizeof(N));
 14         len=0;
 15         flag=1;
 16     }
 17
 18     void operator =(long long a)
 19   {
 20       int i=0;
 21       while(a!=0)
 22       {
 23            N[i]=a%10;
 24            a/=10;
 25            i++;
 26        }
 27        len=i;
 28   }
 29
 30     void operator = (string g)
 31     {
 32         for(int i=0;i<g.size();i++)    N[i]=g[g.size()-1-i]-48;
 33         len=g.size();
 34     }
 35
 36     friend bignum operator + (bignum f,bignum g)
 37     {
 38         bignum ans;
 39         ans.len=max(f.len,g.len)+1;
 40         int tp=0;
 41         for(int i=0;i<=ans.len;i++)
 42         {
 43             ans.N[i]=f.N[i]+g.N[i]+tp;
 44             tp=ans.N[i]/10;
 45             ans.N[i]%=10;
 46         }
 47         int i=ans.len;
 48         while(ans.N[i]==0&&i>0)
 49         {
 50             ans.len--;
 51             i--;
 52         }
 53         return ans;
 54     }
 55
 56     friend bignum operator * (bignum f,bignum g)
 57     {
 58         bignum ans;
 59         ans.len=f.len+g.len;
 60         int tp=0;
 61         for(int i=0;i<f.len;i++)
 62         {
 63             for(int j=0;j<g.len;j++)
 64             {
 65                 ans.N[i+j]+=f.N[i]*g.N[j];
 66                 ans.N[i+j+1]+=ans.N[i+j]/10;
 67                 ans.N[i+j]%=10;
 68             }
 69         }
 70         int i=ans.len;
 71         while(ans.N[i]==0&&i>0)
 72         {
 73             ans.len--;
 74             i--;
 75         }
 76         return ans;
 77     }
 78
 79     friend bignum operator - (bignum f,bignum g)
 80     {
 81         bignum ans;
 82         if(f<g)
 83         {
 84             swap(f,g);
 85             ans.flag=0;
 86         }
 87
 88         ans.len=max(f.len,g.len);
 89         for(int i=0;i<f.len;i++)
 90         {
 91             ans.N[i]=f.N[i]-g.N[i];
 92             if(ans.N[i]<0)
 93             {
 94                 f.N[i+1]--;
 95                 ans.N[i]+=10;
 96             }
 97         }
 98         int i=ans.len;
 99         while(ans.N[i]==0&&i>0)
100         {
101             ans.len--;
102             i--;
103         }
104         return ans;
105     }
106
107     friend bool operator < (bignum f,bignum g)
108     {
109         if(f.len<g.len) return true;
110         else if(f.len==g.len)
111         {
112             bool flg=1;
113             for(int i=0;i<g.len;i++)if(f.N[i]<g.N[i])    return true;
114             return false;
115         } else return false;
116     }
117
118     void pt()
119     {
120         if(flag==0) printf("-");
121         for(int i=len;i>=0;i--) printf("%d",N[i]);
122     }
123 };
124
125 int main() {
126   bignum A,B;
127     long long a,b;
128     cin>>a>>b;
129     A=a;
130     B=b;
131     bignum ans;
132     ans=A-B;
133     ans.pt();
134     return 0;
135 }
时间: 2024-11-25 18:56:26

CRJ巨佬的gjd算法模板的相关文章

CRJ巨佬gjd算法伪代码

为了方便记忆,因此给出为代码 定义 reset(N) flag=1,len = 0 赋值(LL) : while a不为零 N[i] = a[i]个位 len = i 赋值(string a): len = a.len for 0 -> len N[i] = a[len-1-i] - '0' 加法: len = maxlen(a,b) + 1 tp = 0; for 0 -> N N[i] = a[i]+b[i] + tp tp = N[i] / 10 N[i] %= 10 去前导零 减法:

tarjan算法模板

var {left表示点 root 没离开栈 vis表示点 root 有没有被访问过} i,n,m,now,time,color,top:longint; v:array[0..10001] of record start:longint;end; e:array[0..100001] of record y,next:longint;end; dfn,low,stack,encolor:array[0..10001] of longint; vis,left:array[0..10001] o

prim算法模板

var g:array[1..10,1..10] of longint; d:array[1..10] of longint; f:array[1..10] of boolean; procedure prim; var i,j,k,min:longint; begin fillchar(g,sizeof(g),0); fillchar(f,sizeof(f),0); for i:=1 to n do d[i]:=g[1,i]; f[1]:=true; for i:=2 to n do begi

bellman-ford算法模板

有SPFA模板,bellman-ford模板显然是多余的. var e:array[1..maxe]of record a,b,w:longint;end; { 距源点s距离 } dis:array[1..maxn]of longint; { 前驱 } pre:array[1..maxn]of longint; m,n,s:longint; procedure relax(u,v,w:longint); begin if dis[u]+w<dis[v] then begin dis[v]:=di

Floyd判最小环算法模板

算法思想:如果存在最小环,会在编号最大的点u更新最短路径前找到这个环,发现的方法是,更新最短路径前,遍历i,j点对,一定会发现某对i到j的最短路径长度dis[i][j]+mp[j][u]+mp[u][i] != INF,这时i,j是图中挨着u的两个点,因为在之前最短路更新过程中,u没有参与更新,所以dis[i][j]所表示的路径中不会出现u,如果成立,则一定是一个环.用Floyd算法来实现.但是对于负环此算法失效,因为有负环时,dis[i][j]已经不能保证i到j的路径上不会经过同一个点多次了.

hdu 1711 KMP算法模板题

题意:给你两个串,问你第二个串是从第一个串的什么位置開始全然匹配的? kmp裸题,复杂度O(n+m). 当一个字符串以0为起始下标时.next[i]能够描写叙述为"不为自身的最大首尾反复子串长度". 当发生失配的情况下,j的新值next[j]取决于模式串中T[0 ~ j-1]中前缀和后缀相等部分的长度, 而且next[j]恰好等于这个最大长度. 防止超时.注意一些细节.. 另外:尽量少用strlen.变量记录下来使用比較好,用字符数组而不用string //KMP算法模板题 //hdu

HDU 2544 最短路(我的dijkstra算法模板、SPAFA算法模板)

思路:这道题是基础的最短路径算法,可以拿来试一下自己对3种方法的理解 dijkstra主要是从第一个点开始枚举,每次枚举出当当前最小的路径,然后再以那最小的路径点为起点,求出它到其它未标记点的最短距离 bellman-ford 算法则是假设有向网中有n 个顶点.且不存在负权值回路,从顶点v1 和到顶点v2 如果存在最短路径,则此路径最多有n-1 条边.这是因为如果路径上的边数超过了n-1 条时,必然会重复经过一个顶点,形成回路:而如果这个回路的权值总和为非负时,完全可以去掉这个回路,使得v1到v

kruskal 算法模板

http://acm.sdut.edu.cn/sdutoj/problem.php?action=showproblem&problemid=2896 #include <stdio.h> #include <string.h> #include <stdlib.h> struct node { int u,v,w; }q[200001]; int bin[50001]; int n,m,ans; int cmp(const void *a,const void

Floyd算法模板

Floyd可以求出任意两点间的最短距离,代码也相对简单,对于稀疏图来说效率也还是不错的,但由于三个for循环导致时间复杂度较高,不适合稠密图. Floyd算法模板(精简版): void Floyd() { int dist[maxn][maxn]; // dist存储i到j的最短距离 for(int k = 1; k <= n; k++) for(int i = 1;i <= n; i++) for(int j = 1; j <= n; j++) if(dist[i][k] + dist