์๋๋๋ฌด๊ฐ 2๊ฐ ์์ ๋ ์ต๋ W๊น์ง ๋ ์ฌ์ด๋ฅผ ์ค๊ณ ๊ฐ๋ฉด์ ์ผ๋ง๋ ๋ง์ ์๋๋ฅผ ์ป์ ์ ์๋์ง๋ฅผ ๊ตฌํด์ผ ํ๋ค.
๋ฌธ์ ์ ์์ ๋ฅผ ๋ณด๊ณ ์ง๊ด์ ์ผ๋ก ๊ตฌํด๋ณด๋ฉด ์ฒ์์๋ 1๋ฒ ์๋๋๋ฌด ์์น์ ๊ทธ๋๋ก ์ ์๋๋ค. ๋น๋ก 2๋ฒ ์๋๋๋ฌด์์ ๋จ์ด์ง๊ธด ํ์ง๋ง ๊ทธ ๋ค์ 2,3๋ฒ ์งธ ์๋๊ฐ 1๋ฒ์์ ๋จ์ด์ง๊ธฐ ๋๋ฌธ์ด๋ค. ๊ทธ๋ฆฌ๊ณ ๋์ 2๋ฒ ์๋๋๋ฌด๋ก ์์น๋ฅผ ํ ๋ฒ ์ฎ๊ธด๋ค. ์ด์ 2๋ฒ ์๋๋๋ฌด์ ์๋ 2๊ฐ๋ฅผ ๋ฐ๋๋ค. ๊ทธ๋ฆฌ๊ณ ๋ค์ 1๋ฒ ์๋๋๋ฌด๋ก ์์น๋ฅผ ์ฎ๊ธด๋ค. ์ด์ ์๋๋ฅผ ์ต๋ 6๊ฐ ์ป์ ์ ์๋ค.
๋ช ๋ฒ์งธ์ ์์น๋ฅผ ๋ฐ๊พธ๋๋์ ๋ฐ๋ผ ์ป์ ์ ์๋ ์๋์ ๊ฐ์๋ ๋ฌ๋ผ์ง ์ ์๋ค. ๋ง์ผ ํ ๋ฒ๋ ๋ฐ๊พธ์ง ์๊ณ ๊ณ์ 1๋ฒ ์๋๋๋ฌด์ ์์น์ ์๋ค๋ฉด(์์์ 1๋ฒ ์๋๋๋ฌด์ด๋ค) ์ต๋ ์ป์ ์ ์๋ ์๋์ ๊ฐ์๋ 4๊ฐ์ผ ๊ฒ์ด๋ค. ๋ง์ฝ ์ฒ์ ๋จ์ด์ง๋ ์๋๋ฅผ ๋ฐ๊ธฐ ์ํด ์์ํ์๋ง์ ๋ฐ๋ก 2๋ฒ ์๋๋๋ฌด๋ก ์์น๋ฅผ ๋ฐ๊ฟจ๋ค๊ฐ ๋ค์ 2,3๋ฒ ์๋๋ฅผ ์ป๊ธฐ ์ํด 1๋ฒ์ผ๋ก ๋์์ค๊ฒ ๋๋ฉด ์ต๋ ๋ฐฉํฅ์ ๋ฐ๊ฟ ์ ์๋ ๊ฐ์ ๋ค ์ฑ์ ๊ธฐ ๋๋ฌธ์ ๋ ์ด์ ์์น๋ ๋ณ๊ฒฝํ ์ ์๊ณ ์ต๋ ์๋๋ 5๊ฐ๊ฐ ๋๋ค.
๊ฒฐ๊ตญ ์ธ์ ๋ฐฉํฅ์ ๋ฐ๊ฟ ๊ฒ์ธ๊ฐ๊ฐ ์ค์
๋ง์ฝ ์์น๋ฅผ ๋ฑ ํ ๋ฒ๋ง ๋ฐ๊พผ๋ค๊ณ ๊ฐ์ ํด๋ณด์. 4๋ฒ์งธ ์๋๋ฅผ ๋ฐ๊ธฐ ์ํด์ 2๋ฒ์ผ๋ก ์์น๋ฅผ ์ฎ๊ธฐ๊ฒ ๋๋ค. ์ด๋๊น์ง ์ป์ ์๋๋ 1๋ฒ ์๋ 2๊ฐ์ด๋ค. ์์น๋ฅผ ๋ฐ๊พธ๊ธฐ ์ ๊น์ง๋ ๋จ ํ ๋ฒ๋ ์์น๋ฅผ ๋ณ๊ฒฝํ ์ ์ด ์๋ ์ํ๋ค. ์ฌ๊ธฐ์ ์์น๋ฅผ ๋ฐ๊พธ๊ฒ ๋๋ฉด ์ด์ ์์น ๋ณ๊ฒฝ ํ์๊ฐ 1๋ก ์ฆ๊ฐํ๋ค.
์ผ์ชฝ์ ํ ๋ฒํธ๋ ์์น๋ฅผ ๋ณ๊ฒฝํ ํ์, ์ด ๋ฒํธ๋ ๋ช ๋ฒ์งธ ์๋๊ฐ ๋จ์ด์ง๋๊ฐ๋ฅผ ๋ํ๋ธ๋ค. 3๋ฒ์งธ๊น์ง๋ ์์น๋ฅผ ํ ๋ฒ๋ ๋ณ๊ฒฝํ์ง ์์์ผ๋ฏ๋ก 0ํ์ ์๊ณ , 4๋ฒ์งธ ์๋๋ฅผ ๋ฐ๊ธฐ ์ํด 1๋ฒ ์์น๋ฅผ ๋ณ๊ฒฝํ๋ฏ๋ก 1ํ์ผ๋ก ์ฎ๊ธฐ๊ฒ ๋๋ค. ๋ฐฐ์ด์ ๊ฐ์ผ๋ก ๋ํ๋ด๋ฉด ์๋์ ๊ฐ๋ค
arr[1][4] = arr[0][3] + 1
์ด๋ ๊ทธ๋ฆผ์์์ฒ๋ผ ์๋๋ฅผ ์ป๋๋ค๋ฉด 1์ด ์ถ๊ฐ๋์ง๋ง ์ป์ง ๋ชปํ๋ค๋ฉด ์๋ฌด๊ฒ๋ ์ถ๊ฐ๋์ง ์๋๋ค.
์ด์ ๋ค์ 1๋ฒ ์๋๋๋ฌด์ ์๋๋ฅผ ์ป๊ธฐ ์ํด 6๋ฒ์งธ์ ์์น๋ฅผ ๋ค์ ๋ณ๊ฒฝํ๋ค๊ณ ํด๋ณด์. 2๋ฒ ์์น๋ฅผ ๋ณ๊ฒฝํ๊ธฐ ๋๋ฌธ์ 2ํ์ผ๋ก ์ฎ๊ฒจ์ง๊ฒ ๋๊ณ , 6๋ฒ์งธ ํ์ผ๋ก ๊ฐ๊ฒ ๋๋ค. ์์ ์์ ๊ทธ๋๋ก ๊ฐ์ ธ์์ ๋์ ํ๋ฉด ์๋์ ๊ฐ๋ค.
arr[2][6] = arr[1][5] + 1
7๋ฒ์งธ ์๋ ์ญ์ 1๋ฒ ์์น์์ ๋จ์ด์ง๋ฏ๋ก ์ต๋ ๊ตฌํ ์ ์๋ ์๋ 6๊ฐ๋ ๋ง์ง๋ง ์ด์์ ์ป์ ์ ์๊ฒ ๋๋ค.
i
๋ฅผ ๋จ์ด์ง๋ ์๋์ ๋ฒํธ, j
๋ฅผ ๋ฐ๊พผ ์์น์ ํ์๋ก ํ์ ๋ dp๋ก ๋ํ๋ด๋ฉด ๋ค์๊ณผ ๊ฐ์์ง ์ ์๋ค.
์์น๋ฅผ ๋ณ๊ฒฝํ์ง ์์์ ๋ : dp[i][j] = dp[i][j-1]
์์น๋ฅผ ๋ณ๊ฒฝํ์ ๋ : dp[i][j] = dp[i-1][j-1]
๊ฐ ์์น์์ ์๋๋ฅผ ์ป์ ์ ์๋ค๋ฉด 1์ ๋ํ๋ค.
# ์๋๋๋ฌด
T, W = map(int, input().split())
nums = [int(input()) for _ in range(T)]
rem = 1
dp = [[0]*(T+1) for _ in range(W+1)]
for i in range(1, T+1):
if nums[i-1]%2 == rem:
dp[0][i] = dp[0][i-1]+1
else:
dp[0][i] = dp[0][i-1]
for i in range(1, W+1):
rem = (rem+1)%2
for j in range(i, T+1):
dp[i][j] = max(dp[i][j-1], dp[i-1][j-1])
if nums[j-1]%2 == rem:
dp[i][j] += 1
print(max(list(map(list, zip(*dp)))[-1]))