๋ถ๋ฅ ์ ์ฒด
- [๋ฉ๋ฏธ]๋ฉํฐ๋ฏธ๋์ด ์์ 3 - Threshold, Image Add/Subract/ Contrast Stretching 2008.04.07
- [๋ฉ๋ฏธ4] ์ค์ต4 ํ์คํ ๊ทธ๋จ 2008.03.31
- [๋ฌผ๋ฆฌ์์ 3] ๋ฌธ์ ํ์ด 2008.03.31
- [ํผ์จ๊ธ] ์ ์๊ณ ๋ฆฌ์ฆ์ ์์์ผ ํ์ง? 2008.03.23
- [ํผ์จ๊ธ] ๋ฌธ์์ด ์ซ์๋ก ๋ฐ๊พธ๊ธฐ stringstream 2008.03.21
- [์๋ฃ] ๋ฏธ๋ ๊ณตํ์ฉ ๊ณ์ฐ๊ธฐ 2008.03.20 1
- [Uva 10892] Annoying Painting tool ํ์ด. 2008.03.17
- [๋ฉ๋ฏธ์ค์ต2] ์๋ํธ๋ฐ์ค ์ ๋ ฅ๋ฐ๊ธฐ ๋ฐ ์ฌ๋ผ์ด๋ ์ด์ฉํ๊ธฐ. 2008.03.17
[๋ฉ๋ฏธ]๋ฉํฐ๋ฏธ๋์ด ์์ 3 - Threshold, Image Add/Subract/ Contrast Stretching
[๋ฉ๋ฏธ4] ์ค์ต4 ํ์คํ ๊ทธ๋จ
[๋ฌผ๋ฆฌ์์ 3] ๋ฌธ์ ํ์ด
์ด ํฌ์คํ ์ ์ฟ ํก ํํธ๋์ค ํ๋์ ์ผํ์ผ๋ก, ์ด์ ๋ฐ๋ฅธ ์ผ์ ์ก์ ์์๋ฃ๋ฅผ ์ ๊ณต๋ฐ์ ์ ์์ต๋๋ค.
1. ์ฌ๋ฌ๋ถ์ด ์๊ถ์ ์๋ผ๊ณ ํด๋ณด์. 30.0 m ์ ๋ฐฉ์ ์๋ ๊ณผ๋ ์ ํ์์๋ฅผ ์ต๋๋ก ๋น๊ฒจ, ์ฒ์์ ์ํ ๋ฐฉํฅ์ผ๋ก ์์๋๋ ์์
์ ํ ์ค์๊ณผ ๋ ๊ฐ์ ๋์ด์ ์๋ ๊ณผ๋ ์ค์์ผ๋ก๋ถํฐ ์ฐ์ง ํ๋ฐฉ์ผ๋ก 1.25 m ๋จ์ด์ง ๋์ด์ ํ์ด์ด ๊ฝํ ๊ฒ์ ๋ง์๊ฒฝ์ผ๋ก ํ
์ธํ๋ค๊ณ ํ์. ๋ ๋ฒ์งธ ์์์์ ์ฒ์๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ํ์์๋ฅผ ์ต๋๋ก ๋น๊ฒจ ๊ณผ๋ ์ค์์ ๋ช ์ค์ํค๋ ค๋ฉด ๋ช ๋ ์๋ฐฉ์ผ๋ก ์์
์ผ ํ ๊น? (์ค๋ ฅ๊ฐ์๋๋ g=9.80 m/s^2 ๋ก ๋์ ๊ฒ.)
x์ฑ๋ถ๊ณผ y์ฑ๋ถ์ ๋ณ๊ฐ๋ค.
y์ฑ๋ถ์ ํตํด ์๊ฐ์ ๊ตฌํ ์ ์๋ค.
๊ณผ๋ ์์ 1.25m ๋ฐ์ผ๋ก ๊ฐ์ผ๋ฏ๋ก...
๊ถค์ = Vy0 * t + 1/2*a*t^2 ์์
์ฃผ์ด์ง ๋๋ก Vy0 = 0์ด๊ณ a = 9.8m/s^2์ด๋ฏ๋ก t๋ฅผ ๊ตฌํ ์ ์๋ค.
1.25 = 0*t + 1/2*9.8 * t^2
1.25 * 2 / 9.8 = t ^ 2
t = ๋ฃจํธ(2.5/9.8)
t = 5/๋ฃจํธ(98)์ด
x์ฑ๋ถ์ ์๊ฐํด๋ณด๋ฉด ์๊ฐ์ ์ํด์ ๊ตฌํ์ผ๋ฏ๋ก ๊ทธ๊ฑธ ํ ๋๋ก ์ฒ์ ์๋๋ฅผ ๊ตฌํ ์ ์๋ค.
30 = V0 * 5/๋ฃจํธ(98) + 1/2*0*t^2
Vx0 = 6*๋ฃจํธ(98)m/s^2
์ด์ ์ ๋ ์์ ํ ๋๋ก y์ฑ๋ถ์ ์ผ๋ง๋งํผ์ ์๋๊ฐ ๊ฐ์ผ ๊ณผ๋
์ ์ค์์ ๋ง์๊น๋ฅผ ์๊ฐํด๋ณด๋ฉด
๊ถค์ = V0*t + 1/2*a*t^2์์ ์ ์ค์์ ๋ง๋๋ค๋ ๋ง์ ์ฌ๋ผ๊ฐ๋ค๊ฐ ๋ค์ ๋ด๋ ค๊ฐ์ ๊ฒฐ๊ณผ์ ์ผ๋ก ๊ถค์ ์ด 0์ด๋ผ๋ ๋ป์ด๋ค.
์ฆ, 0 = Vy0 * t - 1/2*9.8*t^2์์ t= 5/๋ฃจํธ(98)์ด
0 = Vy0 * 5/๋ฃจํธ(98) - 1/2*9.8*(5/๋ฃจํธ(98))^2
Vy0*5/๋ฃจํธ(98) = 4.9*25/98
Vy0 = 4.9*25/98/5*๋ฃจํธ(98)
Vy0 = ๋ฃจํธ(98)/4
Sin์ํ = 6*๋ฃจํธ(98) / ๋ฃจํธ(98)/4
= 1/24
์ํ = ArcSIN(1/24) = 0.0416787324225779
๊ฐ์ด ๋ผ๋์ ์ด๋ฏ๋ก 360๋๊ฐ๋๋ก ๋ฐ๊ฟ์ฃผ๋ฉด
2.388015...
์ํ = ์ฝ 2.4๋
2. ์ปค๋ค๋ ๋๋ฅด๋์ ํผํผํ ์ค์ด ํ๋ ๊ฑธ์ณ์ ธ ์๊ณ ์์ชฝ์ ๋ฌด๊ฒ๋ฅผ ๋ฌด์ํ ์ ์๋ ์ ์ธ ๋ ๊ฐ๊ฐ ๋ฌ๋ ค ์๋ค๊ณ ํ์. ๊ฐ ์ ์ธ
์ ๋ชธ๋ฌด๊ฒ๊ฐ 70 ํฌ๋ก๊ทธ๋จ๊ณผ 50 ํฌ๋ก๊ทธ๋จ์ธ ๋ ์ฌ๋์ด ๊ฐ๊ฐ ์ฌ๋ผ ํ๋ค๊ณ ํ๋ฉด ๋น์ฐํ ๋ชธ๋ฌด๊ฒ๊ฐ ๋ ๋ฌด๊ฑฐ์ด ์ฌ๋ ์ชฝ์ด ๋ด๋ ค์ค๊ฒ
๋ ๊ฒ์ด๋ค. ์ด ๋ ์ ์ธ์ ๋ํ๋ ๊ฐ ์ฌ๋์ ๋ชธ๋ฌด๊ฒ๋ฅผ ๊ตฌํด ๋ณด์์ค.
"๋ชธ๋ฌด๊ฒ"๋ ํ์ ์ฐจ์์ด๋ค.(ํฌ๋ก๊ทธ๋จ์ค ์ผ๋ก ํ๊ธฐ๋์ด์์ง ์์ ์ ์ค๋ ฅ๊ฐ์๋๊ฐ ์ ์ฃผ์ด ์ก๋์ง ํท๊ฐ๋ ธ์ต๋๋ค.)
ํฉ๋ ฅ์ ๊ตฌํ๋ฉด ๋ฌด๊ฑฐ์ด์ชฝ์ผ๋ก ํ์ด ์ ๋ฆฌ๊ฒ ๋๋ค.
์ฆ ์ ์ธ์ 70ํฌ๋ก๊ทธ๋จ์ผ๋ก ๋์๋ ์ชฝ์ผ๋ก 50ํฌ๋ก๊ทธ๋จ์ ๋บ 20ํฌ๋ก๊ทธ๋จ์ ๋ฌด๊ฒ๋งํผ ์์ฉํ๊ฒ ๋๋ค.
๊ทธ๋์ ๋ชธ๋ฌด๊ฒ๊ฐ 70ํฌ๋ก๊ทธ๋จ์ธ ์ฌ๋์ด ์ฌ๋ผํ ์ชฝ์ ์ ์ธ์ด 20ํฌ๋ก๊ทธ๋จ์ ๊ฐ๋ฆฌํฌ ๊ฒ์ด๊ณ
50ํฌ๋ก๊ทธ๋จ์ธ ์ฌ๋์ด ํ ์ชฝ์ ์ ์ธ์ด 0ํฌ๋ก๊ทธ๋จ์ ๊ฐ๋ฆฌํฌ ๊ฒ์ด๋ค.
3. ์์ ์๊ฐ์ ์ง๋์ด m1, m2 ์ธ ๋ ๋ฌผ์ฒด๋ฅผ ์ํํ ๋ฐ๋ฅ ์์ ๋๊ณ ์๋ก ์ ์ด์์ผ ๋์ ๋ค ์ํ ๋ฐฉํฅ์ ํ F ๋ฅผ m1 ์ ๊ฐํ
๊ฒฝ์ฐ ์ด๋ป๊ฒ ์์ง์ด๋ฉฐ, ์ฃผ๊ณ ๋ฐ๋ ํ์ ์ผ๋ง๋ ๋๋์ง ๊ณ์ฐํด ๋ณด์๋ค. ์ฌ๊ธฐ์ ์ง๋ m3 ์ธ ๋ฌผ์ฒด๋ฅผ ํ๋ ๋ m2 ์์ ๋ถ์ฌ ๋์
๊ฒฝ์ฐ ๊ฐ์๋์ ์ฃผ๊ณ ๋ฐ๋ ํ๋ค์ ๊ตฌํด ๋ณด์์ค. ๋, m1 ๋ถํฐ mN ๊น์ง์ ๋ฌผ์ฒด๊ฐ ๋ถ์ด ์๋ ๊ฒฝ์ฐ๋ก ์ผ๋ฐํํ ์ ์๋์ง ์๊ฐํด
๋ณด์์ค.
m3๊น์ง ์๋๊ฒฝ์ฐ๋
F = (m1 + m2 + m3) * a
์ฆ ๊ฐ์๋๋
a = F / (m1 + m2 + m3)
์ง๋์ด m1์ธ ๋ฌผ์ฒด๊ฐ ๋ฐ๋ ์์งํ F + F12 = m1*a
์ง๋์ด m2์ธ ๋ฌผ์ฒด๊ฐ ๋ฐ๋ ์์งํ F21 + F23 = m2*a
์ง๋์ด m3์ธ ๋ฌผ์ฒด๊ฐ ๋ฐ๋ ์์งํ F32 = m3*a
mN๊น์ง์ ๋ฌผ์ฒด๊ฐ ๋ถ์ด์๋ ์ผ๋ฐ์ ์ธ ๊ฒฝ์ฐ๋
๊ฐ์๋ a = F / (m1 + m2 + m3 + ... + mN)
= F / (โK๋1์์n๊น์ง) mK
๋ฌผ์ฒด๊ฐ N๊ฐ์ผ๋ ๊ฐ ๋ฌผ์ฒด๊ฐ ์ฃผ๊ณ ๋ฐ๋ ํ์
์ง๋์ด mK์ธ ๋ฌผ์ฒด๊ฐ ๋ฐ๋ ์์งํ FK(K-1) + FK(K+1) = mK*a (K๊ฐ 1๊ณผ N์ด ์๋๋)
K๊ฐ 1์ผ๋, F + FK(K+1) = mK*a
K๊ฐ N์ผ๋, FN(N-1) = mN*a
[ํผ์จ๊ธ] ์ ์๊ณ ๋ฆฌ์ฆ์ ์์์ผ ํ์ง?
์ด ํฌ์คํ ์ ์ฟ ํก ํํธ๋์ค ํ๋์ ์ผํ์ผ๋ก, ์ด์ ๋ฐ๋ฅธ ์ผ์ ์ก์ ์์๋ฃ๋ฅผ ์ ๊ณต๋ฐ์ ์ ์์ต๋๋ค.
์ถ์ฒ : http://www.hyunlog.com/blog/entry/์-์๊ณ ๋ฆฌ์ฆ์-์์์ผ-ํ์ง
์ ์๊ณ ๋ฆฌ์ฆ์ ์์์ผ ํ์ง?
์๊ณ ๋ฆฌ์ฆ์ ๋ํด ๊ธ์ ์จ ๋ณด๊ธฐ๋ก ํ๋ค.
๋๋ ์๊ณ ๋ฆฌ์ฆ์ด ์ ์ฐํ์ ๊ฐ์ฅ ๊ธฐ๋ณธ, ๊ฐ์ด๋ผ ์๊ฐํ๋ค. ์ธ๊ณต์ง๋ฅ, ์ด์์ฒด์ , DBMS ๋ฑ ์ ์ฐํ์ ์ด๋์๊ณ ์ ์ ํ ์๊ณ ๋ฆฌ์ฆ์ ๋ํ ์ดํด๊ฐ ํ์ํ์ง ์๋ ๊ณณ์ด ์๋ค. ํ๋ง์์ ๋ฐ์ ์ฌ๋๋ค์ ๋ณด๋๋ผ๋ ๊ทธ ์ค ๋ง์ ์ฌ๋๋ค์ด ์๊ณ ๋ฆฌ์ฆ์ ๋ฐฐ์ฐ๋ค ๋ณด๋ฉด ๋์ค๋ ์๋ฐ๋ค์ด๋ค.
๋๋ ๋ํ์์์ ์ํ์ ๋
ผ๋ฆฌํ๊ณผ ์๊ณ ๋ฆฌ์ฆ์ ๋ฐฐ์ฐ๋ฉด์ ๋ด๊ฐ ์ด ์ชฝ์์ ์์คํผํธ๊ฐ ๋ ๋งํผ ์ค๋งํธํ์ง ์๋ค๋ ๊ฒ์ ์์๋ค. ๊ทธ๋๋ ์๊ณ ๋ฆฌ์ฆ์ ์ ์ฐํ์ ํ๊ธฐ์ ํ์ํ๋ฏ๋ก ์๊ณ ์์ด์ผ ํ๋ค๊ณ ์๊ฐํด ๋
ธ๋ ฅํ๋ค. ์๊ณ ๋ฆฌ์ฆ ์ฑ
์ ๋ง์ง๋ง ๋ณธ๊ฒฉ์ ์ผ๋ก ๋ณธ ๊ฒ์ด 92๋
๊ฒฝ์ด๋ผ ๊ธฐ์ตํ๋ค.
์ ์ง๊ธ ๋ค์ ์๊ณ ๋ฆฌ์ฆ์ด ์๊ฐ๋ ๊น?
์ฐ๋ฆฌ ํ์ฌ์์ ์๋ก์ด ์ํ์ ์ค๋นํ๋๋ฐ ์๊ณ ๋ฆฌ์ฆ ํ๋ จ์ด ํ์ํ๊ธฐ ๋๋ฌธ์ด๋ค. ์๊ณ ๋ฆฌ์ฆ ํ๋ จ์ด ๋์ง ์์ ์ฌ๋์ ๋จ์ coder ์ด๊ณ , ์๊ณ ๋ฆฌ์ฆ์ ์ดํดํ๊ณ ์ ์ฉํ๋ฉด์ ๋ถํฐ ํ๋ก๊ทธ๋๋จธ๋ผ ๋ถ๋ฅผ ์ ์๋ค. ์๊ณ ๋ฆฌ์ฆ ํ๋ จ์ด ๋๊ณ ์ด์ ๋ฐํํ ์ ์ฐํ์ ์ฌ๋ฌ ๋ถ์ผ๋ฅผ ์๊ฒ๋๋ฉด ์ปดํจํฐ ์์ง๋์ด ๋๋ ๊ณผํ์๋ผ ๋ถ๋ฅธ๋ค. ์ปดํจํฐ ์์ง๋์ด/๊ณผํ์์ ์์ํ ์ฌ๋ถ์ธ Donald Knuth์ The Art of Computer Programming ์ ๋ณด์. ์ฑ
์ด๋ฆ์ "์ปดํจํฐ ํ๋ก๊ทธ๋๋ฐ ๊ธฐ์ " ์ด๋ผ๊ณ ํ๋ค. ์ด ๊ฒ ๋ณด๊ณ ์ดํดํด์ผ์ง ํ๋ก๊ทธ๋๋จธ๋๋ค. ์ฐ๋ฆฌ ํ์ฌ๊ฐ ์ข์ ํ๋ก๊ทธ๋๋จธ, ์์ง๋์ด๊ฐ ํ์ํ๊ณ ๋๋ถํฐ ๋ค์ ํ๋ จํด์ผ ์ง์๋ค ๋์ ์ค ์ ์์ ๊ฒ ๊ฐ๋ค.
์๊ณ ๋ฆฌ์ฆ์ Cormen ๋ฑ์ด ์ด Introduction to Algorithms ์ผ๋ก ๊ณต๋ถํ๋ค. ๊ฝค ๋๊บผ์ด ์ฑ
์ผ๋ก ์ด ์ชฝ ๋ถ์ผ์ ๋ฒ ์คํธ์
๋ฌ๋ค. ์๊ณ ๋ฆฌ์ฆ ์ฝ์ง ์๋ค. ์ค์ฃฝํ๋ฉด ๋น ๊ฒ์ด์ธ ๊ฐ "๋๊ฐ ์ ๋ง ์ข์ ํ๋ก๊ทธ๋๋จธ๋ผ๋ฉด Knuth์ The Art of Programming์ ๋ณด์์ผ ํ๊ณ , ์ ๋ง ๋ค ์ฝ์์ผ๋ฉด ์ฌ๋นจ๋ฆฌ ์๊ธฐ์๊ฒ ์ด๋ ฅ์ ๋ณด๋ด๋ผ" ํ์๊น? ์ด ์ฑ
์ด 4๊ถ์ด๋ค. ์๋ง ์ด ๋ถ์ผ์์ ๊ฐ์ฅ ์ ๋ช
ํ๋ฉด์๋ ๊ฐ์ฅ ๋ง์ด ์ณ๋ค ๋ณด๊ธฐ๋ง ํ ์ฑ
์ผ ๊ฒ์ด๋ค. ์ด ์ฑ
๋ค 4๊ถ ๋ค ์ฝ์ ์ฌ๋์ด๋ผ๋ฉด ๋๊ฐ ์ฑ๊ฐ๋์ง๋ ๋ชจ๋ฅด๊ฒ ์ฑ ๊ฐ ๊ฒ์ด๋ค. ๊ตฌ๊ธ์ ์ธ๋ฅด๊ฒ์ด ๋ธ๋ฆฐ์ด ์๋ง๋ ์ ์ฉ ๋นํ๊ธฐ ๋ณด๋ผ ์ง๋ ๋ชจ๋ฅธ๋ค.
์ด ์ ๋๋ฉด ์ธ์ผํฐ๋ธ ๋์ง ์์๊น?
90๋
๋ ์ด์ ์ง๊ธ ๊ฝค ์๊ณ ๋ฆฌ์ฆ ์งํ์ด ๋ฐ๋์๋ค. ์๊ณ ๋ฆฌ์ฆ์ด ๋ฐ๋ ๊ฒ์ด ์๋๋ผ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ๋ SW ํ๊ฒฝ์ด ๋ฐ๋์๋ค. ๊ฐ์ฅ ํฐ ๋ณํ๋ JAVA์ ๊ฐ์ ๊ฐ์ฒด์งํฅ ์ธ์ด์ ๊ธฐ์ ์ด ๋ณด๊ธ๋๋ฉด์ JAVA์ Collection ๊ฐ์ด ํธ๋ฆฌํ ์๋ฃ๊ตฌ์กฐ API ๋ค์ด ๋ฑ์ฅํ ๊ฒ์ด๋ค. ์์ฃผ ์ข์ ํ์์ด๋ค.
JAVA Collection ๊ฐ์ ๋๊ตฌ, ํ๋ถ์์ ์๋ฃ๊ตฌ์กฐ๋ฅผ ๊ฐ๋ฅด์น๋ฉด์ ๋๊ผ๋ ์ด๋ ค์, ๊ทธ๋ฆฌ๊ณ ์ต๊ทผ์ ๋ํ์์์ ๊ฐ์ฒด์งํฅ ๊ธฐ์ ์ ๊ฐ์ํ๋ฉด์ ์๊ธด ์ํํธ์จ์ด ๊ด์ ์ ๋ณํ, SW์ ์ฌ์ฌ์ฉ์ฑ, ํ์ค์ ์ผ๋ก ์ด์ฉ ์ ์์ด ๊ณ์ ์๊ตฌ์ฌํญ์ด ๋ฐ๋๊ธฐ ๋๋ฌธ์ SW๋ ์ง์์ ์ผ๋ก ๋ฐ๋์ ๋ฐ์ ์๋ค๋ extreme programming ๋ฐฉ๋ฒ๋ก ๋ฑ์ด ๋ค ์ฐ๋ฆฌ๊ฐ ์๊ณ ๋ฆฌ์ฆ์ ๋ณด๋ ๋ฐฉ๋ฒ์ ๋ณํ๋ฅผ ์๊ตฌํ๊ณ ์๋ค๊ณ ์๊ฐํ๋ค. ์์ ์ ์ฐ๋ฆฌ๊ฐ red-black tree๋ฅผ ์ง์ ์งฐ๋ค๋ฉด ์ด์ ๋ JAVA Collection ์ค์ ์ ๋นํ ๋
์์ ๋ถ๋ฌ ์ธ ์ ์๊ฒ ๋ ๊ฒ์ด๋ค. ํธ๋ฆฌํจ์ ์ป์์ง๋ง ํ๋ก๊ทธ๋๋ฐ ์๋ฏธํ๋ ๊ธฐ์ ์ ์์ด ๊ฐ๋ค. ์ผ๋ง๋ ์ Collection API๊ฐ ๊ตฌํ๋์์๊น ๊ถ๊ธํ๊ธฐ๋ ํ๋ค. 20๋
์ ์๋ ๋ค๋ฅธ ์ฌ๋์ด ๋ง๋ ๊ฒ ๋ฏฟ์ง ๋ชปํ๋ ์ง์ ์์ ์ด ๊ตฌํํด์ผ ํ๋ค๊ณ ํ๊ฒ ์ง๋ง, ์ด์ ๋ ๊ฐ๋ค ์ฐ๋ ๊ฒ์ด ๋ง๋ค. ๋ด๊ฐ ์ฌ์ฌ์ฉํ๋๋ก ๊ฐ๋ฅด์น๋๋ฐ...
์ด๋ฐ ๊ด์ ์์ ์๊ณ ๋ฆฌ์ฆ์ ๋ณด๊ณ ์ถ๋ค. ๊ฐ์ฒด์งํฅ์ ํด๋์ค, encapsulation, hierarchy, polymorphism์ด ์ ๋ง ์ผ๋ง๋ ์๊ณ ๋ฆฌ์ฆ์ด ์์กดํ๋ ๋ฐ์ดํฐ๊ตฌ์กฐ (Abstract Data Type)์ ๋ฑ ๋ง๋ ์ง (์ ๋ง ๊ทธ๋ ๋ค), ํฌ์ธํฐ ์๋ JAVA๋ก ์ด๋ป๊ฒ ์๊ณ ๋ฆฌ์ฆ์ด ์ ๊ตฌํ๋๋์ง ์์ ๋ณด๋ ค ํ๋ค. ํ๋ค ๋ณด๋ฉด ๊พ๊ฐ ๋ง์ด ๋ ํฐ์ธ๋ฐ. ์ฌ๋ฅ์ด ๋ถ์กฑํ๋ ์๊ฐ๋ ๊ฑธ๋ฆฌ๊ฒ ๊ณ , ๊ทธ๋ ์ง๋ง ๋ ํํธ ๋ด๊ฐ ์ดํด ํ ์ ๋๋ฉด ์ต์ํ The Art of Programming ์ ๊ทธ๋ฅ ๋ณด๋ ๊ฒ ๋ณด๋ค๋ ๋ซ์ง ์์๊น?
์ค๋๋ง์ ๋จธ๋ฆฌ๋ ์จ ๋ณด๊ณ , ์๋ฐ๋ ํ๋ จํ ๊ฒ ๊ฐ์ ์ค๋ ๋ค.
Knuth๊ต์๋์ ๊ฐ์๋ฅผ ๋ณด๊ณ ์ถ์ผ๋ฉด ์ฌ๊ธฐ๋ก. ์ฌ๋ฏธ์๋ ๊ฒ์ด ์ฌ๊ธฐ์ ๋ง์ต๋๋ค. ์์ด์ ์๊ณ ๋ฆฌ์ฆ์ ์๊ฒ๋๋ฉด ์๋ก์ด ์ธ์์ด ๋ณด์ผ ๊ฒ์
๋๋ค.
Hang on.
[ํผ์จ๊ธ] ๋ฌธ์์ด ์ซ์๋ก ๋ฐ๊พธ๊ธฐ stringstream
์ด ํฌ์คํ ์ ์ฟ ํก ํํธ๋์ค ํ๋์ ์ผํ์ผ๋ก, ์ด์ ๋ฐ๋ฅธ ์ผ์ ์ก์ ์์๋ฃ๋ฅผ ์ ๊ณต๋ฐ์ ์ ์์ต๋๋ค.
์ถ์ฒ : http://www.buggymind.com/83
์์ฆ C++๋ก Admission Control System์ ๊ฐ๋ฐ์ค์
๋๋ค. ๊ทผ๋ฐ ํ๋ก๊ทธ๋จ์ ์ง๋ค ๋ณด๋ฉด ์ผ๋ก ๊ทธ๋ ๊ฒ ์ง๋ง ์คํธ๋ง์ ์ซ์๋ก, ์ซ์๋ ์คํธ๋ง์ผ๋ก ๋ณํํ ์ผ์ด ๋ง์ด ์๊ธฐ๋๊ตฐ์. ์ข
์ ์๋ atoll๊ฐ์ ํจ์๋ฅผ ์จ์ ๊ทธ๋ฐ ๋ณํ์์
์ ํ๊ณ ์์๋๋ฐ, ์ฌ์ง ์ค๋์ stringstream ํด๋์ค๋ฅผ ์จ์ ๊ทธ๊ฑธ ํด๋ณด๊ณ ์ถ๋๊ตฐ์. ์ด์ฉ๋ค๊ฐ Bjarne ์ ์๋์ ์ด ๊ธ์ ๋ณด๊ฒ ๋์๊ฑฐ๋ ์. "How do I convert an Integer to a String"์ด๋ผ๋ ๊ฒ์ด ์ ๋ชฉ์ธ๋ฐ์. stringstream ํด๋์ค๋ฅผ ์ฌ์ฉํด itos๋ผ๋ ํจ์(integer๋ฅผ ๋ฌธ์์ด๋ก ๋ฐ๊พธ๋)๋ฅผ ๊ตฌํํฉ๋๋ค.
๊ทธ๋์ ์ด๋ฒ์๋ ๋ฌธ์์ด์ ์ซ์๋ก ๋ฐ๊พธ๋ ์์
์ stringstream์ ์จ์ ํด๋ณด๊ธฐ๋ก ํ์ต๋๋ค. ๊ฑฐ์ ๋น์ทํ๊ฒ ํ๋ฉด ๋ ๊ฒ ๊ฐ๋๊ตฐ์.
#include <iostream>
#include <sstream>
using namespace std;
long long stoll(const string& v) {
stringstream ss;
ss << v;
long long ret;
ss >> ret;
return ret;
}
int main() {
long long r;
for ( int i = 0; i < 10000000; ++i ) {
r = stoll("48623948209834029");
}
}
๋ค. ์ด๋ ๊ฒ ๊ตฌํํ ์ฝ๋๋ ์์ฃผ ๊ทธ๋ด์ธํ๊ฒ ์ ๋์๊ฐ๋๋ค. ๋๋ฆ๋๋ก 'C++'์ ์ด๊ธฐ๋ ํ์ง์. ํ์ง๋ง ์ฌ๋ฌ ๊ฐ์ง ์ด์ ๋ก ์ ๋ ์์ ์ฝ๋๋ฅผ ์ฌ์ฉํ๊ธฐ๋ฅผ ํฌ๊ธฐํ์ต๋๋ค. ์ ๊ทธ๋ฌ๋๊ณ ์? ์์ ์ฝ๋๋ฅผ Unix time ๋ช ๋ น๊ณผ ํจ๊ป ์คํํด๋ณด๋ฉด, ๋ค์๊ณผ ๊ฐ์ ๊ฒฐ๊ณผ๋ฅผ ์ป์ต๋๋ค.
[bjlee@bjlee-xnote test]$ time ./a.out
real 0m24.972s
user 0m23.349s
sys 0m0.060s
[bjlee@bjlee-xnote test]$
ํ์ง๋ง ๊ฐ์ ํ๋ก๊ทธ๋จ์ stdlib.h์ ์ ์ธ๋์ด ์๋ atoll์ ์จ์ ๋ค์๊ณผ ๊ฐ์ด ํ๋ฉด ์ด๋จ๊น์?
int main() {
long long r;
for ( int i = 0; i < 10000000; ++i ) {
r = atoll("48623948209834029");
}
}
๊ทธ๋ฌ์ ๊ฒฝ์ฐ์๋ ๋ค์๊ณผ ๊ฐ์ ๊ฒฐ๊ณผ๋ฅผ ์ป์ต๋๋ค.
[bjlee@bjlee-xnote test]$ time ./a.out
real 0m2.306s
user 0m2.276s
sys 0m0.008s
[bjlee@bjlee-xnote test]$
๊ฐ๋จํ ์คํ์ผ๋ก๋ ์ฑ๋ฅ ์ฐจ์ด๊ฐ ๊ฝค ํฌ๋ค๋ ๊ฒ์ ํ์ธํ ์ ์์ต๋๋ค. ๊ฐ์ฒด ์์ฑ๊ณผ ๊ฐ์ ๊ธฐํ๋ฑ๋ฑ์ ์ค๋ฒํค๋๊ฐ ๋ผ์ด๋ค๊ธฐ ๋๋ฌธ์ stringstream์ชฝ์ ํผํฌ๋จผ์ค๊ฐ ๋ ์์ข๊ฒ ๋์จ ๊ฒ์ด๊ฒ ์ฃ . ๊ทธ๋ผ Bjarne ์์ ์จ๋ int๋ฅผ string์ชฝ์ผ๋ก ๋ณํํ๋ ๊ฐ์ฅ ๊ฐ๋จํ ๋ฐฉ๋ฒ์ผ๋ก ์ stringstream์ ์ถ์ฒํ ๊ฒ์ผ๊น์? ๊ทธ๊ฒ ๊ถ๊ธํด์ ๋ฐ๋์ชฝ๋ ์คํ์ ํด๋ดค์ต๋๋ค.
#include <iostream>
#include <sstream>
using namespace std;
string itos(const long long& v) {
stringstream ss;
ss << v;
string ret;
ss >> ret;
return ret;
}
int main() {
string p;
for ( int i = 0; i < 10000000; ++i ) {
p = itos(324879829);
}
}
์์ ์ฝ๋์ ๊ฒฝ์ฐ time์ผ๋ก ์๊ฐ์ ์ฌ ๋ณด๋ฉด ๊ฒฐ๊ณผ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
[bjlee@bjlee-xnote test]$ time ./a.out
real 0m19.790s
user 0m19.677s
sys 0m0.012s
[bjlee@bjlee-xnote test]$
๊ทธ๋ผ ๋ค์๊ณผ ๊ฐ์ ์ฝ๋๋ฅผ ์ฌ์ฉํด ๋ณด๋ฉด ์ด๋จ๊น์?
#include <iostream>
#include <sstream>
using namespace std;
string itos(const long long& v) {
char buffer[256];
sprintf(buffer, "%lld", v);
return string( buffer );
}
int main() {
string p;
for ( int i = 0; i < 10000000; ++i ) {
p = itos(324879829);
}
}
์ด ๊ฒฝ์ฐ์ ์ฑ๋ฅ์ ์ฌ ๋ณด๋ฉด ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
[bjlee@bjlee-xnote test]$ time ./a.out
real 0m7.683s
user 0m7.104s
sys 0m0.032s
[bjlee@bjlee-xnote test]$
์ด์จ๋ stringstream์ ์ฐ๊ฒ ๋๋ฉด ์ฑ๋ฅ์ ๋ฐฐ ์ด์ ๋จ์ด์ง๋๊ตฐ์.
๊ทธ๋ ๋ค๋ฉด Bjarne ์์ ์จ๊ฐ int๋ฅผ string์ผ๋ก ๋ณํํ ๋ stringstream์ ์ฐ๋๊ฒ ๊ฐ์ฅ ๊ฐ๋จํ๋ค๊ณ ์ถ์ฒํ ์ด์ ๋ ๋ฌด์์ผ๊น์? ์ด์ ๋ ๊ฐ๋จํฉ๋๋ค. string์ int๋ก ๋ณํํ๋ ์ชฝ์ ๊ทธ๋ด๋ฏํ ์๋ฃจ์ ์ด ์ด๋ฏธ ๋ง์ด ์์ต๋๋ค. (atoll์ด๋ atoi์ ๊ฐ์) ๊ฑฐ๊ธฐ๋ค ์ด๋ฐ ํจ์๋ค์ '๋ ์ด์ ๊ฐ๋จํด์ง ์ ์์ ์ ๋๋ก' ๋จ์ํ ํจ์๋ค์ด์ด์, ๊ทธ ํจ์๊ฐ '๊ทธ๋ค์ง ์ฐ์ํด๋ณด์ด์ง ์๋๋ค๋ ์ด์ ๋ก' C++์ ์ธ ํด๊ฒฐ์ฑ ์ ๊ณ ์ํด ๋ธ๋ค๋ ๊ฒ์ด ๋ง์ด ๋์ง ์์์. ๋ฐฉ๊ธ ์์์ ์คํํ ๊ฒฐ๊ณผ๋ก๋ ์ฆ๋ช ๋๋ ์ด์ผ๊ธฐ์ ๋๋ค๋ง, ์ฑ๋ฅ๋ ๋ ํํธ์์ด์ง ๊ฐ๋ฅ์ฑ์ด ๋์ฃ .
๋ฐ๋ฉด int๋ฅผ string์ผ๋ก ๋ณํํ๋ ๋ฐฉ๋ฒ์ ์ฐพ์๋ณด๋ฉด, ๊ทธ๋ค์ง ๊ฐ๋จํ ๊ฒ์ด ์์ต๋๋ค. ์ ๊ฐ ์ ํธํ๋ ๋ฐฉ๋ฒ์ (์์ ์์ ์ฝ๋์์๋ ์จ๋จน์์ต๋๋ค๋ง) sprintf๋ฅผ ์ฐ๋ ๊ฒ์ธ๋ฐ, ๊ทธ๊ฒ๋ ๋ฒํผ๋ฅผ ์ก๋ ๋ฑ์ ์ฌ์ ์์ ์ด ํ์ํ๋๊น ๊ทธ๋ ๊ฒ ํธํ์ง๋ ์์์. ๊ทธ๋ฌ๋ ๊ทธ๋ฐ ๊ฒฝ์ฐ์๋ 'stringstream'์ ์ฐ๋๊ฒ ๋์ ์๋ ์๊ฒ ์ฃ . Bjarne์ ๋ง์ฒ๋ผ, '๊ฐ๋จํจ'์ด๋ผ๋ ๊ฒฌ์ง์์ ๋ณด๋ฉด ๋ง์ด์์. ๊ฑฐ๊ธฐ๋ค stringstream ํด๋์ค ์์๋ ์ค๋ง๊ฐ์ง ๋ฐ์ดํฐํ์ ์ ๋ค ์ฒ๋ฆฌํ ์ ์๋๋ก ์ค๋ฒ๋ก๋ฉ๋ ์ฐ์ฐ์๋ค์ด ์๋ฉ ๊ตฌํ๋์ด ์์ต๋๋ค. ์ฑ๋ฅ์ ์์ข์์ง ๋ชฐ๋ผ๋, "%lld๊ฐ์ ์ต์ ์ ์ ๋ถ ๊ธฐ์ตํ๊ณ ์์ง ์์๋ ๊ตฌํ์ ํ ์ ์์ผ๋๊น, ํธํ๋ค๋ ๊ฒ์ด์ฃ . (๊ฑฐ๊ธฐ๋ค template์ ์์ด์ฐ๋ฉด ์๋ง ๋ ํธํด์ง๊ฒ๋๋ค ใ ใ )
๊ทธ๋ ๋ค๋ฉด ์ค๋์ ๊ฒฐ๋ก ์...
- int -> string ๋ณํ์ด ํ์ํ ๊ฒฝ์ฐ์๋ stringstream์ ์ฐ๋ ๊ฒ์ด '๊ฐ๋จํ'๋ค.
- ๋ฐ๋์ ๋ณํ์ด ํ์ํ ๊ฒฝ์ฐ์๋ stringstream์ ์จ ๋ด์ผ ์ฝ๋๊ฐ ๊ฐ๋จํด ์ง์ง ์๋๋ค
- ๋ ๊ฐ์ง ๊ฒฝ์ฐ ๋ชจ๋, C API๋ฅผ ์ฐ๋ ๊ฒ์ ๋นํด์๋ ์ฑ๋ฅ์ด ๊ต์ฅํ ๋จ์ด์ง๋ค
์ฑ๋ฅ์ด ๊ฑฑ์ ๋์ ๋ค๋ฉด ๋ญ๋๋ญ๋ ํด๋ C API์ชฝ์ด ๋ซ๊ฒ ์ด์.
[์๋ฃ] ๋ฏธ๋ ๊ณตํ์ฉ ๊ณ์ฐ๊ธฐ
[Uva 10892] Annoying Painting tool ํ์ด.
์ด ํฌ์คํ ์ ์ฟ ํก ํํธ๋์ค ํ๋์ ์ผํ์ผ๋ก, ์ด์ ๋ฐ๋ฅธ ์ผ์ ์ก์ ์์๋ฃ๋ฅผ ์ ๊ณต๋ฐ์ ์ ์์ต๋๋ค.
2007/2008 ACM International Collegiate Programming Contest
University of Ulm Local Contest
Problem A: Annoying painting tool
Maybe you wonder what an annoying painting tool is? First of all, the painting tool we speak of supports only black and white. Therefore, a picture consists of a rectangular area of pixels, which are either black or white. Second, there is only one operation how to change the colour of pixels:
Select a rectangular area of r rows and c columns of pixels, which is completely inside the picture. As a result of the operation, each pixel inside the selected rectangle changes its colour (from black to white, or from white to black).
Initially, all pixels are white. To create a picture, the operation described above can be applied several times. Can you paint a certain picture which you have in mind?
Input Specification
The input contains several test cases. Each test case starts with one line containing four integers n, m, r and c. (1 โค r โค n โค 100, 1 โค c โค m โค 100), The following n lines each describe one row of pixels of the painting you want to create. The ith line consists of m characters describing the desired pixel values of the ith row in the finished painting ('0' indicates white, '1' indicates black).
The last test case is followed by a line containing four zeros.
Output Specification
For each test case, print the minimum number of operations needed to create the painting, or -1 if it is impossible.
Sample Input
3 3 1 1 010 101 010 4 3 2 1 011 110 011 110 3 4 2 2 0110 0111 0000 0 0 0 0
Sample Output
4 6 -1
[๋ฉ๋ฏธ์ค์ต2] ์๋ํธ๋ฐ์ค ์ ๋ ฅ๋ฐ๊ธฐ ๋ฐ ์ฌ๋ผ์ด๋ ์ด์ฉํ๊ธฐ.
์ด ํฌ์คํ ์ ์ฟ ํก ํํธ๋์ค ํ๋์ ์ผํ์ผ๋ก, ์ด์ ๋ฐ๋ฅธ ์ผ์ ์ก์ ์์๋ฃ๋ฅผ ์ ๊ณต๋ฐ์ ์ ์์ต๋๋ค.
ํ ์์๋ค.
์ ๋ฐฉ์ ์ธ!!!!!!
class ๋ธ๋ผ๋ธ๋ผ;
๋ค์ ๋ทฐํด๋์ค์์ ๋ค์ด์๋ก๊ทธ๋ฅผ ์ธํด๋ฃจ๋
๋ค์ด์๋ก๊ทธ์์ ๋ทฐํด๋์ค์์ ์ธํด๋ฃจ๋
๊ณ ๋ก ์ฅ๊ธ์ฅ๊ธ ๋๋ค.
์ด๋ฅผ ํด๊ฒฐํ๊ณ ์ ์ ๋ฐฉ์ ์ธ์ ํ๋ค.
(์ฌ์ค์ ์ ๋ชป ์ง์ฌ์ง ๊ตฌ์กฐ)
๊ทธ๋ฌ๋ MFC์์ ์ด๋ ๊ฒ ์ ๊ณต์ํ๊ธฐ๋๋ฌธ์
์ผ์ข ์ ํธ๋ฆญ์ ์จ์ ์ด๋ฐ ์๋ฌ๋ฅผ ํด๊ฒฐํ๋ ๊ฒ์ด๋ค.
---
์์ฑ์๋ณด๋ค ๋ฆฌ์์ค๊ฐ ๋ง๋ค์ด์ง๋๊ฒ ๋ ๋๋ฆฌ๋ฏ๋ก
๋ง๋ค์ด์ง์ง๋ ์์๋๋ฐ ์ด๊ธฐํํ ๋ ค๋ฉด ์๋ฌ!
๊ทธ๋์ WM_INITDIALOG ๋ฉ์์ง ๋ฐ์. ์ฌ๊ธฐ์ ์ด๊ธฐํ.
์ฐธ๊ณ ๋ก. ON์ด๋ถ๋ ํจ์๋ ๋ฉ์์ง์์ ์จ ํจ์์ด๋ค!!!