ํ์๋ฌธ์ ์ ํ ์ค ํ๋์ธ ๋ด์ฐ๋ฆฌ ๊ฐ์๋ฅผ ์ฐพ๋ ๋ฌธ์ ์ด๋ค.
๋ฌธ์
N*N๊ฒฉ์ํ์ด ์ฃผ์ด์ง๊ณ ๋์ด๊ฐ ์ฐ์ฌ์๋ค. ๊ฐ ๊ฒฉ์ํ์ ์ซ์ ์ค ์์ ์ ์ํ์ข์ฐ ์ซ์๋ณด๋ค ํฐ ์ซ์๋ ๋ด์ฐ๋ฆฌ ์ง์ญ์ด๋ค. ๋ด์ฐ๋ฆฌ ์ง์ญ์ด ๋ช ๊ฐ์ธ์ง ์์๋ด๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ณด์.
์ ๋ ฅ์์ |
5 3 7 2 3
3 7 1 6 1
7 2 5 3 4
4 3 6 4 1
8 7 3 5 2
์ถ๋ ฅ์์ |
10
์ ๊ทผ
1. ๊ธฐ์ค์ ์ ์ ํ๊ณ ๋ค ๋ฐฉํฅ์ ํ์ํ๋ค. ์ด์ค for๋ฌธ์ผ๋ก 2์ฐจ์ ๋ฐฐ์ด์ ํ์ํ๋ค. (if๋ฌธ ๋จ๋ฐํ์ง์๊ณ ์์ฑ)
2. ๋ฐฐ์ด์ ๊ฐ ์์๋ฅผ ํ์ํ๋ฉด์ ์ํ์ข์ฐ ํฌ๊ธฐ ๋น๊ต -> ๋๋ณด๋ค ํฐ๊ฒ ์์ผ๋ฉด ๋ด์ฐ๋ฆฌ๋ค -> ์นด์ดํ ํ๋ค.
ํ์ด
์ธ๋ถ์ ์ผ๋ก ํ์ด๋ฅผ ํด๋ณด๋ฉด,
1.
๋ด ์ขํ(๊ธฐ์ค์ ) ์์ ์ํ์ข์ฐ ์ขํ๋ฅผ ๊ตฌํด์ผํ๋ค.
์์ ๊ณผ ์ํ์ข์ฐ ์ซ์๋ฅผ ๋น๊ตํด์ผํ๋ค. ์์ง์ฌ์ผํ ํ๊ณผ ์ด์ ๋ฐฐ์ด๋ก ์์ฑํ๋ค. (์๊ณ๋ฐฉํฅ)
ํ๊ณผ ์ด์ ์ธํธ๋ก ์์ง์ธ๋ค.
์, ํ → ํ ์ด๋
ํ = [์, ์ฐ, ํ, ์ข] → dx = [-1, 0, 1, 0]
์ข, ์ฐ → ์ด ์ด๋
์ด = [์, ์ฐ, ํ, ์ข] → dy = [0, 1, 0, -1]
2.
๋ด ์ขํ(๊ธฐ์ค์ )์ i๊ณผ j๊ฐ ์ด์คfor๋ฌธ์ ๋๋ฉด์ ์ขํ๋ฅผ ๊ตฌํ๋ค.
3.
์ํ์ข์ฐ, 4๋ฒ k for๋ฌธ ๋์์ผํ๋ค.
๋ด ์ขํ์ ๊ฐ๊ณผ ๋ค ๋ฐฉํฅ์ ์ขํ ๋น๊ตํด์, ๋ค ๋ฐฉํฅ์ด ๋ ์์ผ๋ฉด answer++ํ๋ค.
let nx = i+dx[k]; → i์ -1์ด๋ 1์ ๋ํด ํ์ ์ฎ๊ธด๋ค (์ํ์ด๋)
let ny = j+dy[k]; → j์ -1์ด๋ 1์ ๋ํด ์ด์ ์ฎ๊ธด๋ค (์ข์ฐ์ด๋)
์ → ํ์ด -1๋ก ์ด๋ํ ๋ ์ด์ 0 ์ด๋ (์ด ์ด๋์์)
ํ → ํ์ด 1๋ก ์ด๋ํ ๋ ์ด์ 0 ์ด๋ (์ด ์ด๋์์)
์ข → ์ด์ด 1 ์ด๋ํ ๋ ํ์ 0 ์ด๋ (ํ ์ด๋์์)
์ฐ → ์ด์ด -1 ์ด๋ํ ๋ ์ด์ 0 ์ด๋ (ํ ์ด๋์์)
4.
flag๋ ๋ด์ฐ๋ฆฌ์ธ์ง ์๋์ง ์ฒดํฌํ๋ค.
flag๊ฐ 0์ด๋ฉด answer ์นด์ดํ ์๋๊ณ , 1์ด๋ฉด ์นด์ดํ ๋๋ค.
์ฝ๋
function solution(arr){
let answer = 0; //์นด์ดํ
ํด์ผ๋๋๊น 0์ผ๋ก
let n = arr.length;
let dx = [-1, 0, 1, 0];
let dy = [0, 1, 0, -1];
for(let i=0; i<n; i++){
for(let j=0; j<n; j++){
let flag=1;
for(let k=0; k<4; k++){ // 4๋ฐฉํฅ์ด๋ผ์ 4๋ฒ๋๋๋ก ๋ง์ถค
let nx = i+dx[k]; // ๊ฐ๋ ค๊ณ ํ๋ ๋ฐฉํฅ ํ ์ขํ
let ny = j+dy[k]; // ๊ฐ๋ ค๊ณ ํ๋ ๋ฐฉํฅ ์ด ์ขํ
if(nx>=0 && nx<n && ny>=0 && ny<n && arr[nx][ny] >= arr[i][j]){
// arr[nx][ny]์ํ์ข์ฐ์ขํ >= ํ์ฌ์ง์ ์ขํ arr[i][j]
// nx>=0 && nx<n && ny>=0 && ny<n๋
// ๋ด ์ํ์ข์ฐ๊ฐ ๋ค๋ฐฉํฅ์ผ๋ก ์กด์ฌํ์ง ์๋ ๊ฒฝ์ฐ๋ ์์ผ๋ ๊ทธ ๊ฒฝ์ฐ๋ ์ ์ธํ๋ ์กฐ๊ฑด
// ํ์ฌ์ง์ ์ขํ๋ณด๋ค ํฐ๊ฒ ์์ผ๋ฉด ๋ด์ฐ๋ฆฌ๊ฐ ์๋๋ค. ์ด๊ฑธ ํ์ธํ๊ธฐ ์ํด์ flag๋ณ์ ์์ฑํด์ค ๊ฒ
flag=0;
break; // k for๋ฌธ ๋ฉ์ถค
}
}
if(flag) answer++;
// ์ํ์ข์ฐ ๋ค ๋๊ณ ๋์์ flag๊ฐ ๊ทธ๋๋ก์ด๋ฉด answer++ ํด์ค๋ค
}
}
return answer;
}
let arr = [[5, 3, 7, 2, 3],
[3, 7, 1, 6, 1],
[7, 2, 5, 3, 4],
[4, 3, 6, 4, 1],
[8, 7, 3, 5, 2]];
console.log(solution(arr));
'๐กAlgorithm > ๋ฌธ์ ํ๊ธฐ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
JS์๊ณ ๋ฆฌ์ฆ | ์ ํจํ ํฐ๋ฆฐ๋๋กฌ(๋ฌธ์์ดํ์+์กฐ๊ฑด) (0) | 2021.05.05 |
---|---|
JS์๊ณ ๋ฆฌ์ฆ | ํ๋ฌธ ๋ฌธ์์ด(๋ฌธ์์ด ํ์) (0) | 2021.05.03 |
JS์๊ณ ๋ฆฌ์ฆ | ๊ฒฉ์ํ ์ต๋ํฉ(2์ฐจ์ ๋ฐฐ์ด) (0) | 2021.05.01 |
JS์๊ณ ๋ฆฌ์ฆ | ๋ฑ์๊ตฌํ๊ธฐ (์ด์คfor๋ฌธ, Array.from) (0) | 2021.04.27 |
JS์๊ณ ๋ฆฌ์ฆ | ์ ์๊ณ์ฐ (0) | 2021.04.26 |