E D R , A S I H C RSS

Pascal Triangle

ํŒŒŠค˜ ‚ฐํ˜• •Œณ ฆฌฆ˜

  • ฉฐ  „— งˆฐœ žฃŒตฌกฐ˜ ฒซฒˆงธ ˆ™ œ˜€ฃ ? ‹คฅธ „“ค„ ‹คฅดฒŒ งœ‹  „ด žˆœ‹œ‹คฉด „œกœ ˜ฒฌ„ ‚˜ˆ  ณด•˜œฉด ํ•ฉ‹ˆ‹ค.

žฌ€ ํ˜ธถœ„ ดšฉํ•œ ฐฉฒ• - by ธˆ˜

~cpp 
const int pas(const int &m,const int &n)
{
    if(m==n || n==1) // ํ–‰ —ดด ฐ™‚˜(€žฅ ˜คฅธชฝด‚˜) —ดด 1•ŒŠ” 1ถœ ฅ
        return 1;
    else
        return pas(m-1,n-1)+pas(m-1,n); // žฌ€ํ˜ธถœ
}

  • ณด‹œŠ” ฐ”™€ ฐ™ด.. กธ „‹จํ•ฉ‹ˆ‹ค.
  • but.. ˆซž€ กฐธˆงŒ ปค ธ„.. ต‰žฅํžˆ ˜คž˜ ฆฝ‹ˆ‹ค. 01ํ•™ฒˆ ด„ ํ˜ธตฐด 32ํ–‰  •„ „–ดดค„•Œ ฆฐ ‹œ„€ 100ดˆ€ „˜—ˆ‹ค ํ•ฉ‹ˆ‹ค. žฌ€ํ˜ธถœ..  ˆ˜ žˆœฉด “ฐ€ ง™‹œ‹ค.
  • ด •Œณ ฆฌฆ˜€ ‹œ„„ ํฌƒํ•˜ฉด„œ ณต„„ „ธ •Œณ ฆฌฆ˜ดฒ ฃ ?
  • ’ค ฒƒ„ —†ด € ธ •Œณ ฆฌฆ˜ -- „ ํ˜ธ.

recursive -zennith

~cpp 
unsigned long int P(int row, int col) {
	/* —ด˜ ฐ’ด ํ–‰ณด‹ค ํด ฒฝšฐ ข…ฃŒ */
	if(row < col)
		exit(0);

	/* –ด„ ฐ’„ €‚ฌํ•˜—ฌ, ฒซฒˆงธ —ดด 1ด‚˜ ํ–‰ —ดด ฐ™€ฒฝšฐ 1„ ฆฌํ„ด */
	if(col == 1 || row == col)
		return 1;

	/* ทธ ‡€ •Š€ ฒฝšฐ ํ–‰ —ด„ 1”ฉ ฐ†Œํ•ด„œ žฌ€ ํ˜ธถœํ•œ ฐ’
	ํ–‰งŒ 1 ฐ†Œ‹œœ žฌ€ ํ˜ธถœํ•œ ฐ’„ ”ํ•ด„œ ฆฌํ„ด */
	return P(--row, --col) + P(row, ++col);
}

  • ‹จˆœํžˆ ํ”„ฆฐํŠธ˜ ‚ดšฉ„ ˜ฎ„ ฟ..

™  ฐฐ—ด„ ดšฉํ•œ ฐฉฒ• - by ธˆ˜

~cpp 
typedef unsigned long ulong;

