階加演算法代碼
#include<stdio.h>
#define N 50 /*可以是任意一個數的階乘，當然要計算機能夠存的下*/
int main()
{
int a[100], l=0, i, j;
for(i=0; i<100; i++)
a[i]=0;
a[0]=1;
for(i=2; i<=N; i++)
{
for(j=0; j<=l; j++)
a[j] *= i;
l+=3;
for(j=0; j<l; j++)
if(a[j]>9)
{
a[j+1]+=a[j]/10;
a[j] %=10;
}
while(a[l]==0) l--;
}
for(i=l; i>=0; i--)
printf("%d", a[i]);
printf("\n");
}
看了 樓下兩個 用int 存儲 50！
感覺有點不可思議， 至少應該用double啊，用double雖然不能保證精度，但至少可以很接近結果。
3樓的 一句話：「老師說過，可以自已定義一個類型來表示更大的數。。。」
自己是可以定義，你可以定義任意類型。只不過需要你自己來實現。 50！這種問題 就相當於 大數 的操作。
網上可以下載到大樹類， 支持 大數的+ - * / 開平方， 開根號，（幾乎所有math里的函數）...。
B. 1到100的階乘代碼
給你100!
#include<stdlib.h>
#include<iostream.h>
#include<iomanip.h>
const int N=100;
int compute(unsigned int *s,int n)//s用來存儲一次的計算結果,n為本次計算的乘數,函數返回結果中有效數據的節數
{
unsigned long p; //暫時存放一節的結果
unsigned long more=0;//一次乘法的進位
int i; //循環變數
static int m=1;//存放結果中的節數,三位一節
static int q=0;//存放結果中最後為零的節數
//計算本次的結果
for(i=q;i<m;i++)
{
p=(long)s[i]*(long)n+more;
more=p/N;
s[i]=p-more*N;
}
//計算結果中最後為零的節數
while(s[q]==0)
q++;
//處理最高位
for(more=p/N;more;)
{
p=more;
more=p/N;
s[i++]=p-more*N;
m++; //有效節數增一
}
return m; //返回有效節數
}
void main()
{
unsigned int *s; //存放結果
int i; //循環變數
int m; //存放節數
int n; //求n的階乘
cout<<"請輸入一個正整數<0----100>:";
cin>>n;
if(n<0)
{
cout<<"輸入數據錯誤!"<<endl;
return;
}
else if(n==0)
{
cout<<"0!==1"<<endl;
return;
}
//初始化s
s=(unsigned int *)malloc(n*sizeof(s)*10);
for(i=1;i<n;i++) s[i]=0;
s[0]=1;
//計算結果
for(i=2;i<=n;i++)
m=compute(s,i);
while(s[m]==0)
m--;//過濾掉前面的零
//輸出結果
cout<<n<<"!=="<<s[m--];//最高一節
int num=1;
for(i=m;i>=0;i--)
{
num++;
cout<<','<<setw(3)<<setfill('0')<<s[i];
if((num%10)==0) cout<<endl;
}
cout<<endl;
//釋放空間
free(s);
}
JAVA的函數是一樣的.可惜JAVA的編碼我不會寫了.
C. 階乘的公式是什麼
n!=1×2×3×...×n。階乘亦可以遞歸方式定義：0!=1，n!=(n-1)!×n。
亦即n!=1×2×3×...×n。階乘亦可以遞歸方式定義：0!=1，n!=(n-1)!×n。
資料來源：階乘_網路
D. 階乘的程序和演算法
沒說要什麼語言編寫的，我給你一個Java的：
public class Factorial
{ public static int factorial(int x)
{
if (x < 0)
{
throw new IllegalArgumentException("x must be>=0");
}
int fact = 1;
for(int i = 2; i <= x; i++)
{
fact *= i;
}
return fact;
}
public static void main(String args[])
{
System.out.print(factorial(10));
}
}
E. python中n的階乘的演算法
我的代碼是
#encoding=utf-8
s=1
n=int(input("請輸入一個整數n:"))
for i in range(1,n+1):
s=s*i
print(n,"!=",s)
結果：
python3 a.py
請輸入一個整數n:5
5 != 120
F. 階乘的公式是怎樣的
程序源代碼：
/**
*計算大數的階乘，演算法的主要思想就是將計算結果的每一位用數組的一位來表示：如要計算5!，那麼首先將
*(1) a[0]=1，然後a[0]=a[0]*2，a[0]=2，
*(2) a[0]=a[0]*3，a[0]=6
*(3) a[0]=a[0]*4，a[0]=24，此時a[1]＝2，a[0]＝4
*/
public class Factorial
{
static int a[] = new int [10000];
static void factorial(int n)
{
for(int i=2; i< a.length; i++)
a[i] = 0; //將數組元素初始化
a[0] = 1; //用數組的一項存放計算結果的位數
a[1] = 1; //將第一項賦值為一
for(int j= 2; j <= n; j++)
{
int i=1;
int c = 0; //c表示向高位的進位
for(; i <= a[0]; i++)
{
a[i] = a[i] * j + c;//將來自低位的計算結果和本位的結果相加
c = a[i] / 10;
a[i] = a[i] % 10;
}
for(; c != 0; i++)
{
a[i] = c%10;
c = c / 10;
}
a[0] = i - 1;
G. c語言的求n的階乘的程序代碼
int f(int n)
{
if(n==1)
return 1;
else
return n*f(n-1);
}
這個是經典的迭代程序例子。
H. 求解：圖論中常見的最短路徑演算法有幾種都是什麼
主要是有三種、、
第一種是最直接的貪心dijkstra演算法、、可以利用堆數據結構進行優化、、缺點就是不能求有負權的最短路與判斷負環、、
第二種是bellman-ford演算法、、根據鬆弛操作的性質是可以來判斷負環的、、時間復雜度是O(nm)的、、
第三種是SPFA演算法、、把他單獨拿出來作為一種演算法並不是非常好的、、他的實質應該是上面的bellman-ford演算法的隊列優化時間復雜度更低、O(KE)、K的值約等於2、、