https://leetcode.com/problems/battleships-in-a-board/

 

Battleships in a Board - LeetCode

Level up your coding skills and quickly land a job. This is the best place to expand your knowledge and get prepared for your next interview.

leetcode.com

[풀이] BFS

 

1XN 또는 NX1 모양의 배를 찾는 문제. 

문제의 조건에 배는 인접하지 않고

valid한 map만 주어진다고 했으므로

BFS를 돌면서 찾은 그룹의 개수가 답이다.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
#include <vector>
#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
 
int N, M;
int dy[4= { 0,0,1,-1 };
int dx[4= { 1,-1,0,0 };
 
struct P {
    int y;
    int x;
    P(int y, int x) :y(y), x(x) {}
};
 
void bfs(int a, int b, vector<vector<char>>& board,vector<vector<bool>>& visit) {
 
    queue<P> q;
    q.push(P(a, b));
    visit[a][b] = 1;
 
    while (!q.empty()) {
 
        int cy = q.front().y;
        int cx = q.front().x;
        q.pop();
        for (int i = 0; i < 4; i++) {
            int ty = cy + dy[i];
            int tx = cx + dx[i];
            if (ty < 0 || tx < 0 || ty >= N || tx >= M || visit[ty][tx] || board[ty][tx] =='.'continue;
            q.push(P(ty, tx));
            visit[ty][tx] = 1;
        }
    }
 
}
 
class Solution {
public:
    int countBattleships(vector<vector<char>>& board) {
        int ans = 0;
        N = board.size();
        M = board[0].size();
        vector<vector<bool>> visit(N);
        for (int i = 0; i < N;i++) visit[i].resize(M);
 
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                if (board[i][j] == 'X' && !visit[i][j]) {
                    bfs(i, j, board, visit);
                    ans++;
                }
            }
        }
 
        return ans;
    }
};
cs

 

 

 

https://github.com/has2/Algorithm/blob/master/leetcode/419.%20Battleships%20in%20a%20Board.cpp

https://leetcode.com/problems/maximum-nesting-depth-of-two-valid-parentheses-strings/

 

Maximum Nesting Depth of Two Valid Parentheses Strings - LeetCode

Level up your coding skills and quickly land a job. This is the best place to expand your knowledge and get prepared for your next interview.

leetcode.com

[풀이] Greedy

 

문제해석이 어려운 문제.

결론적으로 어떤 VPS를 A,B 두 VPS로 나누는 문제. 이 때 depth(A,B)가 최소가 되도록 나누어야 한다.

처음엔 당연히 연속되는 괄호들로 나눠야 한다고 생각했는데

예제를 보니 ()(())() 와 같이 나눠도 된다.

depth를 가장 작게 하려면 겹치는 괄호를 최소한으로 만들어야 한다.그러려면 stack에 여는 괄호를 넣을 때 0,1,0,1 이런식으로 차례대로 넣어주면 된다.닫는 괄호는 여는 괄호와 같은 그룹에 들어가야 하므로 top과 같은 값으로 설정해주면 된다.

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <stack>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <string>
using namespace std;
 
class Solution {
public:
    vector<int> maxDepthAfterSplit(string seq) {
        vector<int> ans(seq.size());
        stack<int> a;
        for (int i = 0; i < seq.size(); i++) {
            char c = seq[i];
 
            if (c == '(') {
                if (a.empty()) a.push(0);
                else a.push(1 - a.top());
                ans[i] = a.top();
            }
            else {
                ans[i] = a.top();
                a.pop();
            }
        }
        return ans;
    }
};
cs
https://github.com/has2/Algorithm/blob/master/leetcode/1111.%20Maximum%20Nesting%20Depth%20of%20Two%20Valid%20Parentheses%20Strings.cpp

 

 

 

 

 

 

https://leetcode.com/problems/sort-integers-by-the-power-value/

 

Sort Integers by The Power Value - LeetCode

Level up your coding skills and quickly land a job. This is the best place to expand your knowledge and get prepared for your next interview.

leetcode.com

[풀이] DP

홀수인경우 kx3 + 1 , 짝수인경우 k/2를 해서 1이 될때까지 만드는 문제

최대 1000개의 값들을 계산해야 하기 때문에 시간복잡도 예상이 안되서 

DP로 풀었는데 완전탐색 해도 풀린다고 한다.

dp 배열을 처음에 4000 크기정도만 해줘도 될거라고 생각했는데 계속 런타임 에러가 나서

500000까지 바꿔주었다. 1000 이하의 k 값을 1로 만드는 과정에서 k가 상당히 커질수도 있는 것 같다.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
  
#include <cstring>
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
class Solution {
public:
 
    int dp[500000];
 
    int sol(int k) {
 
        if (k == 1return 0;
 
        int& ret = dp[k];
        if (ret != 0return ret;
 
        if (k % 2) ret = 1 + sol(3 * k + 1);
        else ret = 1 + sol(k/2);
        
        return ret;
    }
 
    int getKth(int lo, int hi, int k) {
        vector<pair<int,int>> a;
        for (int i = lo; i <= hi; i++) a.push_back(make_pair(sol(i),i));
        
        sort(a.begin(), a.end());
    
        return a[k-1].second;
    }
};
cs

 

https://github.com/has2/Algorithm/blob/master/leetcode/1387.cpp

https://leetcode.com/problems/count-good-nodes-in-binary-tree/

 

Count Good Nodes in Binary Tree - LeetCode

Level up your coding skills and quickly land a job. This is the best place to expand your knowledge and get prepared for your next interview.

leetcode.com

[풀이]

 

1. 재귀를 이용해서 이진트리의 모든 노드들을 순회한다.

2. 파라미터 v는 현재 node의 부모 node들의 value 중에 가장 큰 value를 의미한다.

3. 현재 노드의 value가 v보다 크면 return 값에 1을 더해 주어 결과값에 추가될 수 있도록 한다.

4. root는 무조건 추가되어야 하므로 main에서 -100000을 v에 넣어준다.

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:

	int search(TreeNode* node, int v) {

		if (node == nullptr) return 0;
 
		int ret = 0;
		int cur_max = v;
		if (node->val >= v) {
			cur_max = node->val;
			ret++;
		}
		ret += search(node->left,  cur_max);
		ret += search(node->right, cur_max);

		return ret;
	}

	int goodNodes(TreeNode* root) {
		return search(root, -100000);
	}
};

https://github.com/has2/Algorithm/blob/master/leetcode/1448.cpp

https://leetcode.com/problems/subrectangle-queries/

 

Subrectangle Queries - LeetCode

Level up your coding skills and quickly land a job. This is the best place to expand your knowledge and get prepared for your next interview.

leetcode.com

#include <vector>
#include <algorithm>
using namespace std;
class SubrectangleQueries {
public:
	vector<vector<int>> rec;
	SubrectangleQueries(vector<vector<int>>& rectangle) {
		rec = rectangle;
	}

	void updateSubrectangle(int row1, int col1, int row2, int col2, int newValue) {
		for (int i = row1; i <= row2; i++) {
			fill(rec[i].begin()+col1, rec[i].begin()+col2+1, newValue);
		}
	}

	int getValue(int row, int col) {
		return rec[row][col];
	}
};

+ Recent posts