ulong Pascal_Triangle(int m,int n)
{
	ulong **Array=new ulong*[m];	// 2ฐจ› ™  ฐฐ—ด ํ• ‹

	for(int i=0;i<m;i++)
		Array[i]=new ulong[i+1];	// nํ–‰—Š” nฐœ˜ —ดงŒ ํ• ‹˜ฒŒ

	for(i=0;i<m;i++)
	{
		for(int j=0;j<=i;j++)
		{
			if(i==j || j==0)		// ํ–‰ —ดด ฐ™‚˜ —ดด 1•Œ
				Array[i][j]=1;		// (ฐฐ—ด€ 0€„‹œž‘ํ•˜€กœ 0ดํ–ˆŒ) 1˜ ฐ’„ คŒ
			else
				Array[i][j]=Array[i-1][j-1]+Array[i-1][j];
						// ทธ ™ธ˜ ฒฝšฐ—Š” ณต‹„ ”ฐฅธ‹ค.
		}
	}

	ulong return_value=Array[m-1][n-1];
	// ›ํ•˜Š” ฐ’ ฆฌํ„ด(—ญ‹œ ฐฐ—ด€ 0€„‹œž‘ํ•˜€กœ ํ•˜‚˜”ฉ „œ)

	if(Array)	// Array 2ฐจ› ฐฐ—ดด ํ• ‹˜—ˆ„•Œ
	{
		for(i=0;i<m;i++)
		{
			if(Array[i])
				delete [] Array[i];		// €›Œ €‹ค.(—ด)
		}
	}

	delete [] Array;		// €›Œ €‹ค.(ํ–‰)

	return return_value;
}

  • ” ณดธฐ—„ žฌ€ํ˜ธถœณด‹คŠ” ณตžกํ•˜ฃ ?
  • ทธŸฐฐ.. †„Š” ํ™•‹คํžˆ  ฆ…‹ˆ‹ค. ช‡„ „–ด„ ฆ‰‹œฆ‰‹œ ‚˜˜คŠ”..
  • ด •Œณ ฆฌฆ˜€ ฉ”ชจฆฌ ” “ฐฉด„œ †„ ‚ดฆฐ ฐฉฒ•ดฒ ฃ ?
  • žฐ”กœ งœฉด € ” ‰ฌšธฐ™„—ฌ. ฉ”ชจฆฌ ƒˆŠ” •ํ•˜€ •Š•„„ ˜‹ˆ..
  • ‹คฅธ ข‹€ ฐฉฒ•ด žˆœ‹œฉด —ฌธฐ‹ค  –ด‹œธฐ ฐ”ž‹ˆ‹ค.
  • ใ…ก.ใ…ก €..ฐ™‹ค.. --„ ํ˜ธ

dynamic allocation -zennith

~cpp 
int P(int row, int col) {
	/* €ˆ˜ „ –ธ€ */
	int i, j, temp;

	/* —ฐ‚ฐ„ œ„ํ•ด ดค‘  •ˆ˜ํ˜• ํฌธํ„„ –ธ */
	int ** buffer;

	/* —ดด ํ–‰ณด‹ค ํด ฒฝšฐ ข…ฃŒ */
	if(col > row)
		exit(0);

	/* buffer— ํ–‰งŒํ˜  •ˆ˜ํฌธํ„ฐํ˜•„ ํ• ‹ฐ›•„ Œ€ž… */
	buffer = malloc( row * sizeof(int *) );

	for(i = 0; i < row; i++) {
		/* ฐฐ˜  •ˆ˜ ํฌธํ„—  •ˆ˜ ฐฐ—ด„ ํ• ‹ํ•œ‹ค */
		*(buffer + i) = (int *)malloc( (i + 1) * sizeof(int) );

		/* ํ• ‹„ ‹คํŒจํ–ˆ„ •Œ */
		if(*(buffer + i) == NULL) {

			/*  € —ฌํƒœŒ€ ํ• ‹ํ•œ  •ˆ˜ ฐฐ—ด„ ฐ˜ํ™˜ ํ•˜ณ  */
			for(j = 0; j <= i; j++) {
				free(*(buffer + j));
			}

			/*  •ˆ˜ ํฌธํ„ฐฐ—ด„ ฐ˜ํ™˜ ํ•œ ํ›„ */
			free(buffer);

			/* ข…ฃŒํ•œ‹ค */
			exit(0);
		}
	}

	/* —ฐ‚ฐ€ */
	for(i = 0; i < row; i++) {
		for(j = 0; j <= i; j++) {
			/* —ดด 1ด‚˜ ํ–‰ —ดด ฐ™€ ฒฝšฐ, 1„ Œ€ž… ํ•œ‹ค */
			if(j == 0 || j == i) {
				*(*(buffer + i) + j) = 1;
				continue;
			}

			/* ทธ ‡€ •Š€ ฒฝšฐ  „ ํ–‰(i - 1)  „ —ด(j - 1)˜ ฐ’,
			 „ ํ–‰(i - 1) ™ —ด(j) ˜ ฐ’„ ”ํ•ด„œ Œ€ž…ํ•œ‹ค */
			*(*(buffer + i) + j) =
				*(*(buffer + i - 1) + j - 1) + *(*(buffer + i - 1) + j);
		}
	}

	/* „‚ฐํ•œ ฒฐฐ’„ ž„‹œ€ˆ˜—  €žฅํ•œ‹ค */
	temp = *(*(buffer + row - 1) + col - 1);

	/*  €  •ˆ˜ ฐฐ—ด„ ฐ˜ํ™˜ํ•˜ณ  */
	for(i = 0; i < row; i++)
		free(*(buffer + i));

	/*  •ˆ˜ ํฌธํ„ฐฐ—ด„ ฐ˜ํ™˜ํ•œ‹ค */
	free(buffer);

	/* ž„‹œ€ˆ˜—  €žฅํ•œ ฐ’„ ฆฌํ„ด */
	return temp;
}

  • •„ง ฐœ„ ํ•  ด ํ•œ ‘ ตฐฐ žˆŠ”ฐ.. ตฌ€ —ฌธฐ— ˜ฌฆฐ ดœ Š”  €ฒŒ Null pointer assignment —Ÿฌ€ ‚˜„œ.. —Ÿฌ‚œ™œ ˜ฌฆฌŠ”ฐ. ณ  ํ•˜‹œฉด ํ• ง —†€งŒ.. ํ˜‹œ ํ˜œ•ˆœกœ ‹œ›ํ•˜ฒŒ ฐ”Ÿฌ‹ค „ € ํ•ด‹œฉด ฐ‚ฌํ•˜ฒ Šต‹ˆ‹ค.
  • ํ•ดฒฐํ–ˆŠต‹ˆ‹ค. ฌธ œ —†ด Œ•„€Š”ตฐš”.. —ญ‹œ ํฌธํ„Š” –ด ตณ  –ด ค›Œ..

