n!的位數

將n!表示成10的次冪，即n!=10^M(10的M次方)，則不小於M的最小整數就是 n!的位數，對該式兩邊取對數，有 M =log10^n!

由公式log(a*b)=loga+logb，可化為：M = log10^1+log10^2+log10^3...+log10^n

最後將得到的M加上1就是n!的位數。(因為是10^M，所以最後位數要+1)

/* n!位數 */
void problem1()
{
	int n, i;
	double d;
	while (scanf("%d", &n))
	{
		if (n == EOF) break;
		d = 0;
		for (i = 1;i <= n;i++) {
			d += (double)log10(i);
		}
		printf("%d\n", (int)d + 1);
	}
	return;
}
 

方法①：其實就是拆分，10可以拆成2*5，所以我們統計所有乘數的因數裡min[ n(2) , n(5) ]的個數即可。但階乘有點特殊的是，5的前面必定有個2（的倍數），故我們求所有乘數的因數裡5的個數即可。

方法②：百度後瞭解的，分享一下：

基於方法①，易得10!裡因數5的個數為2 [ 10/5 ]；

而25!裡因數5的個數為6，這是因為25=5*5，即25多提供了一個5 [ 25/5 + 25/(5*5) ]；

像125=5*5*5，則125多提供了兩個5，所以125!裡因數5的個數為: 31 [ 125/5 + 125/(5*5) + 125/(5*5*5) ]。

故，推導公式如下：

while (N)

{

    N /= 5；

    count += N;

}

/* 求n!末尾0的個數 */
void problem2()
{
	int N, i, mod5, d5, count0 = 0;
	scanf("%d", &N);
        /*  方法①  */
	for (i = 1;i <= N;i++) 
	{
		mod5 = i % 5;
		d5 = i / 5;
		while (mod5 == 0)
		{
			count0++;
			mod5 = d5 % 5;
			d5 /= 5;
		}
	}
        /*  方法②  */
	count0 = 0;
	while (N)
	{
		N /= 5;
		count0 += N;
	}
	printf("%d!的個數 %d\n", N, count0);
}
 

有一隻經過訓練的蜜蜂只能爬向右側相鄰的蜂房，不能反向爬行。請程式設計計算蜜蜂從蜂房a爬到蜂房b的可能路線數。
其中，蜂房的結構如下所示：

【輸入格式】

輸入資料的第一行是一個整數N,表示測試例項的個數，然後是N 行資料，每行包含兩個整數a和b(0<a<b<50)。

【輸出格式】

對於每個測試例項，請輸出蜜蜂從蜂房a爬到蜂房b的可能路線數，每個例項的輸出佔一行。

【樣例輸入】

2
1 2
3 6

 【樣例輸出】

1
3

方法①：簡單粗暴地把上下行可能的走法都實現一次，到達終點就輸出。注意出口設定。

方法②：除了格子1和格子2，其餘數字都是由上個數字走過來或上上個數字走過來，故而累加即可。

/* 一隻小蜜蜂.. */
/* 題目連結 http://acm.hdu.edu.cn/showproblem.php?pid=2044 */
int sum_bees = 0; //一隻小蜜蜂
void Bees(int a1, int a2, int b1, int b2) //遞推,a1起始行，a2起始列，b1終點行，b2終點列
{
	if (a1 == b1 && a2 == b2) { //到達離開
		sum_bees += 1;
		return;
	}
	if (a2 > b2)  return; //剪枝
	if (a1 % 2) //下行
	{
		Bees(a1 - 1, a2 + 1, b1, b2);
		Bees(a1, a2 + 2, b1, b2);
	}
	else { //上行
		Bees(a1 + 1, a2, b1, b2);
		Bees(a1, a2 + 2, b1, b2);
	}
}
void ABee_main()
{
	int a, b, a1, a2, b1, b2;
	int i, j;
	__int64 num[50] = { 0 };
	printf("請輸入起/終點a/b：");
	scanf("%d %d", &a, &b); //3 6  0-1 1-3
	printf("請輸入解法1或2：");
	scanf("%d", &i);
	switch (i)
	{
	case 1:
		printf("解法1：針對上/下列，各自遞推;\n");
                /* 看成是二行X列的陣列 */
		b1 = a % 2;a2 = a / 2; //1 1  
		a1 = b % 2;b2 = b / 2; //0 3
		Bees(a1, a2, b1, b2);
		printf("the num:%d\n", sum_bees);
		break;
	case 2:
		printf("解法2：除了1和2，其餘數字都是由上個數字走過來或上上個數字走過來，故而累加即可；\n");
		num[1] = 1;num[2] = 2;
		for (j = 3;j <= b - a;j++)  num[j] = num[j - 1] + num[j - 2];
		printf("the num:%I64d\n", num[j - 1]);
		break;
	default:
		printf("輸入有誤。");
		break;
	}
}

實現下面的虛擬碼。另外給定a, b, c，求w(a, b, c)的值。

