- Fibonacci数列的递推公式为：F_n=F_(n-1)+F_(n-2)， 其中F_1=F_2=1。求F除以10007的余数是多少。
输入格式：输入包含一个正整数n。
输出格式：输出一行，包含一个整数，表示F_n除以10007的余数。
样例输入：
22
样例输出：
7704
#include<iostream>
using namespace std;
int fibo(int n )//迭代法求斐波那契数列
{
if( n <= 0 )
return 0;
if( n==1 || n==2 )
return 1;
int num,n1 = 1,n2 = 1;
for(int i=3; i<=n; i++)
{
num = n1;
n1 += n2;
n2 = num;
}
return n1;
}
int fibo(int n)//递归法求斐波那契数列
{
if( n == 0 )
return 0;
if(n==1)
return 1;
return fibo(n-1)+fibo(n-2);
}
int main(void)
{
int n;
cin>>n;
cout<<fibo(n)%10007;
return 0;
}
迭代法与递归法都比较直观简单，时间复杂度O(n)，之后是最优算法，矩阵法，时间复杂度O(logn)。
//矩阵法 O(logn)
#include <stdio.h>
#include<stdlib.h>
int **mul(int **A, int **B)
{
int **C;
C = (int**)malloc(2*sizeof(int*));
C[0] = (int*)malloc(2*sizeof(int));
C[1] = (int*)malloc(2*sizeof(int));
C[0][0] = 0, C[0][1] = 0;
C[1][0] = 0, C[1][1] = 0;
for(int i = 0; i < 2; i++)
for(int j = 0; j < 2; j++)
for(int k = 0; k < 2; k++)
C[i][j] = C[i][j] + A[i][k] * B[k][j];
return C;
}
int **pow(int **A, int n)
{
int **B;
B = (int**)malloc(2*sizeof(int*));
B[0] = (int*)malloc(2*sizeof(int));
B[1] = (int*)malloc(2*sizeof(int));
B[0][0] = 1, B[0][1] = 0;
B[1][0] = 0, B[1][1] = 1;
while(n>0)
{
if(n & 1) B = mul(B,A);
A = mul(A,A);
n >>= 1;
}
return B;
}
int main()
{
int n ;
scanf("%d",&n);
int **A;
A = (int**)malloc(2*sizeof(int*));
A[0] = (int*)malloc(2*sizeof(int));
A[1] = (int*)malloc(2*sizeof(int));
A[0][0] = 1, A[0][1] = 1;
A[1][0] = 1, A[1][1] = 0;
A = pow(A,n);
printf("%d",A[1][0]%10007);
return 0;
}
- 给出n个数，找出这n个数的最大值，最小值，和，并且给这n个数排序
输入格式：第一行为整数n，表示数的个数。
第二行有n个数，为给定的n个数，每个数的绝对值都小于10000。
输出格式：输出四行：第一行表示这些数中的最大值，第二行表示这些数中的最小值，第三行表示这些数的和。第四行表示排序好的数组
样例输入：
4
4 3 2 1
样例输出：
4
1
10
1 2 3 4
#include<iostream>
using namespace std;
void sort(int a[],int n)
{
int sum=0,max=a[0],min=a[0];
for(int i=0;i<n;i++)
{
sum+=a[i];
if(max<a[i]) max=a[i];
if(min>a[i]) min=a[i];
}
cout<<max<<endl; cout<<min<<endl; cout<<sum<<endl;
for(int j=0;j<n;j++)
for(int i=0;i<n-1;i++)
{
int temp;
if(a[i]>a[i+1])
{
temp=a[i];
a[i]=a[i+1];
a[i+1]=temp;
}
}
for(int i=0;i<n;i++)
{
cout<<a[i]<<" ";
}
cout<<"\n";
system("pause");
}
int main(void)
{
int n;
cin>>n;
int a[n];
for(int i=0;i<n;i++)
{
cin>>a[i];
}
sort(a,n);
}
- 123321是一个非常特殊的数，它从左边读和从右边读是一样的。输入一个正整数n，编程求所有这样的五位和六位十进制数，满足各位数字之和等于n。（1≤n≤54）
输入格式：输入一行，包含一个正整数n。
输出格式：按从小到大的顺序输出满足条件的整数，每个整数占一行。
样例输入：
52
样例输出：
899998
989989
998899
#include<iostream>
#include<algorithm>
using namespace std;
int ans[1000005];
int main()
{
int n,now,t=0;
cin>>n;
if(n%2==0)//只有偶数才有6位十进制数的可能
{
now=n/2;
for(int i=9;i>=1;i--)//第一位不能为0
{
if(now-i>=0)
{
for(int j=9;j>=0;j--)
{
if(now-i-j>=0)
{
for(int k=9;k>=0;k--)
{
if(i+j+k==now)
{
ans[t++]=i*100000+j*10000+k*1000+k*100+j*10+i;
}
}
}
}
}
}
}
//五位数的情况
int l;
if(n%2==0)
{
l=8;
}
else
l=9;
for(int i=l;i>=0;i=i-2)//先考虑最中间位数的情况，如果n是偶数，则最中间的一定是偶数，如果n是奇数，则中间位为奇数
{
if(n-i>=0)
{
now=(n-i)/2;
for(int j=9;j>=1;j--)//首位不为0
{
if(now-j>=0)
{
for(int k=9;k>=0;k--)
{
if(j+k==now)
ans[t++]=j*10000+k*1000+i*100+k*10+j;
}
}
}
}
}
sort(ans,ans+t);
for(int i=0;i<t;i++)
{
cout<<ans[i]<<endl;
}
system("pause");
}
- 给定一个年份，判断这一年是不是闰年。
当以下情况之一满足时，这一年是闰年：
1.年份是4的倍数而不是100的倍数；
2.年份是400的倍数。
输入格式：输入包含一个整数y(1900≤y≤2100)，表示当前的年份。
输出格式：输出一行，如果给定的年份是闰年，则输出yes，否则输出no。
样例输入：
2013
样例输出：
no
#include<iostream>
using namespace std;
int main(void)//闰年判断
{
int n;
cin>>n;
if(n%4==0&&n%100!=0||n%400==0)
cout<<"yes"<<endl;
else
cout<<"no"<<endl;
return 0;
}
- 杨辉三角形又称Pascal三角形，它的第i+1行是〖(a+b)〗^i的展开式的系数。它的一个重要性质是：三角形中的每个数字等于它两肩上的数字相加。
下面给出了杨辉三角形的前4行：+
1
1 1
1 2 1
1 3 3 1
给出n，输出它的前n行。(1≤n≤34)
输入格式：输入包含一个数n
输出格式：输出杨辉三角形的前n行。每一行从这一行的第一个数开始依次输出：中间使用一个空格分隔。请不要在前面输出多余的空格。
样例输入：
4
样例输出：
1
1 1
1 2 1
1 3 3 1
#include<iostream>
using namespace std;
int main(void)//杨辉三角
{
int n;
cin>>n;
int a[n][n]={0};
for(int i=0;i<n;i++)
{
a[i][0]=1;
a[i][i]=1;
}
for(int i=1;i<n;i++)
for(int j=1;j<i;j++)
{
a[i][j]=a[i-1][j]+a[i-1][j-1];
}
for(int i=0;i<n;i++)
{
for(int j=0;j<=i;j++)
{
cout<<a[i][j]<<" ";
}
cout<<endl;
}
return 0;
}
- 给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。
注意：不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。
输入格式：第一行包含一个整数n。
第二行包含n个非负整数，为给定的数列，数列中每个数都不大于1000。
输出格式：如果输入数列非有序，直接输出不合法信息
如果输入合法，第一行输出新数组长度；第二行输出新数组。
样例输入：
9
1 1 2 2 3 3 4 4 5
样例输出：
5
1 2 3 4 5
#include<iostream>
using namespace std;
void removedupli(int a[],int n)
{
int j=0;
for(int i=0;i<n;i++)
{
if(a[i]!=a[i+1])
a[++j]=a[i+1];
}
cout<<j<<endl;
for(int i=0;i<j;i++)
cout<<a[i]<<" ";
cout<<endl;
}
int main(void)
{
int n;
cin>>n;
int a[n];
for(int i=0;i<n;i++)
{
cin>>a[i];
}
for(int i=0;i<n-1;i++)//判断有序性
{
if(a[i]>a[i+1])
{
cout<<"error"<<endl;
return 0;
}
}
removedupli(a,n);
return 0;
}
- 移除上一题有序数组限制，其他条件不变，保证输入均合法。
#include<iostream>
using namespace std;
void removedupli_pro(int a[],int n)
{
int index=1;
for(int i=1;i<n;i++)
{
for(int j=i-1;j>=0;j--)
{
if(a[i]==a[j])
{
a[i]=-index;
index++;
}
}
}
cout<<n-index+1<<endl;
for(int i=0;i<n;i++)
if(a[i]>0)
cout<<a[i]<<" ";
cout<<endl;
}
int main(void)
{
int n;
cin>>n;
int a[n];
for(int i=0;i<n;i++)
cin>>a[i];
removedupli_pro(a,n);
return 0;
}
- 给定一个数组，它的第i个元素是一支给定股票第i天的价格。如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。（注意你不能在买入股票前卖出股票）
输入格式：第一行包含一个整数n。
第二行包含n个正整数，为给定的数列，数列中每个数都不大于1000。
输出格式：正整数x表示获取到的最大利润
样例输入1：
6
7 1 5 3 6 4
样例输出1：
5
(解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5。)
样例输入2：
5
7 6 5 4 3
样例输出2：
0
(解释：在这种情况下, 没有交易完成, 所以最大利润为 0）
#include<iostream>
using namespace std;
int max_pro(int a[],int n)
{
int max=a[1]-a[0];
for(int i=n-1;i>=1;i--)
for(int j=i-1;j>=0;j--)
{
if(max<a[i]-a[j])
max=a[i]-a[j];
}
if( max <= 0 )
return 0;
return max;
}
int main(void)
{
int n;
cin>>n;
int a[n];
for(int i=0;i<n;i++)
cin>>a[i];
cout<<max_pro(a,n)<<endl;
return 0;
}
- 将上题只允许完成1次交易限制去掉，即：你可以尽可能地完成更多的交易（多次买卖这支股票）。注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
样例输入1：
6
7 1 5 3 6 4
样例输出1：
7
【解释：在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3。】
样例输入2：
5
1 2 3 4 5
样例输出2：
4
【解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。】
#include<iostream>
using namespace std;
int main(void)//贪心算法
{
int n,profit=0;
cin>>n;
int a[n];
for(int i=0;i<n;i++)
cin>>a[i];
for(int i=0;i<n-1;i++)
if(a[i+1]>a[i])
profit+=a[i+1]-a[i];
cout<<profit<<endl;
return 0;
}
- 给定一个非负整数数组，编写一个函数将所有0移动到数组的末尾，同时保持非零元素的相对顺序，要求必须在原数组上操作，不能建立额外的数组。
输入格式：第一行包含一个整数n。
第二行包含n个正整数，为给定的数组，数组中每个数都不大于100。
输出格式：结果数组
样例输入1：
5
0 1 0 3 12
样例输出1：
1 3 12 0 0
#include<iostream>
using namespace std;
void delete0(int a[],int n)
{
int j=0;
for(int i=0;i<n;i++)
{
if(a[i]!=0)
a[j++]=a[i];
}
for(;j<n;j++)
a[j]=0;
for(int i=0;i<n;i++)
cout<<a[i]<<" ";
}
int main(void)
{
int n;
cin>>n;
int a[n];
for(int i=0;i<n;i++)
cin>>a[i];
delete0(a,n);
return 0;
}
这些是第一节数据结构的实验小练习，还是比较简单的，没啥想解释的，不过之后如果之后又比较难得算法我还是会写解析的。这也是我第一次写blog，希望之后能做到周更hh。
下次预告：线性表
如果感觉有帮助，欢迎点赞！
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