ฒซ„€„ญ‰ „‚ฐํ•˜Š” ฐฉฒ•

~cpp 
// ฒซํ–‰€„ฐ nํ–‰Œ€ „‚ฐํ•˜Š” ฐฉฒ•„ ํ†ตํ•ด
// ํŒŒŠค˜ ‚ฐํ˜•˜ nํ–‰ m—ด˜ ฐ’„ ตฌํ•˜Š” ํ•จˆ˜ (34ํ–‰ Œ€ „‚ฐ €Šฅ)
unsigned long PascalTriangle1(int n, int m)
{
	if(n<0 || n>35 || m<0 || m>n)	// ํ–‰ —ด˜ ฐ’ด ž˜ชปœฒฝšฐ 0„ ฆฌํ„ด
		return 0;
	if(n==1 || n==2)	// 1ํ–‰ ˜Š” 2ํ–‰€ ชจ‘ 1 ด€กœ 1„ ฆฌํ„ด
		return 1;

    // 2ฐœ˜ ฐฐ—ด„ ‚ฌšฉํ•˜—ฌ „‚ฐ„ ํ•œ‹ค
	// ํ•˜‚˜˜ ฐฐ—ด— 2ํ–‰„  €žฅํ•œ ํ›„
	// ทธ ฐฐ—ด„ ‚ฌšฉํ•ด 3ํ–‰„ „‚ฐํ•ด ‚˜จธ€ ฐฐ—ด—  €žฅํ•˜ณ 
	// ‹ค‹œ 3ํ–‰ด  €žฅœ ฐฐ—ด„ ‚ฌšฉํ•ด 4ํ–‰„ „‚ฐํ•ด„œ
	// 2ํ–‰ด  €žฅ˜–ด žˆ˜ ฐฐ—ด—  €žฅํ•˜ณ 
	// „† ด™€ฐ™€ ‹œกœ nํ–‰ Œ€ „‚ฐํ•œ‹ค

	unsigned long *row[2];	// 2ฐœ˜ ฐฐ—ด˜ ํฌธํ„ฐ
	row[0]=new unsigned long[40];	// ตœŒ€ 40—ดŒ€  €žฅํ•  ˆ˜ žˆ„ก ฉ”ชจฆฌ ํ• ‹
	row[1]=new unsigned long[40];
	row[0][0]=row[0][1]=1;	// 2ํ–‰„  €žฅํ•œ‹ค
	int current=0;	// 2ฐœ˜ ฐฐ—ด ค‘ „‚ฐค‘ธ ฐฐ—ด„ ‚˜ํƒ€‚ดŠ” €ˆ˜

	for(int i=3;i<=n;i++)	// 3ํ–‰€„ฐ nํ–‰Œ€ „‚ฐ
	{
		current=!current;	// „‚ฐํ•  ฐฐ—ด„ ฐ”ฟˆ

		row[current][0]=1;	// ฒซฒˆงธ —ด€ ํ•ญƒ 1
		row[current][i-1]=1;	// งˆ€ง‰ —ด„ ํ•ญƒ 1

		for(int j=1;j<i-1;j++)	// ‚˜จธ€ —ด„ „‚ฐ
			row[current][j]=row[!current][j-1]+row[!current][j];
	}

	// nํ–‰ m—ด˜ ฐ’„ ณด€
	unsigned long temp=row[current][m-1];
	delete[] row[0];	// ํ• ‹ํ–ˆ˜ ฉ”ชจฆฌ ํ•ด œ
	delete[] row[1];
	return temp;	// ณด€ํ•ด‘” nํ–‰ m—ด˜ ฐ’„ ฆฌํ„ด
}

