๋ฌธ์ ํ์
์ ์ ๋ฐฐ์ด nums
๊ฐ ์ฃผ์ด์ง๊ณ , ์ฒซ๋ฒ์งธ ์ธ๋ฑ์ค์์ ์์ํ๋ค.
์ธ๋ฑ์ค์ ์ฃผ์ด์ง ๊ฐ์ ์ต๋๋ก ์ ํํ ์ ์๋ ๊ฐ์ด๋ค.
๋ง์ง๋ง ์ธ๋ฑ์ค์ ๋๋ฌํ ์ ์์ผ๋ฉด true
๋ฅผ ์์ผ๋ฉด false
๋ฅผ ๋ฐํํด์ผํ๋ค.
ํ์ด
1๏ธโฃ
๋ด๊ฐ ๋ ์ฌ๋ฆฐ ์์ด๋์ด๋ ๋ค์๊ณผ ๊ฐ๋ค.
- ํ์ฌ ์์น์์ ๊ฐ์ฅ ๋ฉ๋ฆฌ ๋ธ ์ ์๋ ์ธ๋ฑ์ค๋ฅผ ํ์ธํ๋ค.
- ๋ง์ฝ ๊ฐ์ฅ ๋ฉ๋ฆฌ ๋ธ ์ ์๋ ์์น๊ฐ ๋ฐฐ์ด์ ๋ง์ง๋ง ์ธ๋ฑ์ค (
nums.length - 1
) ์ด์์ด๋ผ๋ฉดtrue
๋ฅผ ๋ฐํํ๋ค.
- ๋ง์ฝ ๊ฐ์ฅ ๋ฉ๋ฆฌ ๋ธ ์ ์๋ ์์น๊ฐ ๋ฐฐ์ด์ ๋ง์ง๋ง ์ธ๋ฑ์ค (
- ํ์ฌ ์์น์์ ๊ฐ์ฅ ๋ฉ๋ฆฌ ๋ธ ์ ์๋ ์ธ๋ฑ์ค ๊น์ง ์ํํ๋ฉด์, ๋ค์์ผ๋ก ๊ฐ์ฅ ๋ฉ๋ฆฌ ๊ฐ ์ ์๋ ์ธ๋ฑ์ค๋ฅผ ์ฐพ๊ณ ์ด๋ํ๋ค.
[2, 3, 1, 1, 4]
๋ฅผ ์์๋ก ๋ค์๋ฉด, ํ์ฌ ์์น 0์ธ 2์์ ๊ฐ ์ ์๋ ์ธ๋ฑ์ค๋ 1๊ณผ 2์ด๊ณ
์ธ๋ฑ์ค 1์ (1 + 3) = 4๋ฒ ์ธ๋ฑ์ค ๊น์ง ๊ฐ ์ ์๊ณ
์ธ๋ฑ์ค 2๋ (2 + 1) = 3๋ฒ ์ธ๋ฑ์ค ๊น์ง ๊ฐ ์ ์์ผ๋ฏ๋ก
1๋ฒ ์ธ๋ฑ์ค๋ก ์ด๋ํ๋ค.- ๋ง์ฝ, ๊ฐ์ฅ ๋ฉ๋ฆฌ ๊ฐ ์ ์๋ ์ธ๋ฑ์ค๊ฐ ์๋ค๋ฉด
false
๋ฅผ ๋ฐํํ๋ค.[3, 2, 1, 0, 4]
๋ฅผ ์์๋ก ๋ค๋ฉด, ํ์ฌ ์์น 0์ธ 3์์ ๊ฐ ์ ์๋ ์ธ๋ฑ์ค๋ 1, 2, 3 ์ธ๋ฐ
1, 2, 3 ์ธ๋ฑ์ค ๋ชจ๋ 3๋ฒ ์ธ๋ฑ์ค ์์น๊น์ง ๋ฐ์ ๋๋ฌํ ์ ์์ผ๋ฏ๋ก ๋ง์ง๋ง ์ธ๋ฑ์ค์ ๋๋ฌํ ์ ์๋ค.
์ ์์ด๋์ด๋ฅผ ๋ฐํ์ผ๋ก ๊ตฌํํด๋ณด์๋ค.
class Solution {
public boolean canJump(int[] nums) {
int start = 0;
while (true) {
int maxJump = start + nums[start];
if (maxJump >= nums.length - 1) {
return true;
}
int maxIdx = start;
for (int i = start + 1; i <= maxJump; i++) {
// ๊ธฐ์กด๋ณด๋ค ๋ ๋ฉ๋ฆฌ ๊ฐ ์ ์๋ ๊ฒฝ์ฐ์๋ง ๊ฐฑ์
if (nums[i] + i > nums[maxIdx] + maxIdx) {
maxIdx = i;
}
}
if (start == maxIdx) {
return false;
}
start = maxIdx;
}
}
}
๊ฒฐ๊ณผ
2๏ธโฃ
๋ก์ง์ด ์กฐ๊ธ ๋ณต์กํ ๊ฒ ๊ฐ์์ ์ ๋ํด์ ๋ค์ ํ์ด๋ดค๋ค.
ํต์ฌ ์์ด๋์ด๋ ๋น์ทํ๋ค.
nums
๋ฐฐ์ด์ ์ํํ๋ฉฐ ๊ฐ์ฅ ๋ฉ๋ฆฌ ๋๋ฌํ ์ ์๋ ์ธ๋ฑ์ค๋ฅผ ๊ณ์ ์
๋ฐ์ดํธํ๋๋ฐ,
์ํํ๋ ์์น๊ฐ ๊ฐ์ฅ ๋ฉ๋ฆฌ ๋๋ฌํ ์ ์๋ ์ธ๋ฑ์ค๋ฅผ ๋์ด๊ฐ๋ฉด, ๋๋ฌํ ์ ์๋ค๋ ์๋ฏธ์ด๋ฏ๋ก false
๋ฅผ ๋ฐํํ๋ค.
class Solution {
public boolean canJump(int[] nums) {
int limit = 0;
for (int i = 0; i < nums.length; i++) {
if (i > limit) {
return false;
}
int jump = nums[i] + i;
if (jump > limit) {
limit = jump;
}
}
return true;
}
}
๊ฒฐ๊ณผ
์๊ฐ์ด ๋จ์ถ๋์๋ค.
๐ ํ๊ณ
์๊ฐํ ์์ด๋์ด๋ฅผ ๋ฐํ์ผ๋ก ๊ตฌํํ ์ฝ๋๊ฐ ํต๊ณผํด์ ๊ธฐ๋ถ์ด ์ข์๋ค.
๊ตฌํํด๋ณด๊ณ , ์ฝ๋๋ฅผ ๊ฐ๋จํ๊ฒ ๋ฆฌํฉํ ๋ง ํด๋ณด๋ ๊ณผ์ ์ ๊ท์ฐฎ๊ณ ์ด๋ ค์ ์ง๋ง ๋๋ฆ ์ฌ๋ฏธ๋ ์์๋ค.(๋ค๋ง ์๊ฐ์ด ๋ น์์ ๋ฟ..)