手写 大整数

http://codevs.cn/problem/1166/

区间dp, 手写大整数

  1 #include<bits/stdc++.h>
  2 #define mt(a,b) memset(a,b,sizeof(a))
  3 using namespace std;
  4 typedef long long LL;
  5 const int M=1e2+10;
  6
  7 class BigInteger{
  8     static const int M=1e2+10;
  9     char s[M];
 10     int length;
 11 public:
 12     void init(LL x){
 13         if(x==0){
 14             s[0]=‘0‘;
 15             length=1;
 16             return ;
 17         }
 18         length=0;
 19         while(x){
 20             s[length]=x%10+‘0‘;
 21             x/=10;
 22             length++;
 23         }
 24     }
 25     bool operator <(const BigInteger &b) const{
 26         if(length<b.length) return true;
 27         if(length>b.length) return false;
 28         for(int i=length-1;i>=0;i--){
 29             if(s[i]<b.s[i]) return true;
 30             if(s[i]>b.s[i]) return false;
 31         }
 32         return false;
 33     }
 34     BigInteger operator +(const BigInteger &b) const{
 35         int buffer1[M];
 36         int buffer2[M];
 37         for(int i=0;i<M;i++){
 38             buffer1[i]=0;
 39             buffer2[i]=0;
 40         }
 41         for(int i=0;i<length;i++){
 42             buffer1[i]=s[i]-‘0‘;
 43         }
 44         for(int i=0;i<b.length;i++){
 45             buffer2[i]=b.s[i]-‘0‘;
 46         }
 47         int carry=0;
 48         for(int i=0;i<M;i++){
 49             int value=carry+buffer1[i]+buffer2[i];
 50             buffer1[i]=value%10;
 51             carry=value/10;
 52         }
 53         BigInteger result;
 54         result.length=1;
 55         for(int i=0;i<M;i++){
 56             result.s[i]=buffer1[i]+‘0‘;
 57             if(buffer1[i]) result.length=i+1;
 58         }
 59         return result;
 60     }
 61     BigInteger operator *(const BigInteger &b) const{
 62         int buffer1[M];
 63         int buffer2[M];
 64         int buffer3[M];
 65         for(int i=0;i<M;i++){
 66             buffer1[i]=0;
 67             buffer2[i]=0;
 68             buffer3[i]=0;
 69         }
 70         for(int i=0;i<length;i++){
 71             buffer1[i]=s[i]-‘0‘;
 72         }
 73         for(int i=0;i<b.length;i++){
 74             buffer2[i]=b.s[i]-‘0‘;
 75         }
 76         for(int i=0;i<length;i++){
 77             for(int j=0;j<b.length;j++){
 78                 buffer3[i+j]+=buffer1[i]*buffer2[j];
 79             }
 80         }
 81         int carry=0;
 82         for(int i=0;i<M;i++){
 83             int value=carry+buffer3[i];
 84             buffer3[i]=value%10;
 85             carry=value/10;
 86         }
 87         BigInteger result;
 88         result.length=1;
 89         for(int i=0;i<M;i++){
 90             result.s[i]=buffer3[i]+‘0‘;
 91             if(buffer3[i]) result.length=i+1;
 92         }
 93         return result;
 94     }
 95     void output(){
 96         for(int i=length-1;i>=0;i--){
 97             putchar(s[i]);
 98         }
 99     }
100 };
101 int n,m;
102 LL a[M][M];
103 BigInteger dp[M][M];
104 BigInteger two[M];
105 bool flag[M][M];
106 void init(){
107     two[0].init(1);
108     BigInteger number;
109     number.init(2);
110     for(int i=1;i<M;i++){
111         two[i]=two[i-1]*number;
112     }
113 }
114 BigInteger dfs(int r,int L,int R){
115     BigInteger &d=dp[L][R];
116     if(flag[L][R]) return d;
117     flag[L][R]=true;
118     if(L==R){
119         BigInteger number;
120         number.init(a[r][L]);
121         d=number*two[m];
122         return d;
123     }
124     int time=m-(R-L+1)+1;
125     BigInteger number;
126     number.init(a[r][L]);
127     d=number*two[time]+dfs(r,L+1,R);
128     number.init(a[r][R]);
129     BigInteger buffer=number*two[time]+dfs(r,L,R-1);
130     if(d<buffer) d=buffer;
131     return d;
132 }
133 void solve(){
134     BigInteger answer;
135     answer.init(0);
136     for(int i=0;i<n;i++){
137         mt(flag,false);
138         answer=answer+dfs(i,0,m-1);
139     }
140     answer.output();
141     puts("");
142 }
143 int main(){
144     init();
145     while(~scanf("%d%d",&n,&m)){
146         for(int i=0;i<n;i++){
147             for(int j=0;j<m;j++){
148                 scanf("%lld",&a[i][j]);
149             }
150         }
151         solve();
152     }
153     return 0;
154 }

