力扣题解6-8

中等题

理解题目意思花一些时间：可以想成一个更新过程，但是只会向下或者向右上进行。一般来说这种类似找规律的题目都比较简单，尤其是这种明确告诉你更新方法的。有一种做法是手动计算每个字符出现的规律，就是用数学方法。但是这里我们不这么做，主要是训练一下类似这种一步步走棋盘的算法。

#include <iostream>
#include <string>

#define ARR_LEN 1000

using namespace std;

class Solution {
public:
    string convert(string s, int numRows) {
        if(numRows == 1) return s;
        char table[ARR_LEN][ARR_LEN]; //棋盘
        int col = 0, row = 0; //初始位置
        int dircol = 1; //列方向的动作。起初向下，即+1
        int dirrow = 0; //行方向的动作。起初不变，即+0
        int count = numRows-1; //改变倒计时，每采取numRows-1个动作后，下一个动作就改变了
        int len = s.size();

        table[col][row] = s[0];
        for(int i=1; i<len; i++){
            if(count == 0){
                dircol *= -1; //往回走，1与-1切换
                dirrow = 1 - dirrow; //1与0切换
                count = numRows - 1;
            }
            col += dircol;
            row += dirrow;
            table[col][row] = s[i];
            count -- ;
        }
        
        string res = "";
        for(int i=0; i<numRows; i++){
            for(int j=0; j<=len; j++){
                if(table[i][j]){
                    res += table[i][j];
                }
            }
        }
        return res;
    }
};

int main(){
    Solution st;
    string s = "PAYPALISHIRING";
    
    cout<<st.convert(s,4)<<endl;

    return 0;
}

整个流程就是按部就班地画棋盘，最后遍历一下。两个方向动作dircol和dirrow我本意是做成相当于方向向量类似的东西。本题需要注意的点是只有一行需要单独讨论，因为它不存在列方向上的移动，这也是提交报错后才发现的。

总结6

• 二维字符数组的定义，这里没有初始化，在OJ上会出错，本地没问题。
• 边界问题和特殊情况讨论（永远都会遇到的问题）
• 好像没什么了，这题比较水，干脆多攒一点一起发吧

7 整数反转

中等题

不用考虑复杂度的基本算法练习。反转很简单，使用整除和除法循环一次即可，问题是如何判断中间过程溢出情况。由于题目要求不能使用64位整数，也就是说不能‘“溢出”后再判断是否溢出，而是必须进行某项运算前判断该运算是否会导致溢出。为了更好地了解到这一点，先贴一下我一开始的错误代码：

class Solution {
public:
    int reverse(int x) {
        //末尾有0需要记录信息
        int count = calbit(x);
        int rev = correverse(x,count);
        int ori = correverse(rev,count);
        if(ori == x) return rev;
        else return 0;
    }

    int correverse(int x, int count){
        int res = 0;
        int cpx = x;
        while(x!=0){
            int end = x%10;
            res *= 10;
            res += end;
            x /= 10;
        }
        //因为第一次的转化可能会去掉了末尾的0，给他补上
        res *= pow(10,count-calbit(cpx));
        return res;
    }

    //计算位数
    int calbit(int x){
        int count = 0;
        while(x != 0){
            count ++;
            x/=10;
        }
        return count;
    }
};

该算法就是对需要判断的数转换两次。如果转换两次后和原数比对发现一致，那么就说明中间没有出错没有溢出。这里需要考虑末位是0的数会损失位数，需要补齐。在本地运行是可以通过的，但是在力扣OJ上无法通过，原因是产生溢出。也就是说，力扣的编译器会发现我溢出了。这我就不理解了，编译器都能发现我溢出了，那我写个try catch错误处理一下不就完了？那还要我写算法干嘛？所以我觉得这题没什么意思。官方解答是，通过判断中间值和边界值/10的大小关系判断下一步是否会溢出，嗯，那确实。代码如下：

class Solution {
public:
    int reverse(int x) {
        int rev = 0;
        while (x != 0) {
            if (rev < INT_MIN / 10 || rev > INT_MAX / 10) {
                return 0;
            }
            int digit = x % 10;
            x /= 10;
            rev = rev * 10 + digit;
        }
        return rev;
    }
};

作者：LeetCode-Solution
链接：https://leetcode.cn/problems/reverse-integer/solution/zheng-shu-fan-zhuan-by-leetcode-solution-bccn/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

8 字符串转换整数

中等题

一看题目又是一个基本上不需要考虑复杂度，只要精准地一步步完成每一步操作的题。这种题在新手期我的想法是不要想着搞那种精简代码，一行做很多事，一个函数里做很多事。不如就按部就班，一块代码完成一块的事情。因此我就拆成四步：1.去掉空白字符 2.确定符号 3.取数，字符串形式 4.计算值

#include <iostream>


int MAXNUM = 2147483647;

using namespace std;

class Solution {
public:
    int myAtoi(string s) {
        s = sstripe(s); //去除空白字符
        int sign = ssign(s); //确定符号
        string sres = sread(s); //取数，字符串类型
        int res = scal(sres, sign); //计算值
        return res;
    }

    string sstripe(const string& s){
        int len = s.size();
        string res = s;
        for(int i=0; i<len; i++){
        	//isspace用于判断是否是空白字符
            if(isspace(s[i])) res = s.substr(i+1,len-i-1);
            else break;
        }
        return res;
    }
    
    int ssign(const string& s){
        if(s.size() > 0 && s[0] == '-') return -1;
        else return 1; //+或无符号或长度为0都默认为1
    }

    string sread(string s){
        string res = "";
        //先去除第一个符号位，如果有的话
        if(s[0] == '-' || s[0] == '+') s = s.substr(1,s.size()-1);
        for(int i=0; i<s.size(); i++){
            if(s[i] >=48 && s[i] <= 57) res += s[i];
            else break;
        }
        return res; //后面有什么垃圾也不用管
    }

    int scal(const string& s, int sign){
        int res = 0;
        for(int i=0; i<s.size(); i++){
            if(s[i] >= 48 && s[i] <=57){
            	//下面就分情况讨论。为什么不合并起来讨论？别问，问就是精准扶贫。
                if(sign > 0){
                    //正向溢出，总之我每可能溢出的地方都判断，行不行？
                    //具体为什么这么写见上题
                    if(res > MAXNUM / 10) return MAXNUM;
                    res *= 10;
                    if(res > MAXNUM - (s[i] -48)) return MAXNUM;
                    res += (s[i] - 48);
                }
                else{
                    //反向溢出
                    if(res < MAXNUM*(-1) / 10) return -MAXNUM-1;
                    else {
                        res *= 10;
                        if(res < MAXNUM*(-1) + (s[i] - 48) - 1) return -MAXNUM-1;
                        res -= (s[i] - 48);
                    }
                }
            }
            else break;
        }
        return res;
    }
};



int main(){
    Solution st;

    cout<<st.myAtoi("     -43")<<endl;

    return 0;
}

这题也没什么意思，浪费了人生的两个小时（一直在想办法合并起来判断边界）。