力扣刷题记录-2020-2-28

一、给定一个字符串，编写一个函数判定其是否为某个回文串的排列之一。
回文串是指正反两个方向都一样的单词或短语。排列是指字母的重新排列。
回文串不一定是字典当中的单词。

class Solution {
public:
    bool canPermutePalindrome(string s) {
        if(s.size() <= 0) return false;
        if(s.size() == 1) return true;
        //判断字符串中字符出现的个数都为偶数个，或有一个奇数个。
        vector<int>sign(128, 0);

        for(int i = 0; i < s.size(); i++)
        {
            sign[s[i]]++;
        }
        
        int num = 0;
        //开始判断
        for(int i = 0; i < sign.size(); i++)
        {
            if(sign[i] % 2 != 0) num++; 
        }

        return num <= 1;
        
    }     
};

总结：找出规律，发现符合条件的是字符串中每个字符出现的个数为偶数有且只有一个奇数个

二、字符串操作

class Solution {
public:
    bool oneEditAway(string first, string second) {
        if(first == second) return true;
        int s1 = first.size();
        int s2 = second.size();
        int sub = s1 - s2;
        if(sub > 1 || sub < -1) return false;
        int count = 0;
        int i = 0, j =0;
        while(i < first.size() && j < second.size())
        {
            if(first[i] == second[j])
            {
                i++;
                j++;
            }
            else
            { 
                //则需要变换
                count++;
                if(count > 1) return false;

                if(s1 > s2)
                {
                    i++;
                }
                else if(s1 < s2)
                {
                    j++;
                }
                else
                {
                    i++;
                    j++;
                }
            }
        }
        
        return true;
    }
};

总结：分情况讨论

三、字符串压缩

class Solution {
public:
    string compressString(string S) {
        //为0返回，为1 a 则是a1，为2 aa则为a2 ab则为a1b1
        if(S.size() <= 2) return S;
        string S1;
        int count = 1;
        for(int i = 0; i < S.size();i++)
        {
            if(S[i] == S[i+1])
            {
                count++;
            }
            else
            {
                S1 += S[i];
                S1 += to_string(count);
                count = 1;
            }
        }
        cout << S1 << endl;
        return S1.size() > S.size() ? S:S1;
    }
};

总结，遍历移动再比较

四、旋转矩阵

大佬写的一次遍历

class Solution {
public:
    void rotate(vector<vector<int>>& matrix) {
        int n = matrix.size();//只是为了方便书写，可以不用
        for (int i = 0; i < n / 2; i++) {
            for (int j = i; j < n - 1 - i; j++) {
                myswap(matrix[i][j], matrix[n-1-j][i]);
                myswap(matrix[n-1-j][i], matrix[n-1-i][n-1-j]);
                myswap(matrix[n - 1 - i][n - 1 - j], matrix[j][n-1-i]);
            }
        }
    }

    void myswap(int& a, int& b) {
        a = a ^ b;
        b = a ^ b;
        a = a ^ b;
    }
};

总结：思路就是对于矩阵，先对外圈进行旋转，在到内圈， 当到了中间时就结束还有一种解法是二次旋转
对应代码：

class Solution {
public:
    void rotate(vector<vector<int>>& matrix) {
        int n = matrix.size();//只是为了方便书写，可以不用
        //一次交换
        for(int i = 0; i < n; i++)
        {
            for(int j = i + 1; j < n; j++)
            {
                myswap(matrix[i][j], matrix[j][i]);
            }
        }
        //再对每行进行交换
        for(int i = 0; i < n; i++)
        {
            int l = 0;
            int r = n -1;
            while(l < r)
            {
                myswap(matrix[i][l], matrix[i][r]);
                l++;
                r--;
            }
        }
    }

    void myswap(int& a, int& b) {
        a = a ^ b;
        b = a ^ b;
        a = a ^ b;
    }
};

五、零矩阵

class Solution {
public:
	void setZeroes(vector<vector<int>>& matrix) {
		set<int>row;
		set<int>col;
		for (int i = 0; i < matrix.size(); i++)
		{
			for (int j = 0; j < matrix[0].size(); j++)
			{
				if (matrix[i][j] == 0)
				{
					row.insert(i);
					col.insert(j);
				}
			}
		}

		for (int i = 0; i <  matrix[0].size(); i++)
		{
			for (set<int>::iterator it = row.begin(); it != row.end(); it++)
			{
				matrix[*it][i] = 0;
			}
		}

		for (int i = 0; i < matrix.size(); i++)
		{
			for (set<int>::iterator it = col.begin(); it != col.end(); it++)
			{
				matrix[i][*it] = 0;
			}
		}
	}
};

**总结：**本题中我们可以使用C++中的set集合来保存数组元素等于0的行列，然后这样防止一行或者一列有多个重复的存入，然后迭代器遍历，从而得到目标0矩阵