http://codevs.cn/problem/3116/

大整数 计算

  1 #include<bits/stdc++.h>
  2 #define mt(a,b) memset(a,b,sizeof(a))
  3 using namespace std;
  4 typedef long long LL;
  5 const int M=1e3+10;
  6 class BigInteger{
  7     static const int M=1e3+10;
  8     char s[M];
  9     int length;
 10 public:
 11     void init(char c[]){
 12         int lc=strlen(c);
 13         for(int i=0;i<lc;i++){
 14             s[i]=c[lc-i-1];
 15         }
 16         length=lc;
 17     }
 18     void init(LL x){
 19         if(x==0){
 20             s[0]=‘0‘;
 21             length=1;
 22             return ;
 23         }
 24         length=0;
 25         while(x){
 26             s[length]=x%10+‘0‘;
 27             x/=10;
 28             length++;
 29         }
 30     }
 31     BigInteger operator +(const BigInteger &b) const{
 32         int buffer1[M];
 33         int buffer2[M];
 34         for(int i=0;i<M;i++){
 35             buffer1[i]=0;
 36             buffer2[i]=0;
 37         }
 38         for(int i=0;i<length;i++){
 39             buffer1[i]=s[i]-‘0‘;
 40         }
 41         for(int i=0;i<b.length;i++){
 42             buffer2[i]=b.s[i]-‘0‘;
 43         }
 44         int carry=0;
 45         for(int i=0;i<M;i++){
 46             int value=carry+buffer1[i]+buffer2[i];
 47             buffer1[i]=value%10;
 48             carry=value/10;
 49         }
 50         BigInteger result;
 51         result.length=1;
 52         for(int i=0;i<M;i++){
 53             result.s[i]=buffer1[i]+‘0‘;
 54             if(buffer1[i]) result.length=i+1;
 55         }
 56         return result;
 57     }
 58     BigInteger operator *(const BigInteger &b) const{
 59         int buffer1[M];
 60         int buffer2[M];
 61         int buffer3[M];
 62         for(int i=0;i<M;i++){
 63             buffer1[i]=0;
 64             buffer2[i]=0;
 65             buffer3[i]=0;
 66         }
 67         for(int i=0;i<length;i++){
 68             buffer1[i]=s[i]-‘0‘;
 69         }
 70         for(int i=0;i<b.length;i++){
 71             buffer2[i]=b.s[i]-‘0‘;
 72         }
 73         for(int i=0;i<length;i++){
 74             for(int j=0;j<b.length;j++){
 75                 buffer3[i+j]+=buffer1[i]*buffer2[j];
 76             }
 77         }
 78         int carry=0;
 79         for(int i=0;i<M;i++){
 80             int value=carry+buffer3[i];
 81             buffer3[i]=value%10;
 82             carry=value/10;
 83         }
 84         BigInteger result;
 85         result.length=1;
 86         for(int i=0;i<M;i++){
 87             result.s[i]=buffer3[i]+‘0‘;
 88             if(buffer3[i]) result.length=i+1;
 89         }
 90         return result;
 91     }
 92     void output(){
 93         for(int i=length-1;i>=0;i--){
 94             putchar(s[i]);
 95         }
 96     }
 97 }A,B,C;
 98 char a[M];
 99 char b[M];
