Problema 1: 1143. Subsequência comum mais longa - LeetCode
Dadas duas strings text1 e , retorne o comprimento da maior subsequência comumtext2 dessas duas strings . Retorna se não existir nenhuma subsequência comum .0
Uma subsequência de uma string refere-se a uma nova string: é uma nova string formada pela exclusão de alguns caracteres (ou não exclusão de nenhum caractere) da string original sem alterar a ordem relativa dos caracteres.
- Por exemplo,
"ace"é"abcde"uma subsequência de, mas"aec"não"abcde"uma subsequência de.
Uma subsequência comum de duas strings é uma subsequência que ambas as strings têm em comum
Ideia: Definir um dp[i][j] bidimensional, que representa a subsequência comum mais longa das combinações i e j-ésima. Se o mesmo elemento for encontrado durante a travessia, então dp[i][j] = dp [i- 1][j-1]+1, o código é o seguinte:
class Solution {
public:
int longestCommonSubsequence(string text1, string text2) {
vector<vector<int>> dp(text1.size()+1,vector<int>(text2.size()+1,0));
for(int i = 1;i <= text1.size();i++){
for(int j = 1; j <= text2.size();j++){
if(text1[i-1] == text2[j-1]){
dp[i][j] = dp[i-1][j-1] + 1;
}
else{
dp[i][j] = max(dp[i-1][j],dp[i][j-1]);
}
}
}
return dp[text1.size()][text2.size()];
}
} ; Problema 2: 1035. Linhas Disjuntas - LeetCode
Dado um array de inteiros nums , encontre um subarray contínuo com a soma máxima (o subarray contém pelo menos um elemento) e retorne sua soma máxima.
Um subarray é uma parte contígua de um array.
Ideia: Pensar nesta questão é na verdade o mesmo que a maior subsequência comum, que pode ser obtida listando várias fórmulas recursivas. O código específico é o seguinte:
class Solution {
public:
int maxSubArray(vector<int>& nums) {
if(nums.size() == 1) return nums[0];
vector<int> dp(nums.size(),0);
int result = nums[0];
dp[0] = nums[0];
for(int i = 1; i < nums.size(); i++){
dp[i] = max(nums[i],dp[i-1] + nums[i]);
if(dp[i] > result) result = dp[i];
}
return result;
}
};Problema 3: 53. Soma máxima do subarray - LeetCode
Dado um array de inteiros nums , encontre um subarray contínuo com a soma máxima (o subarray contém pelo menos um elemento) e retorne sua soma máxima.
Um subarray é uma parte contígua de um array.
Idéia: encontre a soma máxima da submatriz, dp representa a soma máxima da submatriz quando o i-ésimo elemento está presente, a fórmula recursiva é dp[i]=max(nums[i],dp[i-1]+ nums[i]), O código específico é o seguinte:
class Solution {
public:
int maxSubArray(vector<int>& nums) {
if(nums.size() == 0) return 0;
vector<int> dp(nums.size(),0);
int result = nums[0];
dp[0] = nums[0];
for(int i = 1; i < nums.size(); i++){
dp[i] = max(nums[i],dp[i-1] + nums[i]);
if(dp[i] > result) result = dp[i];
}
return result;
}
};