1002: [FJOI2007]轮状病毒

1002: [FJOI2007]轮状病毒

Time Limit: 1 Sec  Memory Limit: 162 MB
Submit: 2609  Solved: 1450
[Submit][Status]

Description

给定n(N<=100),编程计算有多少个不同的n轮状病毒。

Input

第一行有1个正整数n。

Output

将编程计算出的不同的n轮状病毒数输出

Sample Input

3

Sample Output

16

HINT

Source

题解:这道题可以采用“打表—找规律”战术——通过打表可以发现1,5,16,45,121,320,841,2205。。。。然后奇数项1=12,16=42,121=112,841=292,得到另一个序列——1、4、11、29,且11=3×4-1,29=3×11-4,即A1=1,A2=4,Ai=3*Ai-1-Ai-2,所以奇数项规律Finished。。。然后偶数项,将数字除以5,得到1=12,9=32,64=82,规律和上面的一样,只不过A2不一样,然后别的没了,直接高精度。。。(呵呵0ms Accept我也是醉了,代码略长求不鄙视TT)

  1 var
  2         i,j,k,l,m,n:longint;
  3         a,b,c:array[0..1000] of longint;
  4 begin
  5         readln(n);
  6         if odd(n) then
  7                 begin
  8                         n:=(n+1) div 2;
  9                         if n<=2 then
 10                                 begin
 11                                         if n=1 then writeln(1) else writeln(16);
 12                                 end
 13                         else
 14                                 begin
 15                                         a[1]:=1;
 16                                         a[0]:=1;
 17                                         b[1]:=4;
 18                                         b[0]:=1;
 19                                         for i:=3 to n do
 20                                                 begin
 21                                                         if odd(i) then
 22                                                                 begin
 23                                                                         k:=0;
 24                                                                         c[0]:=b[0]+1;
 25                                                                         for j:=1 to c[0] do
 26                                                                                 begin
 27                                                                                         k:=k+b[j]*3;
 28                                                                                         c[j]:=k mod 10;
 29                                                                                         k:=k div 10;
 30                                                                                 end;
 31                                                                         for j:=1 to c[0] do
 32                                                                                 begin
 33                                                                                         c[j]:=c[j]-a[j];
 34                                                                                         if c[j]<0 then
 35                                                                                                 begin
 36                                                                                                         dec(c[j+1]);
 37                                                                                                         c[j]:=c[j]+10;
 38                                                                                                 end;
 39                                                                                 end;
 40                                                                         while c[c[0]]=0 do dec(c[0]);
 41                                                                         a[0]:=c[0];
 42                                                                         for j:=1 to a[0] do
 43                                                                                 a[j]:=c[j];
 44                                                                 end
 45                                                         else
 46                                                                 begin
 47                                                                         k:=0;
 48                                                                         c[0]:=a[0]+1;
 49                                                                         for j:=1 to c[0] do
 50                                                                                 begin
 51                                                                                         k:=k+a[j]*3;
 52                                                                                         c[j]:=k mod 10;
 53                                                                                         k:=k div 10;
 54                                                                                 end;
 55                                                                         for j:=1 to c[0] do
 56                                                                                 begin
 57                                                                                         c[j]:=c[j]-b[j];
 58                                                                                         if c[j]<0 then
 59                                                                                                 begin
 60                                                                                                         dec(c[j+1]);
 61                                                                                                         c[j]:=c[j]+10;
 62                                                                                                 end;
 63                                                                                 end;
 64                                                                         while c[c[0]]=0 do dec(c[0]);
 65                                                                         b[0]:=c[0];
 66                                                                         for j:=1 to b[0] do
 67                                                                                 b[j]:=c[j];
 68                                                                 end;
 69                                                 end;
 70                                         if odd(n) then
 71                                                 begin
 72                                                         c[0]:=a[0];
 73                                                         for i:=a[0] downto 1 do
 74                                                                 c[i]:=a[i];
 75                                                 end
 76                                         else
 77                                                 begin
 78                                                         c[0]:=c[0];
 79                                                         for i:=b[0] downto 1 do
 80                                                                 c[i]:=b[i];
 81                                                 end;
 82                                         fillchar(a,sizeof(a),0);
 83                                         a[0]:=c[0]*2;
 84                                         for i:=1 to c[0] do
 85                                                 begin
 86                                                         for j:=1 to c[0] do
 87                                                                 begin
 88                                                                         a[i+j-1]:=a[i+j-1]+c[i]*c[j];
 89                                                                         a[i+j]:=a[i+j]+(a[i+j-1] div 10);
 90                                                                         a[i+j-1]:=a[i+j-1] mod 10;
 91                                                                 end;
 92                                                 end;
 93                                         while a[a[0]]=0 do dec(a[0]);
 94                                         for i:=a[0] downto 1 do
 95                                                 write(a[i]);
 96                                         writeln;
 97                                 end;
 98                 end
 99         else
