structure Considération programmation clairement dynamique commence autour de la comparaison, la même pensée quand la première approche descendante, une ascendante puis inverse + double boucle, dérivée programmation dynamique.
343. Pause entier
méthode de recherche récursive + Plan
de manière descendante
// 递归+记忆化搜索
class Solution {
private:
vector<int> memo;
int max3(int a, int b, int c){
return max(a, max(b,c));
}
int breakInteger(int n){
if(n==1)
return 1;
if(memo[n] != -1)
return memo[n]; //返回记录
int res = -1;
for(int i=1; i<=n-1; ++i)
res = max3(res, i * (n-i) ,i * breakInteger(n-i)); // 重叠子问题
memo[n] = res;
return res;
}
public:
int integerBreak(int n) {
assert(n>=2); //出于严谨考虑,让n>=2,其实根据提议要至少2部分。
// 调用这个函数的时候,对memo进行初始化
memo = vector<int>(n+1, -1); //n的问题,初始化为n+1个元素)
return breakInteger(n); //递归方法
}
};
Dynamique de programmation Procédé de
bas en haut
complexité vu de l'algorithme est O (n ^ 2)
// 我自己写的动态规划!
class Solution {
private:
vector<int> memo;
public:
int integerBreak(int n) {
assert(n>=2); //出于严谨考虑,让n>=2,其实根据提议要至少2部分。
// 调用这个函数的时候,对memo进行初始化
memo = vector<int>(n+1, -1); //n的问题,初始化为n+1个元素)
memo[1] = 1;
memo[2] = 1;
for(int i=3; i<=n; ++i){
int res = -1; //用于之后计算memo[i]的最大值
for(int j=1; j<=i-1; ++j){
int temp = max(j*memo[i-j], j*(i-j)); //找出当前这步最大
if(temp>res)
res=temp;
}
memo[i] = res;
}
return memo[n];
}
};
optimisation des enseignants: la compression est en outre nécessaire max (note de service [i])!
// 老师写的动态规划!
class Solution {
private:
int max3(int a, int b, int c){
return max(a, max(b,c));
}
public:
int integerBreak(int n) {
assert(n>=2);
vector<int> memo(n+1,-1);
memo[1] = 1;
for(int i=2; i<=n; ++i)
for(int j=1; j<=i-1; ++j)
// //找出当前这步最大
memo[i] = max3(memo[i], j*memo[i-j], j*(i-j) );
return memo[n];
}
};
Comprendre: état, état de transition
Etat - la définition de la fonction faire (quelle fonction au nom de)
la transition de l' état - Comment fonctionnent
198 Maison Robber
Initiale récursive:
définition de la fonction (état): Étant donné nums de vol qualifié [index, ... nums.size () ] dans la gamme de toute la maison
class Solution {
private:
// memo[i]表示考虑抢劫nums[i...n]所能获得的最大收益
// memo[i]和tryRob状态的定义是一致的!
vector<int> memo;
// 函数定义(状态):考虑抢劫nums[index, .... nums.size()]范围内的所有房子
int tryRob(vector<int> &nums, int index){
//递归终止条件
if(index >= nums.size())
return 0;
if(memo[index] != -1)
return memo[index];
int res = 0;
for(int i=index;i<nums.size(); ++i){
res = max(res, nums[i] + tryRob(nums, i+2));
}
memo[index] = res;
return res;
}
public:
int rob(vector<int>& nums) {
memo = vector<int>(nums.size(), -1);
return tryRob(nums, 0);
}
};
manière dynamique de programmation:
qui peut être divisé comme ceci:
- Ici , avec une double circulation, une
bonne appréciation quant à l'utilisation de la différence entre le double et le cycle lourd en un seul cycle à. - Mémo [i] dans le mode d'acquisition,
note [i] signifie que: le i-ème position de la valeur maximale pour commencer à voler! Donc , il doit y avoir un processus de maximum! (Max prendre une compétence!)
memo[i] = nums[j] + memo[j+2];
Ensuite , le but est de trouver la note [i] du maximum, donc avec pointe:
memo[i] = max(memo[i], nums[j] + memo[j+2])
Puis je me souviens en tenant compte des limites tableau de détails , voir le code ci - dessous!
int rob(vector<int> &nums){
int n = nums.size();
if(n==0)
return 0;
vector<int> memo(n, -1);
memo[n-1] = nums[n-1];
// 递推解决
for(int i=n-2; i>=0; --i)
for(int j=i; j<n; j++)
// 关键这一步,然后max也找出了memo[i]最大值
memo[i] = max(memo[i], nums[j] + (j+2<n ? memo[j+2]:0));
return memo[0];
}