100 int main(){
101     while(~scanf("%s%s",a,b)){
102         A.init(a);
103         B.init(b);
104         C=A+B;
105         C.output();
106         puts("");
107     }
108     return 0;
109 }

http://codevs.cn/problem/3117/

  1 #include<bits/stdc++.h>
  2 #define mt(a,b) memset(a,b,sizeof(a))
  3 using namespace std;
  4 typedef long long LL;
  5 const int M=1e3+10;
  6 class BigInteger{
  7     static const int M=1e3+10;
  8     char s[M];
  9     int length;
 10 public:
 11     void init(char c[]){
 12         int lc=strlen(c);
 13         for(int i=0;i<lc;i++){
 14             s[i]=c[lc-i-1];
 15         }
 16         length=lc;
 17     }
 18     void init(LL x){
 19         if(x==0){
 20             s[0]=‘0‘;
 21             length=1;
 22             return ;
 23         }
 24         length=0;
 25         while(x){
 26             s[length]=x%10+‘0‘;
 27             x/=10;
 28             length++;
 29         }
 30     }
 31     BigInteger operator +(const BigInteger &b) const{
 32         int buffer1[M];
 33         int buffer2[M];
 34         for(int i=0;i<M;i++){
 35             buffer1[i]=0;
 36             buffer2[i]=0;
 37         }
 38         for(int i=0;i<length;i++){
 39             buffer1[i]=s[i]-‘0‘;
 40         }
 41         for(int i=0;i<b.length;i++){
 42             buffer2[i]=b.s[i]-‘0‘;
 43         }
 44         int carry=0;
 45         for(int i=0;i<M;i++){
 46             int value=carry+buffer1[i]+buffer2[i];
 47             buffer1[i]=value%10;
 48             carry=value/10;
 49         }
 50         BigInteger result;
 51         result.length=1;
 52         for(int i=0;i<M;i++){
 53             result.s[i]=buffer1[i]+‘0‘;
 54             if(buffer1[i]) result.length=i+1;
 55         }
 56         return result;
 57     }
 58     BigInteger operator *(const BigInteger &b) const{
 59         int buffer1[M];
 60         int buffer2[M];
 61         int buffer3[M];
 62         for(int i=0;i<M;i++){
 63             buffer1[i]=0;
 64             buffer2[i]=0;
 65             buffer3[i]=0;
 66         }
 67         for(int i=0;i<length;i++){
 68             buffer1[i]=s[i]-‘0‘;
 69         }
 70         for(int i=0;i<b.length;i++){
 71             buffer2[i]=b.s[i]-‘0‘;
 72         }
 73         for(int i=0;i<length;i++){
 74             for(int j=0;j<b.length;j++){
 75                 buffer3[i+j]+=buffer1[i]*buffer2[j];
 76             }
 77         }
 78         int carry=0;
 79         for(int i=0;i<M;i++){
 80             int value=carry+buffer3[i];
 81             buffer3[i]=value%10;
 82             carry=value/10;
 83         }
 84         BigInteger result;
 85         result.length=1;
 86         for(int i=0;i<M;i++){
 87             result.s[i]=buffer3[i]+‘0‘;
 88             if(buffer3[i]) result.length=i+1;
 89         }
 90         return result;
 91     }
 92     void output(){
 93         for(int i=length-1;i>=0;i--){
 94             putchar(s[i]);
 95         }
 96     }
 97 }A,B,C;
 98 char a[M];
 99 char b[M];