100                 begin
101                         n:=n div 2;
102                         if n<=2 then
103                                 begin
104                                         if n=1 then writeln(5) else writeln(45);
105                                 end
106                         else
107                                 begin
108                                         a[0]:=1;
109                                         a[1]:=1;
110                                         b[0]:=1;
111                                         b[1]:=3;
112                                         for i:=3 to n do
113                                                 begin
114                                                         if odd(i) then
115                                                                 begin
116                                                                         k:=0;
117                                                                         c[0]:=b[0]+1;
118
119                                                                         for j:=1 to c[0] do
120                                                                                 begin
121                                                                                         k:=k+b[j]*3;
122                                                                                         c[j]:=k mod 10;
123                                                                                         k:=k div 10;
124                                                                                 end;
125                                                                         for j:=1 to c[0] do
126                                                                                 begin
127                                                                                         c[j]:=c[j]-a[j];
128                                                                                         if c[j]<0 then
129                                                                                                 begin
130                                                                                                         dec(c[j+1]);
131                                                                                                         c[j]:=c[j]+10;
132                                                                                                 end;
133                                                                                 end;
134                                                                         while c[c[0]]=0 do dec(c[0]);
135                                                                         a[0]:=c[0];
136                                                                         for j:=1 to a[0] do
137                                                                                 a[j]:=c[j];
138                                                                 end
139                                                         else
140                                                                 begin
141                                                                         k:=0;
142                                                                         c[0]:=a[0]+1;
143
144                                                                         for j:=1 to c[0] do
145                                                                                 begin
146                                                                                         k:=k+a[j]*3;
147                                                                                         c[j]:=k mod 10;
148                                                                                         k:=k div 10;
149                                                                                 end;
150                                                                         for j:=1 to c[0] do
151                                                                                 begin
152                                                                                         c[j]:=c[j]-b[j];
153                                                                                         if c[j]<0 then
154                                                                                                 begin
155                                                                                                         dec(c[j+1]);
156                                                                                                         c[j]:=c[j]+10;
157                                                                                                 end;
158                                                                                 end;
159                                                                         while c[c[0]]=0 do dec(c[0]);
160                                                                         b[0]:=c[0];
161                                                                         for j:=1 to b[0] do
162                                                                                 b[j]:=c[j];
163                                                                 end;
164                                                 end;
165                                         if odd(n) then
166                                                 begin
167                                                         c[0]:=a[0];
168                                                         for i:=1 to c[0] do
169                                                                 c[i]:=a[i];
170                                                 end
171                                         else
172                                                 begin
173                                                         c[0]:=b[0];
174                                                         for i:=1 to c[0] do
175                                                                 c[i]:=b[i];
176                                                 end;
177                                         fillchar(a,sizeof(a),0);
178                                         a[0]:=2*C[0];
179                                         for i:=1 to c[0] do
180                                                 for j:=1 to c[0] do
181                                                         begin
182                                                                 a[i+j-1]:=a[i+j-1]+c[i]*c[j];
183                                                                 a[i+j]:=a[i+j]+(a[i+j-1] div 10);
184                                                                 a[i+j-1]:=a[i+j-1] mod 10;
185                                                         end;
186                                         while a[a[0]]=0 do dec(a[0]);
187                                         k:=0;
188                                         for i:=1 to a[0] do
189                                                 begin
190                                                         k:=k+a[i]*5;
191                                                         a[i]:=k mod 10;
192                                                         k:=k div 10;
193                                                 end;
194                                         while k>0 do
195                                                 begin
196                                                         inc(a[0]);
197                                                         a[a[0]]:=k mod 10;
198                                                         k:=k div 10;
199                                                 end;
200                                         for i:=a[0] downto 1 do
201                                                 write(a[i]);
202                                         writeln;
203                                 end;
204                 end;
205 end.
时间: 2024-08-09 02:17:32

1002: [FJOI2007]轮状病毒的相关文章

BZOJ 1002 [FJOI2007]轮状病毒

1002: [FJOI2007]轮状病毒 Description 轮状病毒有很多变种,所有轮状病毒的变种都是从一个轮状基产生的.一个N轮状基由圆环上N个不同的基原子和圆心处一个核原子构成的,2个原子之间的边表示这2个原子之间的信息通道.如下图所示 N轮状病毒的产生规律是在一个N轮状基中删去若干条边,使得各原子之间有唯一的信息通道,例如共有16个不同的3轮状病毒,如下图所示 现给定n(N<=100),编程计算有多少个不同的n轮状病毒 Input 第一行有1个正整数n Output 计算出的不同的n

