队列的最大值、解密数字、珠宝的最高价值、招式拆解（无重复字符的最长字串）、丑数

• 队列的最大值

class MaxQueue {
public:
    MaxQueue() {

    }
    
    int max_value() {
        return d.empty() ? -1:d.front();
    }
    
    void push_back(int value) {
        q.push(value);
        while(!d.empty() && d.back() <  value)
        {
            d.pop_back();
        }
        d.push_back(value);
    }
    
    int pop_front() {
        
        if(q.empty())
        {
            return -1;
        }
        int val = q.front();
        if(q.front() == d.front())
        {
            d.pop_front();
        }
        q.pop();
        return val;
    }

    queue<int> q;
    deque<int> d;
};

/**
 * Your MaxQueue object will be instantiated and called as such:
 * MaxQueue* obj = new MaxQueue();
 * int param_1 = obj->max_value();
 * obj->push_back(value);
 * int param_3 = obj->pop_front();
 */

有点类似于之前写的包含min函数的栈，但最开始思路是一个队列，一个栈，发现存在逻辑错误。解析中提到，使用一个队列和一个双端队列。双端队列用来记录最大值，确保其存储的数据是非递减的，即可实现该题队列的最大值。
双端队列可以前删后删，前插后插，相较起来比较灵活。
while(!d.empty() && d.back() < value)确保双端队列里是非递减的，值得注意的是，不能写成d.back()<=value。不然双端队列中会缺少元素。

• 解密数字

class Solution {
public:
    int crackNumber(int ciphertext) {
        string s = to_string(ciphertext);
        
        int a = 1, b = 1;
        for(int i = 2; i <= s.size(); i++)
        {
            string temp = s.substr(i-2,2);//从索引i-2到i之前，不包括i，第二个参数表示长度为2
            int c = temp.compare("10") >= 0 && temp.compare("25") <= 0 ? a+b : a;
            b = a;
            a = c;
        }
        return a;
    }
};

最开始的思路在将整数转化为字符串，但在判断条件下卡住了。这里的解决办法是用到了字符串的compare方法，比括号内的大就大于0，反之亦然。除此之外，to_string函数也是第一次用到，可以快速将整形数据转化为字符串，而减少了for循环遍历的麻烦；substr()函数表示用来截取字符串，第一个参数为索引起始索引，第二个参数为长度。

该题为动态规划类型的题目，解决动态规划的题目首要目标是能写出其递推公式，即转移方程.

• 珠宝的最高价值

class Solution {
public:
    int jewelleryValue(vector<vector<int>>& frame) {
        int i, j;
        for(i = 0; i < frame.size(); i++)
        {
            for(j = 0; j < frame[i].size(); j++)
            {
                // if(i == 0 && j == 0)
                // {
                //     continue;
                // }
                if(i == 0 && j != 0)
                {
                    frame[i][j] += frame[i][j-1];
                }
                else if(i != 0 && j == 0)
                {
                    frame[i][j] += frame[i-1][j];
                }
                else if(i != 0 && j != 0)
                {
                    frame[i][j] += max(frame[i-1][j], frame[i][j-1]);
                }
            }
        }
        return frame[i-1][j-1];
    }
};

最开始的思路是想到之前写过的迷宫问题，通过定义上下左右的数据结构进行广度优先搜索，最后未果。

这里需要注意的是数组越界的问题，不能超过了二维数组的上下左右边界，根据状态转移方程还是很轻松写出代码的。

• 招式拆解

动态规划+哈希表

class Solution {
public:
    int dismantlingAction(string arr) {
        unordered_map<char, int> m;
        int res = 0, temp = 0, i;
        for(int j = 0; j < arr.size(); j++)
        {
            if(m.find(arr[j]) == m.end())
            {
                i = -1;//没找到
            }
            else
            {
                i = m.find(arr[j])->second;//找到了就更新i值
            }
            m[arr[j]] = j;
            temp = temp < j-i ? temp+1 : j-i;
            res = max(res, temp);
        }

        return res;
    }
};

最开始的思路是用两层for循环，利用双指针去遍历数组，可是在写的过程中发现无法找到与当前下标左边相同的字符。而题解就是用的unordred_map哈希表解决这个问题的。回顾下哈希表的知识，unordered_map与map不同，前者是无序后者是有序，哈希表有两个值，分别是key值和value值。题中的key值为char，value值为int。这里使用的find函数是c++中STL内置算法，其返回值是迭代器，找到了就返回该位置的迭代器，没找到就返回末尾迭代器。所以在更新i值时是用m.find(arr[j])->second

动态规划+线性查找

class Solution {
public:
    int dismantlingAction(string arr) {
        int res = 0, temp = 0;
        for(int j = 0; j < arr.size(); j++)
        {
            int i = j-1;
            while(i >= 0 && arr[i] != arr[j]) i--;//线性查找i
            temp = temp < j-i ? temp+1 : j-i;
            res = max(res, temp);
        }

        return res;
    }
};

总结：该方法解决了我最初想法卡壳的地方，就是寻找其左边相同字符的下标，应当从j-1的位置向左边遍历，所以告诉我们做题不能一贯性思维。写习惯了从左往右的遍历，但是发现从右往左遍历问题就能迎刃而解。

• 丑数

class Solution {
public:
    int nthUglyNumber(int n) {
        int a = 0, b = 0, c = 0, n1, n2, n3;
        int dp[n];
        dp[0] = 1;
        for(int i = 1; i < n; i++)
        {
            n1 = 2*dp[a];
            n2 = 3*dp[b];
            n3 = 5*dp[c];

            dp[i] = min(min(n1, n2), n3);
            if(dp[i] == n1) a++;
            if(dp[i] == n2) b++;
            if(dp[i] == n3) c++;
        }

        return dp[n-1];
    }
};

初看以为能做，在思考过程中还是会卡壳。卡壳点就在下标的关系是模糊的，需要自己设定，而并不是一定与前一个数据有倍数上的关系，而是与前面中的某个数有关系。关键是在最小值函数的使用上。这里我不太会组织语言，还是照搬解析的好。