100 int main(){
101     while(~scanf("%s%s",a,b)){
102         A.init(a);
103         B.init(b);
104         C=A*B;
105         C.output();
106         puts("");
107     }
108     return 0;
109 }

http://codevs.cn/problem/3115/

减法 就 没 考虑进class了 ,那就复杂了 。

 1 //#define txtout
 2 //#define debug
 3 #include<bits/stdc++.h>
 4 #define mt(a,b) memset(a,b,sizeof(a))
 5 using namespace std;
 6 typedef long long LL;
 7 const double pi=acos(-1.0);
 8 const double eps=1e-8;
 9 const int inf=0x3f3f3f3f;
10 const int M=1e3+10;
11 char a[M];
12 char b[M];
13 char answer[M];
14 void Reverse(char s[]){
15     int ls=strlen(s);
16     for(int i=0,j=ls-1;i<j;i++,j--){
17         swap(s[i],s[j]);
18     }
19 }
20 bool isBig(char s1[],char s2[]){
21     int l1=strlen(s1);
22     int l2=strlen(s2);
23     if(l1>l2) return true;
24     if(l1<l2) return false;
25     return strcmp(s1,s2)>0;
26 }
27 void solve(){
28     if(!strcmp(a,b)){
29         answer[0]=‘0‘;
30         answer[1]=0;
31         return ;
32     }
33     bool big=isBig(a,b);
34     if(!big) swap(a,b);
35     int la=strlen(a);
36     int lb=strlen(b);
37     Reverse(a);
38     Reverse(b);
39     for(int i=lb;i<la;i++){
40         b[i]=‘0‘;
41     }
42     int carry=0;
43     for(int i=0;i<la;i++){
44         if(a[i]-carry>=b[i]){
45             answer[i]=a[i]-carry-b[i]+‘0‘;
46             carry=0;
47             continue;
48         }
49         int need=1;
50         while(need*10+a[i]-carry<b[i]){
51             need++;
52         }
53         answer[i]=need*10+a[i]-carry-b[i]+‘0‘;
54         carry=need;
55     }
56     int len=0;
57     for(int i=la-1;i>=0;i--){
58         if(answer[i]>=‘1‘){
59             len=i+1;
60             break;
61         }
62     }
63     if(!big){
64         answer[len]=‘-‘;
65         len++;
66     }
67     answer[len]=0;
68     Reverse(answer);
69 }
70 int main(){
71     #ifdef txtout
72     #endif // txtout
73     while(~scanf("%s%s",a,b)){
74         solve();
75         puts(answer);
76     }
77     return 0;
78 }

end

时间: 2024-11-13 16:58:56

手写 大整数的相关文章

自己动手写Java大整数《3》除法和十进制转换

