More Related Content
Similar to 2012 Ds D0 01 Pdf
Similar to 2012 Ds D0 01 Pdf (20)
2012 Ds D0 01 Pdf
- 1. ํ ๋ช
D0
์กฐ์ profile
20093447 : ๊น๋ํ
20113311 : ์ฅ๋๊ท
20093489 : ์กํ์ค
20113324 : ์ต์์
- 2. ๊ณผ ์ ์ ํ ์ผ ์ง
์ด๋ฆ: 20์์ : ์๋ฃ๊ตฌ์กฐ 01๋ถ๋ฐ D0์กฐ
093447 ๊น๋ํ ,20093489 ์กํ์ค ,20113324 ์ต์์ ,20113311 ์ฅ๋๊ท
๊ณผ์ ์ํ๊ธฐ๊ฐ: 14์ผ 5๋ฒ ๋ชจ์ ์ด 10์๊ฐ
I. ๊ณํ์ ์์ฑ
โ ์ฐ๊ตฌ์ ๋ชฉ: ํ์ค์นผ์ ์ผ๊ฐํ
โก์ฐ๊ตฌ๋ฐฐ๊ฒฝ: Array์ ๋ํ ์ดํด
โข์ฐธ๊ณ ์๋ฃ: Fundamentals of Data Structures in C
๊ตฌ๊ธ๊ฒ์ , ์ฑ
(์ดํ๊ฐ์ Cํ๋ก๊ทธ๋๋ฐ)
์๊ฐ ๊ณต๊ฐ ๋ณต์ก๋ ์ฐธ๊ณ :
http://kin.naver.com/qna/detail.nhn?d1id=1&dirId=1040101&docId=68494777&qb
=U3BhY2UgY29tcGxleGl0eQ==&enc=utf8§ion=kin&rank=3&search_sort=0&sp
q=0
II. ๋ชฉ์ฐจ
- ์๋ฌด๋ถ๋ด์ ๋ํ์ฌ ( 3์ชฝ )
- ์๊ณ ๋ฆฌ์ฆ ์์๋ ( 4์ชฝ )
- ๊ณํ์ ์คํ ( 5~10์ชฝ )
- ์๊ฐ,๊ณต๊ฐ ๋ณต์ก๋์ ๊ณ์ฐ ( 11์ชฝ )
- ๊ณผ์ ๋ฅผ ๋ง์น๋ฉด์( ๋ง์ง๋ง ์ชฝ )
- 3. โป ์๋ฌด ๋ถ๋ด์ ๋ํ์ฌ
์กฐ์ฅ : ๊น๋ํ
๋ณด๊ณ ์ ์์ฑ, ์ต์ข
์ข
ํฉ, ํ๋ก๊ทธ๋จ ์ค๋ช
์.
์๊ณ ๋ฆฌ์ฆ : ์ฅ๋๊ท
์์ฐ์์ ๊ณ์ฐ ์๋ฆฌ๋ฅผ ํ์
ํ์ฌ ํ๋ก๊ทธ๋จ์ ๋์
ํ๋ ์ญํ .
์ฝ๋ฉ : ๊น๋ํ
ํ๋ก๊ทธ๋จ์ ๋ํ์ฌ ๊ตฌ์กฐ ๊ฐ์ ๋ฐ ๋ฌธ์ ์ ํด๊ฒฐ.
์๋ฃ๊ฒํ ๋ฐ ์ค์ผ์ค : ์กํ์ค
ํ ๋ก ๊ณํ ๋ฐ ์ค์ผ์ค ๊ด๋ฆฌ ์ค๋น๋ ์๋ฃ ์ฌ๊ฒํ .
๊ฒ์ ๋ฐ ํ ์์ข
ํฉ : ์ต์์
ํ ์ ํ ๋ด์ฉ ๊ธฐ๋ก ๋ฐ ๋ฌธ์ ๋ฐ ๊ถ๊ธ์ ์กฐ์ฌ.
- 5. ์ํ 1์ผ์ฐจ (3/6 ํ)
๊ฐ์์๊ฐ์ 4,5๋ช
์ฉ ์กฐ๋ฅผ ๊ตฌ์ฑํจ. ์กฐ์๋ค ๊ฐ๊ฐ์ ํฌ์ง์
์ ์ ํ๊ณ ,
๊ธฐ๋ณธ์ ์ธ ๊ณผ์ ์ ๋ํ ์ดํด๋ฅผ ์ํด ๊ฐ์ ์ฃผ์ (ํ์ค์นผ์ผ๊ฐํ)์ ๋ํ
์ฌ ์ฐ๊ตฌํ๊ธฐ๋กํจ. ๋ค์ ๊ฐ์์๊ฐ์ด ๋๊ธฐ์ ์ ์กฐ์๋ผ๋ฆฌ ๋ชจ์ฌ ๊ณผ์ ์
๋ํ์ฌ ๋ฏธ๋ฆฌ ํ ์ ํ๊ณ , ์ข
ํฉํด ๋ณด๊ธฐ๋ก ํจ.
์ํ 2์ผ์ฐจ (3/8 ๋ชฉ)
๊ฐ์ธ๋ณ๋ก ๊ณผ์ ์ ๋ํ์ฌ ์ฐ๊ตฌ๋ฅผ ํ๊ณ , ๊ธฐ๋ณธ์ ์ธ ์๊ณ ๋ฆฌ์ฆ์ ์ ์ํ
์ฌ, ๊ฐ์ฅ ๊ธฐ๋ณธ์ด ๋๋ ์์ค๋ฅผ ๋ง๋ค์์. ์์ค๋ ์ฃผ์ด์ง ์กฐ๊ฑด์ ๋ง์กฑ
ํ๋ ๋ชจ๋ ๊ฐ(n=1000)์ ์ฐ์ฐํ๊ณ , ๊ทธ ๊ฐ P(n,m)์ ์
๋ ฅํ์ฌ ํด๋น
๊ฐ์ ์ถ๋ ฅํ๋ ๊ตฌ์กฐ๋ก ๋ง๋ค์์. ํ์ง๋ง ๊ทธ ๊ฐ์ ์ถ๋ ฅํ๋๋ฐ ๋ง์
์๊ฐ๊ณผ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฐจ์งํ๋ ํ๋ก๊ทธ๋จ์. ์ด ์์ค๋ฅผ ๊ฐ๋จํ ํ๊ธฐ์ํด
์ฅ๋๊ท๊ฐ ์์ ์ ํ์๋๋ฐ, n=1000๊ฐ์ ๋ชจ๋ ์ฐ์ฐํ์ง์๊ณ , ์ฃผ์ด์ง
๋ n๊ฐ ๋งํผ๋ง ์ฐ์ฐํ์ฌ ์ถ๋ ฅํ๋๋ก ํ์์. ๊ทธ ๊ฒฐ๊ณผ ์ฐ์ฐ์ ๋ค์ด๊ฐ
๋ ์๊ฐ์ด ๋ง์ด ์ค์ด๋ค์์.
- 6. #include <stdio.h>
int ar[1000][1000];
#include <stdio.h> int n,m;
void main()
int ar[1000][1000];
{
int n,m;
int i,j;
scanf("%d%d",&n,&m);
void main() if(n>=1)
{ {
int i,j; ar[1][1]=1;
ar[1][1]=1; for(i=1;i<=n;i++)
{
for(i=1;i<=1000;i++)
ar[i][1]=1;
{
for(j=2;j<n;j++)
ar[i][1]=1;
{
โซ
printf("%u ",ar[i][1]);
for(j=2;j<=1000;j++) ar[i][j]=ar[i-1][j-1]+ar[i-1][j];
{ }
ar[i][i]=1;
ar[i][j]=ar[i-1][j-1]+ar[i-1][j]; }
}
printf("%u ",ar[i][j]);
for(i=1;i<=n;i++)
} {
printf("n"); for(j=1;j<=i;j++)
} {
printf("p(n,m)?"); printf("%u ",ar[i][j]);
scanf("%d%d",&n,&m); }
printf("n");
printf("P(n,m) = %u",ar[n][m]);
}
}
printf("P(n,m)? %u",ar[n][m]);
return 0;
}
(n=1000๊ฐ์ ์ฐ์ฐํ๋ ๋ถ๋ถ์ ์ ๊ฑฐํ๊ณ , n๋งํผ์ ๊ฐ๋ง ๋ฐ์์ ์ฐ์ฐํ๋๋ก ์์ .)
- 7. ์ํ 3์ผ์ฐจ (3/10 ํ )
์ฅ์ : ๋ฉ์ ์ ๋ฅผ ํตํ์ฌ ์ธํฐ๋ท ํ์
โป ๊ฐ์ ์
์์ค๋ฅผ ๋ถ์ํ ๊ฒฐ๊ณผ 1ํ์์๋ 1์ด๋ง ์ฐ์ฐํ๋ฉด ๋๋๋ฐ, n์ด๊น์ง ๋ถํ์ํ๊ฒ ์ฐ์ฐ๋ ๊ณผ์
์ด ์์. ๊น๋ํ์ด ๊ตฌ์กฐ๋ฅผ ๋ค์ ํ๋ฒ ๊ฐ์ ํ์ฌ ํ์ ์ฆ๊ฐํ ์๋งํผ ์ด์ ๊ณ์ฐํ๋๋ก ํ์ฌ
์ฐ์ฐํ์๋ฅผ ์ค์ด๋ ๊ฒ์ผ๋ก ์์ . ๊ทธ๋ฆฌ๊ณ ์์ค์ ๋ถํ์ํ ๋น๊ต๋ฌธ์ด๋ ์ฐ์ฐ๋ฌธ๋ค์ด ์๋ ๋ถ
๋ถ๋ ์ ๊ฑฐํจ.
#include <stdio.h> #include <stdio.h>
int ar[1000][1000]; int ar[1000][1000];
int n,m; int n,m;
void main()
void main()
{
{
int i,j;
scanf("%d%d",&n,&m); int i,j;
if(n>=1) scanf("%d%d",&n,&m);
{ ar[1][1]=1;
ar[1][1]=1; for(i=2;i<=n;i++)
for(i=1;i<=n;i++) {
{
ar[i][1]=1;
ar[i][1]=1;
for(j=2;j<=i;j++)
for(j=2;j<n;j++)
โซ
{ {
ar[i][j]=ar[i-1][j-1]+ar[i-1][j]; ar[i][j]=ar[i-1][j-1]+ar[i-1][j];
} }
ar[i][i]=1; }
}
for(i=1;i<=n;i++)
}
{
for(i=1;i<=n;i++)
{ for(j=1;j<=i;j++)
for(j=1;j<=i;j++) {
{ printf("%u ",ar[i][j]);
printf("%d ",ar[i][j]); }
} printf("n");
printf("n");
}
}
printf("P(n,m)? %u",ar[n][m]);
printf("P(n,m)? %d",ar[n][m]);
return 0; }
}
*๋นจ๊ฐ์ : ์ ๊ฑฐ๋ถ๋ถ *์ด๋ก์ : ๊ฐ์ ๋ถ๋ถ
(์ ํ๋ฅผ ๋ณด๋ฉด ์ด๋ ํ ๋ถ๋ถ์ด ์ ๊ฑฐ ๋์๊ณ ์ด๋ ํ ๋ถ๋ถ์ด ๋ฐ๋์๋์ง ์ ์ ์ ์๋ค.)
- 8. โป ๋ฐ๊ฒฌ๋ ๋ฌธ์ ์
์ถ๋ ฅ๊ฒฐ๊ณผ ///////////////
//////////////////
///////////////
์ด๋ ๋ฏ intํ์ธ ๊ฒฝ์ฐ ๋ณ์์ ์ ์ฅ๋ ๊ฐ์ด 21์ต์ด ๋์ผ๋ฉด ๊ฐ์ด -๋ก ๋์ค๋ฉด์
๊ฐ์ด ์๋ ค๋ฒ๋ฆฌ๋ ๋ฌธ์ ์ ์ด ๋ฐ์ํจ. ์ด์ ๋ํด์๋ ๋ค์ ๋ชจ์๊น์ง ์กฐ์ฌํด์ค๊ธฐ
๋ก ํจ.
์ํ 4์ผ์ฐจ (3/13 ํ)
๊ฐ์ด ์๋ฆฌ๋ ๋ฌธ์ ์ ์ ๋ํ์ฌ ์ฌ๋ฌ ๊ฐ์ง ๋ฐฉ์๋ค์ด ๋์ด.
โ ๋ณ์ํ __int64 ์ฐ๋๋ฐฉ๋ฒ.
โก ๋ณ์ํ int ์์ long๋ฅผ ๋ถํ ์๋ฃํ์ ํฌ๊ธฐ๋ฅผ ๋์ฌ์ฃผ๋ ๋ฐฉ๋ฒ.
โข ์ถ๋ ฅํ ๋ %d ๊ฐ ์๋ %u๋ฅผ ์ฐ๋ ๋ฐฉ๋ฒ.
โฃ ๋ณ์ํ์ double ํ์ผ๋ก ๋ฐ๊ฟ์ฃผ๋ ๋ฐฉ๋ฒ.
#include <stdio.h> #include <stdio.h>
__int64 ar[1000][1000]; double ar[1000][1000];
int n,m; int n,m;
void main()
void main()
{
int i,j; {
scanf("%d%d",&n,&m); int i,j;
ar[1][1]=1; scanf("%d%d",&n,&m);
for(i=2;i<=n;i++) ar[1][1]=1;
{ for(i=2;i<=n;i++)
โซ
ar[i][1]=1; {
for(j=2;j<=i;j++)
ar[i][1]=1;
{
for(j=2;j<=i;j++)
ar[i][j]=ar[i-1][j-1]+ar[i-1][j];
} {
} ar[i][j]=ar[i-1][j-1]+ar[i-1][j];
for(i=1;i<=n;i++) }
{ }
for(j=1;j<=i;j++) printf("P(n,m)? %.0lf",ar[n][m]);
{ }
printf("%.0lf ",ar[i][j]);
}
printf("n");
}
printf("P(n,m)? %I64d",ar[n][m]);
}
- 9. ๊ฐ์ ๊ฒฐ๊ณผ
โ ๋ณ์ํ __int64 ์ฐ๋๋ฐฉ๋ฒ :
-์ด ๊ฒฝ์ฐ์๋ ์ฌ๋๋ก๋ ๊ฐ์ด ์ข๋ ๋ง์ด ๋์ค๊ธฐ๋ ํ์ง๋ง ์ข๋ n์ ๊ฐ์ ๋
์ด๋ฉด -๊ฐ์ด ์ถ๋ ฅ๋์ด ๊ฐ์ด ๊นจ์ ธ๋ฒ๋ฆผ.
โก ๋ณ์ํ int ์์ long๋ฅผ ๋ถํ ์๋ฃํ์ ํฌ๊ธฐ๋ฅผ ๋์ฌ์ฃผ๋ ๋ฐฉ๋ฒ
-์ด ๊ฒฝ์ฐ๋ 1๋ฒ๊ณผ ๊ฒฐ๊ณผ๊ฐ ๊ฑฐ์ ๋์ผํ์๋ค.
โข ์ถ๋ ฅํ ๋ %d ๊ฐ ์๋ %u๋ฅผ ์ฐ๋ ๋ฐฉ๋ฒ
-๊ฐ์ด ์ถ๋ ฅ๋์ง๋ ์์์ง๋ง 10์ 10์น ์ด์ ๊ฐ์ด ์ปค์ง๋ฉด ์ฆ๊ฐํ์ง ๋ชปํ์
๋ค.
โฃ ๋ณ์ํ์ double ํ์ผ๋ก ๋ฐ๊ฟ์ฃผ๋ ๋ฐฉ๋ฒ.
-์์ฃผ ํฐ ์ซ์๊น์ง ์ถ๋ ฅ์ด ๋์์ง๋ง ์ด๊ฒฝ์ฐ์๋ ๋ท์๋ฆฌ๊ฐ 0์ผ๋ก ๋ณํ๋ ๋ฌธ
์ ๊ฐ ๋ฐ์ํ์๋ค
- 10. ์ํ 5์ผ์ฐจ (3/15 ๋ชฉ)
//์ต์ข
์์ค
#include <stdio.h>
double ar[1000][1000];
double Pas(int n,int m)
{
int i,j;
ar[1][1]=1;
for(i=2;i<=n;i++)
{
ar[i][1]=1;
for(j=2;j<=i;j++)
{
ar[i][j]=ar[i-1][j-1]+ar[i-1][j];
}
}
return ar[n][m];
}
void main()
{
int n,m;
double r;
scanf("%d%d",&n,&m);
r= Pas(n,m);
printf("%.0lfn", r);
}
๊ฒฐ๊ณผ ๊ฐ์ ์ฌ๋๋ก ๋ด๊ธฐ์ํ์ฌ ์กฐํฉ ๊ณ์ฐ(nCr) ๊ณต์์ ์ฌ์ฉํ์ฌ ๊ฐ์ ๊ตฌํ๋ ค ํ
์ผ๋ 1000!์ ๊ณ์ฐํ ๊ฒฝ์ฐ์๋ ๊ฐ์ ์ค๋ฅ๊ฐ ๋์ ๋ณ์ํ์ ํฌ๊ธฐ๋ฅผ ์ปค์ง๊ฒ ํ
๋ ๋ฐฉ๋ฒ ์ธ์๋ ๋ฐฉ๋ฒ์ด ์๋ค. ๋ผ๋ ๊ฒฐ๋ก ์ด ๋์์ต๋๋ค.
- 11. ์๊ฐ๋ณต์ก๋ ๊ณ์ฐ์ ๊ดํ์ฌ
์๊ฐ๋ณต์ก๋(Time complexity), ๊ณต๊ฐ๋ณต์ก๋(Space complexity)
์๊ฐ๋ณต์ก๋. ์๊ณ ๋ฆฌ์ฆ์ ์คํํ์ฌ ์ข
๋ฃํ ๋๊น์ง์ ํ์ํ ์๊ฐ
์๊ฐ ๋ณต์ก๋๋ ์๊ณ ๋ฆฌ์ฆ์ ๊ตฌ์ฑํ๋ ๋ช
๋ น์ด๋ค์ด ๋ช ๋ฒ์ด๋ ์คํ์ด ๋๋์ง๋ฅผ ์ผ ๊ฒฐ๊ณผ(frequency count)์ ๊ฐ ๋ช
๋ น์ด
์ ์คํ์๊ฐ(execution time)์ ๊ณฑํ ํฉ๊ณ๋ฅผ ์๋ฏธํ๋ค. ๊ทธ๋ฌ๋ ๊ฐ ๋ช
๋ น์ด์ ์คํ์๊ฐ์ ํน์ ํ๋์จ์ด ํน์ ํ๋ก๊ทธ
๋๋ฐ ์ธ์ด์ ๋ฐ๋ผ์ ๊ทธ ๊ฐ์ด ๋ฌ๋ผ์ง ์ ์๊ธฐ ๋๋ฌธ์ ์๊ณ ๋ฆฌ์ฆ์ ์ผ๋ฐ์ ์ธ ์๊ฐ ๋ณต์ก๋๋ ๋ช
๋ น์ด์ ์ค์ ์คํ์๊ฐ์
์ ์ธํ ๋ช
๋ น์ด์ ์คํ ํ์๋ง์ ๊ณ ๋ คํ๊ฒ ๋๋ค.
๊ณต๊ฐ๋ณต์ก๋. ์๊ณ ๋ฆฌ์ฆ์ ์คํํ์ฌ ์ข
๋ฃํ ๋๊น์ง์ ํ์ํ ๋ฉ๋ชจ๋ฆฌ์ ํฌ๊ธฐ
์ฃผ์ด์ง ์๊ณ ๋ฆฌ์ฆ์ ์คํ์ํค๊ธฐ ์ํด ํ์ํ ๊ธฐ์ต์ฅ์น(space)๋ ๋ค์๊ณผ ๊ฐ์ด ๋
๊ฐ์ง๋ก ๋ถ๋ฅํด ๋ณผ ์ ์๋ค.
1.์๊ณ ๋ฆฌ์ฆ๊ณผ ๋ฌด๊ดํ ๋ถ๋ถ : ์๊ณ ๋ฆฌ์ฆ์ ํน์ฑ๊ณผ๋ ๋ฌด๊ดํ ๋ถ๋ถ์ผ๋ก ํ๋ก๊ทธ๋จ
์ฝ๋๋ฅผ ์ ์ฅํ๊ธฐ ์ํ ๊ณต๊ฐ, ํ๋ก๊ทธ๋จ์ ์ํํ๊ธฐ
์ํด ์์คํ
์ด ํ์๋ก ํ๋ ๊ณต๊ฐ ๋ฑ์ด ์ด์
ํฌํจ๋๋ค.
2.์๊ณ ๋ฆฌ์ฆ๊ณผ ๋ฐ์ ํ ๋ถ๋ถ : ์๊ณ ๋ฆฌ์ฆ์ ํน์ฑ๊ณผ ๋ฐ์ ํ ๊ด๊ณ๊ฐ ์๋ ๋ถ๋ถ์ผ๋ก์
๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ํ์๋ก ํ๋ ๊ณต๊ฐ์ ์๋ฏธํ๋ค.
์ฆ, ๋ณ์๋ฅผ ์ ์ฅํ๊ธฐ ์ํ ๊ณต๊ฐ์ด๋ ์ํ ํ๋ก๊ทธ๋จ์ผ
๊ฒฝ์ฐ ์ํ ์คํ(recursion stack) ๋ฑ์ด ์ด์
ํฌํจ๋๋ค.
์ผ๋ฐ์ ์ผ๋ก ์๊ณ ๋ฆฌ์ฆ์ ๊ณต๊ฐ ๋ณต์ก๋๋ฅผ ๋ถ์ํ ๋๋ ์์ ๋๊ฐ์ง์ค ๋ ๋ฒ์งธ์ ๊ฒ์ ๊ณ์ฐํ๊ฒ ๋๋ค. ์ฆ, ์๊ณ ๋ฆฌ์ฆ์ด ๋ฌธ
์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด์ ๋ฐ๋์ ํ์ํ ๋ถ๋ถ๋ง์ ๊ณ์ฐํจ์ผ๋ก์จ ์ฃผ์ด์ง ์๊ณ ๋ฆฌ์ฆ์ ๊ณต๊ฐ ๋ณต์ก๋๋ฅผ ๊ณ์ฐํ๋ค.
2์ผ์ฐจ ์์ค ์๊ฐ,๊ณต๊ฐ๋ณต์ก๋ 3์ผ์ฐจ ์ดํ ์์ค ์๊ฐ,๊ณต๊ฐ๋ณต์ก๋
- 12. ๊ณผ์ ๋ฅผ ๋ง์น๋ฉด์....
- C์ธ์ด ๊ณต๋ถ์ ๋ํ ๋ถ์กฑํจ์ ๋ง์ด ๋๊ผ์ต๋๋ค. ์์ฃผ ํฐ ์ซ์๋ฅผ ๋ด์ ์ฐ์ฐํ๋ ๋ฐฉ๋ฒ์ ์์๋๋ผ๋ฉด ์ข ๋
์ ๋ขฐ์ฑ์ด ๋์ ์๋ฒฝํ ํ๋ก๊ทธ๋จ์ ์งค ์ ์์์ ๊ฒ ๊ฐ์ต๋๋ค.