กฐํ•ฉ˜ ˆ˜ ดšฉํ•œ ฐฉฒ•

~cpp 
// กฐํ•ฉ˜ ˆ˜ „‚ฐํ•˜Š” ฐฉฒ•„ ํ†ตํ•ด
// ํŒŒŠค˜ ‚ฐํ˜•˜ nํ–‰ m—ด˜ ฐ’„ ตฌํ•˜Š” ํ•จˆ˜ (17ํ–‰Œ€ „‚ฐ €Šฅ)
unsigned long PascalTriangle2(int n, int m)
{
	if(n<0 || n>18 || m<0 || m>n)	// ํ–‰ —ด˜ ฐ’ด ž˜ชปœ ฒฝšฐ 0„ ฆฌํ„ด
		return 0;
	if(n==1 || n==2)	// 1ํ–‰ ˜Š” 2ํ–‰€ ชจ‘ 1 ด€กœ 1„ ฆฌํ„ด
		return 1;
	// 5ํ–‰ 1—ด 5ํ–‰ 5—ด, 5ํ–‰ 2—ด 5ํ–‰ 4—ด “€
	// ฐ’ด ฐ™€งŒ 5ํ–‰ 1—ดด‚˜, 5ํ–‰ 2—ดด „‚ฐด „‹จํ•˜—ฌ
	// „‚ฐค‘— ˜ค„ํ”Œกœšฐ€ –ด‚˜Š” ฒฝšฐ „ˆ˜ žˆ–ด
	// ”š งŽ€ ํ–‰„ „‚ฐํ•  ˆ˜ žˆ‹ค
	// 5ํ–‰ 5—ดด‚˜, 5ํ–‰ 4—ด ฐ™€ ฒƒ„ 5ํ–‰ 1—ดด‚˜, 5ํ–‰ 2—ดกœ
	// ฐ”ฟ”„œ ‹ค‹œ ํ˜ธถœํ•ดŠ” €„ด‹ค
	if(m>n/2+n%2)
		return PascalTriangle2(n,n-m+1);

	unsigned long x=1,y=1, p;

    // (n-1)!/((n-1)-(m-1))! „ „‚ฐ
	p=n-1;
	for(int i=0;i<m-1;i++)
	{
		x*=p;
		p--;
	}

	// (m-1)! „ „‚ฐ
	for(p=m-1;p>=2;p--)
		y*=p;

	return x/y;	// (n-1)!/(((n-1)-(m-1))!*(m-1)!) „ ฆฌํ„ด
}
Valid XHTML 1.0! Valid CSS! powered by MoniWiki
last modified 2021-02-07 05:24:00
Processing time 0.0193 sec