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.0330 sec