ACM Steps_Chapter Three_Section1

超级楼梯

#include<iostream>
using namespace std;
int main()
{
	int n;
	int T;
	int a[41];
	a[1]=0;
	a[2]=1;
	a[3]=2;
	for(int i=4;i<=40;i++)
	{
		a[i]=a[i-1]+a[i-2];
	}
	cin>>T;
	while(T--)
	{
		cin>>n;
		cout<<a[n]<<endl;
	}
	system("pause");
	return 0;
}

一只小蜜蜂..

#include<iostream>
using namespace std;
int main()
{
	int T;
	long long  a[51];
	a[1]=1;
	a[2]=2;
	for(int i=3;i<=50;i++)
	{
		a[i]=a[i-1]+a[i-2];
	}
	cin>>T;
	while(T--)
	{
		int A,B;
		cin>>A>>B;
		cout<<a[B-A]<<endl;
	}
	system("pause");
	return 0;
}

骨牌铺方格

#include<iostream>
using namespace std;
int main()
{
	int n;
	long long int a[51];
	a[1]=1;
	a[2]=2;
	for(int i=3;i<=50;i++)
	{
		a[i]=a[i-1]+a[i-2];
	}
	while(cin>>n)
		cout<<a[n]<<endl;
	system("pause");
	return 0;
}
	

母牛的故事

#include<iostream>
using namespace std;
int main()
{
	int n;
	long long int a[55];
	a[1]=1;
	a[2]=2;
	a[3]=3;
	a[4]=4;
	for(int i=5;i<=54;i++)
	{
		a[i]=a[i-1]+a[i-3];
	}
		
	while(cin>>n&&n!=0)
		cout<<a[n]<<endl;
	system("pause");
	return 0;
}

悼念512汶川大地震遇难同胞——重建希望小学

#include<iostream>
using namespace std;
int main()
{
	int T;
	long long int a[31];
	a[1]=1;
	a[2]=3;
	for(int i=3;i<=30;i++)
	{
		a[i]=a[i-1]+2*a[i-2];
	}
	cin>>T;
	while(T--)
	{
		int n;
		cin>>n;
		cout<<a[n]<<endl;
	}
	system("pause");
	return 0;
}

Tiling_easy version

#include<iostream>
using namespace std;
int main()
{
	int T;
	long long int a[31];
	a[1]=1;
	a[2]=3;
	for(int i=3;i<=30;i++)
	{
		a[i]=a[i-1]+2*a[i-2];
	}
	cin>>T;
	while(T--)
	{
		int n;
		cin>>n;
		cout<<a[n]<<endl;
	}
	system("pause");
	return 0;
}

不容易系列之(3)—— LELE的RPG难题

/*
找规律：当n=1时，f(1)=3{r,p,g}
当n=2时，在f(1)后添加和最后一个字符不同的字符
即：f(2)={rp,rg,pr,pg,gr,gp}
当n=3时，在f(2)的后面添加和最后一个不同的字符，
可以得出两组{rpg,rpr,rgp,rgr,prg,prp,pgr,pgp,grp,grg,gpr,gpg}
正确的一组：{rpg,rgp,prg,pgr,grp,gpr}
不正确的一组：{rpr,rgr,prp,pgp,grg,gpg}
不正确的用于计算f(4),因为在不正确的后面加上一个字符，可能就是正确的了。
当n=4时，用n=3时正确的派生出
{rpgp,rpgr,rgpg,rpgr,prgr,prgp,pgrg,pgrp,grpr,grpg,gprp,gprg}
正确的一组是：{rpgp,rgpg,prgr,pgrg,grpr,gprp}
不正确的一组是：{rpgr,rpgr,prgp,pgrp,grpg,gprg}
用n=3不正确的派生出{rprp,rprg,rgrg,rgrp,prpr,prpg,pgpg,pgpr,grgr,grgp,gpgr,gpgp}
它们都是正确的！
观察不正确的，n=3时不正确的一组是由n=2正确的一组派生出来的，
这一个不正确的组派生出来的用于n=4派生正确的组(全部正确f(n-2)*2)，
n=4时不正确的一组是由n=3正确的一组派生出来的，这一组用来派生n=5正确的，
而且全部正确，依次类推
得到公式f(1)=3,f(2)=6,f(3)=6,f(n)=f(n-1)+2*f(n-2)
*/


#include<iostream>
using namespace std;
int main()
{
	int n;
	long long int a[51];
	a[1]=3;
	a[2]=6;
	a[3]=6;
	for(int i=4;i<=50;i++)
	{
		a[i]=a[i-1]+2*a[i-2];
	}	
	while(cin>>n)
	{
		cout<<a[n]<<endl;
	}
	system("pause");
	return 0;
}

Children’s Queue

/*
1、递归公式
1)m
2)mff

3)mfff

a:安全序列后加ff或者m，结果仍然安全。

b:不安全序列后加ff可使其安全，虽然mf加f也能得到安全序列，但与a情况重复。

故：公式a[n]=a[n-1]+a[n-2]+a[n-4];
*/
/*
安全序列的f至少有2个连在一起
 * 那么可以用倒推找到安全后缀为：
 * （1）m
 * （2）mff
 * （3）mfff
 * （4）......
 * 在看其他大牛的博客时，觉得他们有点说不清楚，我起初也看不明白为什么安全序列
 * 一定有 m 在前面
 * 
 * 但后来发现了一样东西： 
 *      （1）mmf|ff：前面的mmf显然不是安全序列，但加上ff后就是安全序列，所以 
 *              “不安全=>安全”
 *          由于这个地方的不同与以前的题目有差别，所以我们可以做相同的转化，使得
 *      （2）mmf|ff -> m|mfff 这样我们就可以确保能 
 *              “安全=>安全”，
 *          从而可以得到上面的后缀序列
 * 
 * 递推式：dp[n] = dp[n-1] + dp[n-3] + dp[n-4] + ... + dp[1]
 *        因为  dp[n-2] = dp[n-3] + dp[n-5] + dp[n-6] + ... +dp[1]
 *        所以  dp[n] = dp[n-1] + dp[n-4] + dp[n-2]
 */


#include<iostream>
#include<cstdio>
using namespace std;
int a[1001][101]={0};
void add(int n)
{
    int k=0,j;
    for(j = 1;j<101;j++)
    {
        k += a[n-1][j] + a[n-2][j] + a[n-4][j];
        a[n][j] = k%10000;
        k = k/10000;
       // printf("%d",k);
    }
    while(k)
    {
        a[n][j++] = k%10000;
        k = k/10000;
    }

}
int main()
{
    a[1][1] = 1;
    a[2][1] = 2;
    a[3][1] = 4;
    a[4][1] = 7;
    int n,i;
    for(i = 5;i<1001;i++)
    {
        add(i);
    }
    while(cin>>n)
    {
        for(i = 100;i > 0;i--)
        {
            if(a[n][i]!=0)break;
        }
        printf("%d",a[n][i]);
        for(i=i-1;i>0;i--)
        {
            printf("%04d",a[n][i]);
        }
        printf("\n");
    }
    return 0;
}