bzoj 1002 [FJOI2007]轮状病毒 高精度&amp;&amp;找规律&amp;&amp;基尔霍夫矩阵

1002: [FJOI2007]轮状病毒 Time Limit: 1 Sec  Memory Limit: 162 MBSubmit: 2234  Solved: 1227[Submit][Status] Description 给定n(N<=100),编程计算有多少个不同的n轮状病毒. Input 第一行有1个正整数n. Output 将编程计算出的不同的n轮状病毒数输出 Sample Input 3 Sample Output 16 HINT Source 基尔霍夫矩阵总算编出来了,这道题考

BZOJ 1002: [FJOI2007]轮状病毒 递推/基尔霍夫矩阵树定理

f[n]=3*f[n-1]-f[n-2]+2 1002: [FJOI2007]轮状病毒 Time Limit: 1 Sec  Memory Limit: 162 MB Submit: 2959  Solved: 1644 [Submit][Status][Discuss] Description 给定n(N<=100),编程计算有多少个不同的n轮状病毒. Input 第一行有1个正整数n. Output 将编程计算出的不同的n轮状病毒数输出 Sample Input 3 Sample Outpu

BZOJ 1002 FJOI2007 轮状病毒 递推+高精度

题目大意:轮状病毒基定义如图.求有多少n轮状病毒 这个递推实在是不会--所以我选择了打表找规律 首先执行下面程序 #include<cstdio> #include<cstring> #include<iostream> #include<algorithm> #define M 110 using namespace std; struct abcd{ int to,next; bool ban; }table[M<<2]; int head[

1002. [FJOI2007]轮状病毒【找规律+递推】

Description 轮状病毒有很多变种,所有轮状病毒的变种都是从一个轮状基产生的.一个N轮状基由圆环上N个不同的基原子 和圆心处一个核原子构成的,2个原子之间的边表示这2个原子之间的信息通道.如下图所示 N轮状病毒的产生规律是在一个N轮状基中删去若干条边,使得各原子之间有唯一的信息通道,例如共有16个不 同的3轮状病毒,如下图所示 现给定n(N<=100),编程计算有多少个不同的n轮状病毒 Input 第一行有1个正整数n Output 计算出的不同的n轮状病毒数输出 Sample Inpu

bzoj 1002 [FJOI2007]轮状病毒——打表找规律

题目:https://www.lydsy.com/JudgeOnline/problem.php?id=1002 看 Zinn 的博客:https://www.cnblogs.com/Zinn/p/9252831.html 时隔六个月,自己终于也 A 了这道题. #include<cstdio> #include<cstring> #include<algorithm> #include<cmath> #define db double using name

【递推】【高精度】【FJOI 2007】【bzoj 1002】轮状病毒

1002: [FJOI2007]轮状病毒 Time Limit: 1 Sec Memory Limit: 162 MB Submit: 3238 Solved: 1797 Description 给定n(N<=100),编程计算有多少个不同的n轮状病毒. Input 第一行有1个正整数n. Output 将编程计算出的不同的n轮状病毒数输出 Sample Input 3 Sample Output 16 题解: 递推. 打表可以找规律得,f[i]=3*f[i-1]-f[i-2]+2,但是需要高精

bzoj1002[FJOI2007]轮状病毒

bzoj1002[FJOI2007]轮状病毒 题意: N轮状病毒的产生规律是在一个N轮状基中删去若干条边,使得各原子之间有唯一的信息通道,例如共有16个不同的3轮状病毒,如下图所示 现给定n,计算有多少个不同的n轮状病毒.N<=100 题解: 公式:f[i]=f[i-1]*3-f[i-2]+2,i≥3,f[1]=1,f[2]=5.(我承认我是抄的QAQ因为我根本不懂什么矩阵树定理~ 又是高精度,又被我用python水掉了…… 代码: 1 n=int(raw_input()) 2 a=1 3 b=

[FJOI2007]轮状病毒 题解(dp(找规律)+高精度)

[FJOI2007]轮状病毒 题解(dp(找规律)+高精度) 标签:题解 阅读体验:https://zybuluo.com/Junlier/note/1335733 没什么好说的,直接把规律找出来,有两种规律(据说还有多种dp),再套个高精度 \(First\) \(f[1]=1,f[2]=5,f[i]=3×f[i-1]-f[i-2]+2\) 就直接写个高精+低精和高精×低精和高精-高精就行了 \(Second\) \(f[1]=1,f[2]=3,f[i]=f[i-1]+f[i-2]\) \(i