function w(a, b, c):

       if a <=0 or b <=0 or c <=0, then returns:1

       if a >20or b >20or c >20, then returns: w(20,20,20)

       if a < b and b < c, then returns: w(a, b, c-1)+ w(a, b-1, c-1)- w(a, b-1, c)    

       otherwise it returns: w(a-1, b, c)+ w(a-1, b-1, c)+ w(a-1, b, c-1)

問題在於如果直接計算，對於任意一個三元組(a, b, c)，w(a, b, c)可能被計算多次。但對於固定的(a, b, c)，w(a, b, c)其實是個固定的值，沒必要多次計算。所以我們建立一個三維陣列 num[21][21][21] ，在每次if判斷之前先查表，如果 num[a][b][c] 已儲存了計算結果，就直接取出來用，否則就進行之後的遞迴計算，並把結果存在 num[a][b][c] 裡。這樣對於任意(a, b, c)就只會計算一次值，此後再遇到就只是查表而已，單次查詢的複雜度降到O(1)，總的複雜度為O(n^3)，n為資料規模。這種思路學名【記憶化搜尋】。

/* Function Run Fun */
int runfun[21][21][21] = { 0 };
int FunctionRunFun(int a, int b, int c)
{
	if (a <= 0 || b <= 0 || c <= 0)  return 1;
	else if (a > 20 || b > 20 || c > 20) {
		if (runfun[20][20][20] != 0)
		{
			return runfun[20][20][20];
		}
		else
		{
			runfun[20][20][20] = FunctionRunFun(20, 20, 20);
			return runfun[20][20][20];
		}
	}
	else if (a < b&& b < c)
	{
		if (runfun[a][b][c] != 0)
		{
			return runfun[a][b][c];
		}
		else
		{
			runfun[a][b][c] = FunctionRunFun(a, b, c - 1) + FunctionRunFun(a, b - 1, c - 1) - FunctionRunFun(a, b - 1, c);
			return runfun[a][b][c];
		}
	}
	else
	{
		if (runfun[a][b][c] != 0)
		{
			return runfun[a][b][c];
		}
		else
		{
			runfun[a][b][c] = FunctionRunFun(a - 1, b, c) + FunctionRunFun(a - 1, b - 1, c) + FunctionRunFun(a - 1, b, c - 1) - FunctionRunFun(a - 1, b - 1, c - 1);
			return runfun[a][b][c];
		}
	}
}
int main()
{
	int a, b, c;
	scanf("%d %d %d", &a, &b, &c);
	printf("%d\n", FunctionRunFun(a, b, c));
	return 0;
}

飯卡

電子科大本部食堂的飯卡有一種很詭異的設計，即在購買之前判斷餘額。如果購買一個商品之前，卡上的剩餘金額大於或等於5元，就一定可以購買成功（即使購買後卡上餘額為負），否則無法購買（即使金額足夠）。所以大家都希望儘量使卡上的餘額最少。
某天，食堂中有n種菜出售，每種菜可購買一次。已知每種菜的價格以及卡上的餘額，問最少可使卡上的餘額為多少。

【輸入格式】

多組資料。對於每組資料：
第一行為正整數n，表示菜的數量。n<=1000。
第二行包括n個正整數，表示每種菜的價格。價格不超過50。
第三行包括一個正整數m，表示卡上的餘額。m<=1000。
n=0表示資料結束。

【輸出格式】

對於每組輸入,輸出一行,包含一個整數，表示卡上可能的最小余額。

【樣例輸入】

1
50
5
10
1 2 3 2 1 1 2 3 2 1
50
0

【樣例輸出】

-45
32

揹包問題。把可用餘額減去5，對菜價進行降序排序，從第二高價的菜品開始搜。

狀態轉移方程為 dp[ j ] = max(dp[ j ], dp[ j - v[ i ]] + v[ i ])。前者是不買菜，後者是買菜（ j - v[ j ] 即買了菜後的餘額），此時已買的菜的總價值dp[ j ]就要加上此次購買的單價v[ j ]。兩者之間取價值最大的情況。

最後把買的菜的總價值加上最貴的菜的價值，就是此次購買的金額，則餘額也就可求了。

/* 飯卡 */
void MealCard()
{
	int i, j, n, v[1024], money, dp[1024];//菜數、菜價格、餘額
	printf("菜數：");
	scanf("%d", &n);
	printf("依次菜價：\n");
	for (i = 0;i < n;i++) scanf("%d", &v[i]);
	printf("餘額：");
	scanf("%d", &money);
	if (money < 5)  printf("餘額不足!");
	sort(v, v + n, greater<>()); //價格降序
	memset(dp, 0, sizeof(dp)); //初始化陣列
	for (i = 1;i < n;i++)
		for (j = money - 5;j >= v[i];j--)
			dp[j] = max(dp[j], dp[j - v[i]] + v[i]);
	printf("the  balance :%d\n", money - dp[money - 5] - v[0]);
}