LeetCode 329~336题
作者:互联网
第三百二十九题:
class Solution {
public:
int n, m;
vector<vector<int>> f, w;
int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
int dp(int x, int y) {
auto& v = f[x][y];
if (v != -1) return v;
v = 1;
for (int i = 0; i < 4; i ++ ) {
int a = x + dx[i], b = y + dy[i];
if (a >= 0 && a < n && b >= 0 && b < m && w[x][y] < w[a][b])
v = max(v, dp(a, b) + 1);
}
return v;
}
int longestIncreasingPath(vector<vector<int>>& matrix) {
if (matrix.empty() || matrix[0].empty()) return 0;
w = matrix;
n = w.size(), m = w[0].size();
f = vector<vector<int>>(n, vector<int>(m, -1));
int res = 0;
for (int i = 0; i < n; i ++ )
for (int j = 0; j < m; j ++ )
res = max(res, dp(i, j));
return res;
}
};
class Solution {
public int[][] dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
public int rows, columns;
public int longestIncreasingPath(int[][] matrix) {
if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
return 0;
}
rows = matrix.length;
columns = matrix[0].length;
int[][] outdegrees = new int[rows][columns];
for (int i = 0; i < rows; ++i) {
for (int j = 0; j < columns; ++j) {
for (int[] dir : dirs) {
int newRow = i + dir[0], newColumn = j + dir[1];
if (newRow >= 0 && newRow < rows && newColumn >= 0 && newColumn < columns && matrix[newRow][newColumn] > matrix[i][j]) {
++outdegrees[i][j];
}
}
}
}
Queue<int[]> queue = new LinkedList<int[]>();
for (int i = 0; i < rows; ++i) {
for (int j = 0; j < columns; ++j) {
if (outdegrees[i][j] == 0) {
queue.offer(new int[]{i, j});
}
}
}
int ans = 0;
while (!queue.isEmpty()) {
++ans;
int size = queue.size();
for (int i = 0; i < size; ++i) {
int[] cell = queue.poll();
int row = cell[0], column = cell[1];
for (int[] dir : dirs) {
int newRow = row + dir[0], newColumn = column + dir[1];
if (newRow >= 0 && newRow < rows && newColumn >= 0 && newColumn < columns && matrix[newRow][newColumn] < matrix[row][column]) {
--outdegrees[newRow][newColumn];
if (outdegrees[newRow][newColumn] == 0) {
queue.offer(new int[]{newRow, newColumn});
}
}
}
}
}
return ans;
}
}
class Solution:
DIRS = [(-1, 0), (1, 0), (0, -1), (0, 1)]
def longestIncreasingPath(self, matrix: List[List[int]]) -> int:
if not matrix:
return 0
rows, columns = len(matrix), len(matrix[0])
outdegrees = [[0] * columns for _ in range(rows)]
queue = collections.deque()
for i in range(rows):
for j in range(columns):
for dx, dy in Solution.DIRS:
newRow, newColumn = i + dx, j + dy
if 0 <= newRow < rows and 0 <= newColumn < columns and matrix[newRow][newColumn] > matrix[i][j]:
outdegrees[i][j] += 1
if outdegrees[i][j] == 0:
queue.append((i, j))
ans = 0
while queue:
ans += 1
size = len(queue)
for _ in range(size):
row, column = queue.popleft()
for dx, dy in Solution.DIRS:
newRow, newColumn = row + dx, column + dy
if 0 <= newRow < rows and 0 <= newColumn < columns and matrix[newRow][newColumn] < matrix[row][column]:
outdegrees[newRow][newColumn] -= 1
if outdegrees[newRow][newColumn] == 0:
queue.append((newRow, newColumn))
return ans
var (
dirs = [][]int{[]int{-1, 0}, []int{1, 0}, []int{0, -1}, []int{0, 1}}
rows, columns int
)
func longestIncreasingPath(matrix [][]int) int {
if len(matrix) == 0 || len(matrix[0]) == 0 {
return 0
}
rows, columns = len(matrix), len(matrix[0])
outdegrees := make([][]int, rows)
for i := 0; i < rows; i++ {
outdegrees[i] = make([]int, columns)
}
for i := 0; i < rows; i++ {
for j := 0; j < columns; j++ {
for _, dir := range dirs {
newRow, newColumn := i + dir[0], j + dir[1]
if newRow >= 0 && newRow < rows && newColumn >= 0 && newColumn < columns && matrix[newRow][newColumn] > matrix[i][j] {
outdegrees[i][j]++
}
}
}
}
queue := [][]int{}
for i := 0; i < rows; i++ {
for j := 0; j < columns; j++ {
if outdegrees[i][j] == 0 {
queue = append(queue, []int{i, j})
}
}
}
ans := 0
for len(queue) != 0 {
ans++
size := len(queue)
for i := 0; i < size; i++ {
cell := queue[0]
queue = queue[1:]
row, column := cell[0], cell[1]
for _, dir := range dirs {
newRow, newColumn := row + dir[0], column + dir[1]
if newRow >= 0 && newRow < rows && newColumn >= 0 && newColumn < columns && matrix[newRow][newColumn] < matrix[row][column] {
outdegrees[newRow][newColumn]--
if outdegrees[newRow][newColumn] == 0 {
queue = append(queue, []int{newRow, newColumn})
}
}
}
}
}
return ans
}
第三百三十题:
class Solution {
public:
int minPatches(vector<int>& nums, int n) {
long long x = 1;
int i = 0, res = 0;
while (x <= n) {
if (i < nums.size() && nums[i] <= x) x += nums[i ++ ];
else {
x += x;
res ++ ;
}
}
return res;
}
};
class Solution {
public int minPatches(int[] nums, int n) {
int patches = 0;
long x = 1;
int length = nums.length, index = 0;
while (x <= n) {
if (index < length && nums[index] <= x) {
x += nums[index];
index++;
} else {
x *= 2;
patches++;
}
}
return patches;
}
}
class Solution:
def minPatches(self, nums: List[int], n: int) -> int:
patches, x = 0, 1
length, index = len(nums), 0
while x <= n:
if index < length and nums[index] <= x:
x += nums[index]
index += 1
else:
x <<= 1
patches += 1
return patches
func minPatches(nums []int, n int) (patches int) {
for i, x := 0, 1; x <= n; {
if i < len(nums) && nums[i] <= x {
x += nums[i]
i++
} else {
x *= 2
patches++
}
}
return
}
第三百三十一题:
class Solution {
public:
int k;
string s;
bool isValidSerialization(string _s) {
k = 0;
s = _s + ',';
if (!dfs()) return false;
return k == s.size();
}
bool dfs() {
if (k == s.size()) return false;
if (s[k] == '#') return k += 2, true;
while (s[k] != ',') k ++ ;
k ++ ;
return dfs() && dfs();
}
};
class Solution {
public boolean isValidSerialization(String preorder) {
// number of available slots
int slots = 1;
int n = preorder.length();
for(int i = 0; i < n; ++i) {
if (preorder.charAt(i) == ',') {
// one node takes one slot
--slots;
// no more slots available
if (slots < 0) return false;
// non-empty node creates two children slots
if (preorder.charAt(i - 1) != '#') slots += 2;
}
}
// the last node
slots = (preorder.charAt(n - 1) == '#') ? slots - 1 : slots + 1;
// all slots should be used up
return slots == 0;
}
}
class Solution:
def isValidSerialization(self, preorder: str) -> bool:
num=1
preorder=preorder.split(',')
for i in preorder:
if num==0:return False
if i =='#':
num-=1
if num<0:return False
else:
num+=1
if num==0:return True
else:return False
func isValidSerialization(preorder string) bool {
// 每个非空节点都有两个出度,每个结点都有一个入度(根节点除外), 出度==入度+1
splits := strings.Split(preorder, ",")
edge := 1
for _, str := range splits {
edge--
if edge < 0 {
break
}
if str != "#" {
edge += 2
}
}
return edge == 0
}
第三百三十二题:
class Solution {
public:
unordered_map<string, multiset<string>> g;
vector<string> ans;
vector<string> findItinerary(vector<vector<string>>& tickets) {
for (auto& e: tickets) g[e[0]].insert(e[1]);
dfs("JFK");
reverse(ans.begin(), ans.end());
return ans;
}
void dfs(string u) {
while (g[u].size()) {
auto ver = *g[u].begin();
g[u].erase(g[u].begin());
dfs(ver);
}
ans.push_back(u);
}
};
class Solution {
Map<String, PriorityQueue<String>> map = new HashMap<String, PriorityQueue<String>>();
List<String> itinerary = new LinkedList<String>();
public List<String> findItinerary(List<List<String>> tickets) {
for (List<String> ticket : tickets) {
String src = ticket.get(0), dst = ticket.get(1);
if (!map.containsKey(src)) {
map.put(src, new PriorityQueue<String>());
}
map.get(src).offer(dst);
}
dfs("JFK");
Collections.reverse(itinerary);
return itinerary;
}
public void dfs(String curr) {
while (map.containsKey(curr) && map.get(curr).size() > 0) {
String tmp = map.get(curr).poll();
dfs(tmp);
}
itinerary.add(curr);
}
}
class Solution:
def findItinerary(self, tickets: List[List[str]]) -> List[str]:
def dfs(curr: str):
while vec[curr]:
tmp = heapq.heappop(vec[curr])
dfs(tmp)
stack.append(curr)
vec = collections.defaultdict(list)
for depart, arrive in tickets:
vec[depart].append(arrive)
for key in vec:
heapq.heapify(vec[key])
stack = list()
dfs("JFK")
return stack[::-1]
func findItinerary(tickets [][]string) []string {
var (
m = map[string][]string{}
res []string
)
for _, ticket := range tickets {
src, dst := ticket[0], ticket[1]
m[src] = append(m[src], dst)
}
for key := range m {
sort.Strings(m[key])
}
var dfs func(curr string)
dfs = func(curr string) {
for {
if v, ok := m[curr]; !ok || len(v) == 0 {
break
}
tmp := m[curr][0]
m[curr] = m[curr][1:]
dfs(tmp)
}
res = append(res, curr)
}
dfs("JFK")
for i := 0; i < len(res)/2; i++ {
res[i], res[len(res) - 1 - i] = res[len(res) - 1 - i], res[i]
}
return res
}
第三百三十四题:
class Solution {
public:
bool increasingTriplet(vector<int>& nums) {
vector<int> q(2, INT_MAX);
for (auto a: nums) {
int k = 2;
while (k > 0 && q[k - 1] >= a) k -- ;
if (k == 2) return true;
q[k] = a;
}
return false;
}
};
class Solution {
public boolean increasingTriplet(int[] nums) {
int one = Integer.MAX_VALUE,two = Integer.MAX_VALUE;
for(int three : nums){
if(three > two) return true;
else if(three <= one) one = three;
else two = three;
// if(three > one && three < two) two = three;
}
return false;
}
}
class Solution:
def increasingTriplet(self, nums: List[int]) -> bool:
r1, r2 = sys.maxsize, sys.maxsize
for n in nums :
if n <= r1 : r1 = n
elif n <= r2 : r2 = n
else : return True
return False
func increasingTriplet(nums []int) bool {
m1, m2 := math.MaxInt64, math.MaxInt64
for i := 0; i < len(nums); i++ {
if m1 >= nums[i] {
m1 = nums[i]
} else if m2 >= nums[i] {
m2 = nums[i]
} else {
return true
}
}
return false
}
第三百三十五题:
class Solution {
public:
bool isSelfCrossing(vector<int>& x) {
int n = x.size();
if (n <= 3) return false;
for (int i = 3; i < n; i ++ ) {
if (x[i - 1] <= x[i - 3] && x[i] >= x[i - 2]) return true;
if (i >= 4 && x[i - 3] == x[i - 1] && x[i] + x[i - 4] >= x[i - 2]) return true;
if (i >= 5 && x[i - 3] >= x[i - 1] && x[i - 1] + x[i - 5] >= x[i - 3] && x[i - 2] >= x[i - 4] && x[i - 4] + x[i] >= x[i - 2])
return true;
}
return false;
}
};
class Solution {
public boolean isSelfCrossing(int[] x) {
if(x.length <= 3)
return false;
int i, xl = x[1], yl = x[0], px = 0, py = 0;
//检测a类型路径的变化趋势
for(i = 2; i < x.length; i++){
if((i & 0x1) == 1){
if(x[i] <= xl){
//a ---> b
if(xl - px <= x[i])
yl -= py;
xl = x[i];
break;
}
//用px保存xl的旧值
px = xl;
xl = x[i];
}else {
if(x[i] <= yl){
//a ---> b
if(yl - py <= x[i])
xl -= px;
yl = x[i];
break;
}
//用py保存yl的旧值
py = yl;
yl = x[i];
}
}
//检测b类型路径的变化趋势
for(i++; i < x.length; i++){
if((i & 0x1) == 1 && x[i] < xl){
xl = x[i];
}else if(x[i] < yl){
yl = x[i];
}else{
return true;
}
}
return false;
}
}
class Solution:
def isSelfCrossing(self, x) -> bool:
if len(x) < 4:return False
if len(x) == 4:return True if x[3] >= x[1] and x[2] <= x[0] else False
for i in range(3, len(x)):
if x[i] >= x[i-2] and x[i-1] <= x[i-3]:
return True
if i > 3 and x[i-1] == x[i-3] and x[i-4] + x[i] >= x[i-2]:
return True
if i > 4 and x[i-3]-x[i-5] <= x[i-1] <= x[i-3] and x[i-2]-x[i-4] <= x[i] <= x[i-2] and x[i-2] > x[i-4]:
return True
return False
第三百三十六题:
class Solution {
public:
bool check(string& s) {
for (int i = 0, j = s.size() - 1; i < j; i ++, j -- )
if (s[i] != s[j])
return false;
return true;
}
vector<vector<int>> palindromePairs(vector<string>& words) {
unordered_map<string, int> hash;
for (int i = 0; i < words.size(); i ++ ) {
auto w = words[i];
reverse(w.begin(), w.end());
hash[w] = i;
}
vector<vector<int>> res;
for (int i = 0; i < words.size(); i ++ ) {
auto w = words[i];
for (int j = 0; j <= w.size(); j ++ ) {
auto left = w.substr(0, j), right = w.substr(j);
if (check(right) && hash.count(left) && hash[left] != i) res.push_back({i, hash[left]});
if (check(left) && hash.count(right) && hash[right] != i && w.size() != words[hash[right]].size())
res.push_back({hash[right], i});
}
}
return res;
}
};
class Solution {
List<String> wordsRev = new ArrayList<String>();
Map<String, Integer> indices = new HashMap<String, Integer>();
public List<List<Integer>> palindromePairs(String[] words) {
int n = words.length;
for (String word: words) {
wordsRev.add(new StringBuffer(word).reverse().toString());
}
for (int i = 0; i < n; ++i) {
indices.put(wordsRev.get(i), i);
}
List<List<Integer>> ret = new ArrayList<List<Integer>>();
for (int i = 0; i < n; i++) {
String word = words[i];
int m = words[i].length();
if (m == 0) {
continue;
}
for (int j = 0; j <= m; j++) {
if (isPalindrome(word, j, m - 1)) {
int leftId = findWord(word, 0, j - 1);
if (leftId != -1 && leftId != i) {
ret.add(Arrays.asList(i, leftId));
}
}
if (j != 0 && isPalindrome(word, 0, j - 1)) {
int rightId = findWord(word, j, m - 1);
if (rightId != -1 && rightId != i) {
ret.add(Arrays.asList(rightId, i));
}
}
}
}
return ret;
}
public boolean isPalindrome(String s, int left, int right) {
int len = right - left + 1;
for (int i = 0; i < len / 2; i++) {
if (s.charAt(left + i) != s.charAt(right - i)) {
return false;
}
}
return true;
}
public int findWord(String s, int left, int right) {
return indices.getOrDefault(s.substring(left, right + 1), -1);
}
}
class Solution:
def palindromePairs(self, words: List[str]) -> List[List[int]]:
def findWord(s: str, left: int, right: int) -> int:
return indices.get(s[left:right+1], -1)
def isPalindrome(s: str, left: int, right: int) -> bool:
return (sub := s[left:right+1]) == sub[::-1]
n = len(words)
indices = {word[::-1]: i for i, word in enumerate(words)}
ret = list()
for i, word in enumerate(words):
m = len(word)
for j in range(m + 1):
if isPalindrome(word, j, m - 1):
leftId = findWord(word, 0, j - 1)
if leftId != -1 and leftId != i:
ret.append([i, leftId])
if j and isPalindrome(word, 0, j - 1):
rightId = findWord(word, j, m - 1)
if rightId != -1 and rightId != i:
ret.append([rightId, i])
return ret
func palindromePairs(words []string) [][]int {
wordsRev := []string{}
indices := map[string]int{}
n := len(words)
for _, word := range words {
wordsRev = append(wordsRev, reverse(word))
}
for i := 0; i < n; i++ {
indices[wordsRev[i]] = i
}
ret := [][]int{}
for i := 0; i < n; i++ {
word := words[i]
m := len(word)
if m == 0 {
continue
}
for j := 0; j <= m; j++ {
if isPalindrome(word, j, m - 1) {
leftId := findWord(word, 0, j - 1, indices)
if leftId != -1 && leftId != i {
ret = append(ret, []int{i, leftId})
}
}
if j != 0 && isPalindrome(word, 0, j - 1) {
rightId := findWord(word, j, m - 1, indices)
if rightId != -1 && rightId != i {
ret = append(ret, []int{rightId, i})
}
}
}
}
return ret
}
func findWord(s string, left, right int, indices map[string]int) int {
if v, ok := indices[s[left:right+1]]; ok {
return v
}
return -1
}
func isPalindrome(s string, left, right int) bool {
for i := 0; i < (right - left + 1) / 2; i++ {
if s[left + i] != s[right - i] {
return false
}
}
return true
}
func reverse(s string) string {
n := len(s)
b := []byte(s)
for i := 0; i < n/2; i++ {
b[i], b[n-i-1] = b[n-i-1], b[i]
}
return string(b)
}
标签:return,matrix,int,336,len,++,&&,329,LeetCode 来源: https://blog.csdn.net/weixin_44169596/article/details/113841338