之前已经完成了大整数的表示.绝对值的比较大小.取负值.加减法运算以及乘法运算.具体见前两篇博客(自己动手写Java * ). 这里添加除法运算. 另外看到作者Pauls Gedanken在blog(http://paul-ebermann.tumblr.com/post/6312290327/big-numbers-selfmade-part-2-14-conversion-from)中的转换十进制数到大整数的方法,这里一并列出. 除法 除法使用经典的除法法则,但是有几个需要注意的问题,下面列出

自己动手写Java大整数《4》扩展欧几里得和Mod逆

/* *我把这个大整数的系列写成了Code中的项目,见https://code.csdn.net/XUE_HAIyang/bignumber */ 之前已经完成了大整数的表示.绝对值的比较大小.取负值.加减法运算.乘法运算以及除法和余数运算.具体见我的主页前三篇博客(自己动手写Java系列 ). 这篇博客添加求大整数GCD.扩展欧几里得算法和求Mod逆的算法. 扩展欧几里得算法 说道扩展的欧几里得算法,首先我们看下简单的欧几里得算法.经典的欧几里得算法就是 计算两个整数的最大公因子的算法,所基于

python写的大整数相乘的方法

输入 72106547548473106236 982161082972751393 两个大整数 输出结果 70820244829634538040848656466105986748 解题思路 首先根据 大整数相乘的原理的基础上,把大整数进行优化拆分,拆分的长度,要考虑语言中整形的长度.这里用的python,其实可以直接乘的,呵呵.我暂定设为了 4,也就是 说 7210 6547 5484 7310 6236 98 2161 0829 7275 1393 然后 逐份相乘,当然千万别忘了结果要补

COJ 1211 大整数开平方

手写求大整数开根号所得到的值,具体计算过程参考别人的资料,最后利用java的大整数得到答案 别人博客链接:http://www.cnblogs.com/Rinyo/archive/2012/12/16/2820450.html 1.举例 上式意为65536的开平方为256.手开方过程类似于除法计算.为了方便表述,以下仍称类似位置的数为“被除数”.“除数”.“商”. 以65536为例,其具体计算过程如下: Step1:将被开方数(为了形象,表述成“被除数”,此例中即为65536)从个位往高位每两位

整数平方根:整数开方及大整数开方解决方法

求整数N的开方,精度在0.001 二分法 若N大于1,则从[1, N]开始,low = 1, high = N, mid = low + (high - low) >> 1开始进行数值逼近 若N小于1,则从[N, 1]开始,low = 0, high = N, mid = low + (high - low) >> 1开始进行数值逼近 #include <stdio.h> #include <stdlib.h> #include <math.h>

【PaddlePaddle系列】手写数字识别

  最近百度为了推广自家编写对深度学习框架PaddlePaddle不断推出各种比赛.百度声称PaddlePaddle是一个"易学.易用"的开源深度学习框架,然而网上的资料少之又少.虽然百度很用心地提供了许多文档,而且还是中英双语具备,但是最关键的是报错了很难在网上找到相应的解决办法.为了明年备战百度的比赛,便开始学习以下PaddlePaddle. 1.安装 PaddlePaddle同样支持CUDA加速运算,但是如果没有NVIDIA的显卡,那就还是装CPU版本. CPU版本安装:pip

Miller-Rabin 素性测试 与 Pollard Rho 大整数分解

\(\\\) Miller-Rabin 素性测试 考虑如何检验一个数字是否为素数. 经典的试除法复杂度 \(O(\sqrt N)\) 适用于询问 \(N\le 10^{16}\) 的时候. 如果我们要把询问范围加到 \(10^{18}\) ,再多组询问呢? Miller 和 Rabin 建立了Miller-Rabin 质数测试算法. \(\\\) Fermat 测试 首先我们知道费马小定理: \[ a^{p-1}\equiv 1\pmod p \] 当且仅当 \(p\) 为素数时成立. 逆命题是

logistic回归与手写识别例子的实现

本文主要介绍logistic回归相关知识点和一个手写识别的例子实现 一.logistic回归介绍: logistic回归算法很简单,这里简单介绍一下: 1.和线性回归做一个简单的对比 下图就是一个简单的线性回归实例,简单一点就是一个线性方程表示 (就是用来描述自变量和因变量已经偏差的方程) 2.logistic回归 可以看到下图,很难找到一条线性方程能将他们很好的分开.这里也需要用到logistic回归来处理了. logistic回归本质上是线性回归,只是在特征到结果的映射中加入了一层函数映射,

KNN分类算法实现手写数字识别

需求: 利用一个手写数字"先验数据"集,使用knn算法来实现对手写数字的自动识别: 先验数据(训练数据)集: ?数据维度比较大,样本数比较多. ? 数据集包括数字0-9的手写体. ?每个数字大约有200个样本. ?每个样本保持在一个txt文件中. ?手写体图像本身的大小是32x32的二值图,转换到txt文件保存后,内容也是32x32个数字,0或者1,如下: 数据集压缩包解压后有两个目录:(将这两个目录文件夹拷贝的项目路径下E:/KNNCase/digits/) ?目录trainingD