算法刷题[五]

stoi & atoi

• 两者都是字符串转数字
• stoi参数是string , atoi参数是char*
• string转 char* s.c_str()
• stoi会进行边界检查. 如果超出int范围会抛出异常. atoi不会检查, 超出边界, 会输出边界.

最长回文子串

• 一个下标无法解决, 总是会有情况覆盖不到
  • 比如dp[i] 表示以i结尾的最长子串, 考虑不到开头的情况. 不同于有效括号那一题
• dp[i][j] 表示s[i…j]是否为回文

class Palindrome {
public:
    int getLongestPalindrome(string A, int n) {
        // write code here
        if (n == 1)
            return 1;
        int res = 1;
        vector<vector<int>> dp(n, vector<int>(n, 0));
        for (int i = 0; i < n; i++)
            dp[i][i] = 1;
        for (int i = n - 2; i >= 0; i--) {
            for (int j = i + 1; j< n; j++) {
                if (A[i]==A[j]) {
                    // 非邻近的两个相等, 还需要看中间的是不是回文
                    if (i + 1 <= j - 1)
                        dp[i][j] = (dp[i + 1][j - 1] == 0)?0:(dp[i + 1][j - 1] + 2);
                   // 邻近的两个相等
                    else
                        dp[i][j] = 2;
                }
                res = max(res, dp[i][j]);
            }
        }
        return res;
    }
};

最近公共祖先

• 后序遍历是自底向上
• 先序遍历是自顶向下
• 中序遍历是BST
• 层序遍历是完全二叉树

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        // 后序遍历是自底向上, 学会看图
        if(root == NULL || root == p || root == q) return root;
        TreeNode* left = lowestCommonAncestor(root->left, p, q);
        TreeNode* right = lowestCommonAncestor(root->right, p, q);
        // 这里不能用!=, 只能用==, 如果是left!= NULL return left; 可能right也是!=NULL 就有错误
        // 所以说如果需要成立的, 就要明确指明NULL
        if (left == NULL) return right;
        if (right == NULL) return left;
        return root;

    }
};

买卖股票问题

• 同样是两层循环, 左边超时, 右边没有超时7ms
• 看来循环中的计算多少也是有影响的. 第二个循环里, 只有比较和赋值, 而且大多数比较都直接跳过了
  
• 与之前的数组中连续最大和想法相同.
  

快速求幂

• O(logN)的时间复杂度
• 指数从大到小, 可以除以多少次2. 底数从小到大, *= 多少次.
• 每当指数为奇数时, 就会损失一次那个阶段的*=, 所以要补上
• 终止条件是指数为1, 刚好判断条件成功, 将之前少的全部乘上

int quickPower1(int a, int n) {
    int res = 1;
    int base = a;
    while(n > 0) {
        // 只要是奇数, 除以2的时候, 就会损失一个(可能是一个base 也可能是一个base^2, 要看是在什么阶段少了一个), x需要把那个补起来
        if (n % 2 == 1)
            res *= base;
        base *= base;
        n /= 2;
    }
    return res;
}

int quickPower2(int a, int n) {
    int res = 1;
    while(n--) res *= a;
    return res;
}

int quickPower3(int a, int n) {
    int res = 1;
    int base = a;
    while(n > 0) {
        if (n&1)
            res *= base;
        base *= base;
        n = n>>1;
    }
    return res;
}

int quickPower4(int a, int n) {
    if (n == 1) return a;
    int temp = quickPower1(a, n/2);
    return (n % 2 == 1?a:1)*temp*temp;
}

股票最大利润

class Solution {
public:
// 类似数组中最大子序列
// 7 1 5 3 6 4
// -6 4 -2 3 -2
    int maxProfit(vector<int>& prices) {
        if (prices.size() == 0 || prices.size() == 1)
            return 0;
        int dp = 0;;
        int res = INT_MIN;
        for (int i = 1; i < prices.size(); i++) {
            // 前一天可以获得的最大收益 + 今天比昨天增加的  和  不交易进行比较
            dp = max(0, dp + prices[i] - prices[i-1]);
            res = max(dp, res);
        }
        return res;
    }
};