23.1.13力扣刷题

感觉今天没什么动力。。。

2287. 重排字符形成目标字符串
给你两个下标从 0 开始的字符串 s 和 target 。你可以从 s 取出一些字符并将其重排，得到若干新的字符串。
从 s 中取出字符并重新排列，返回可以形成 target 的 最大 副本数。

每日一题，是道简单题从这里开始吧
看着不像简单题让我想起了牛奶碑文T~T
不需要去按顺序啊
这简单直接统计每个字母个数
然后再取能产生的最小个数就ok

class Solution {
public:
    int rearrangeCharacters(string s, string target) {
        map<char,int>mp1;
        map<char,int>mp2;
        int ans=s.length();
        for(char i :s)
            mp1[i]++;
        for(char i :target)
            mp2[i]++;
        for(auto i=mp2.begin();i!=mp2.end();i++)
        {
            ans=min(ans,mp1[i->first]/i->second);
        }
        return ans;
    }
};

看了一下解法都差不多哇

剑指 Offer 58 - II. 左旋转字符串
字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。

直接返回拆分的字符串再相加就ok
c++的字符串相加真的好用

class Solution {
public:
    string reverseLeftWords(string s, int n) {
        return s.substr(n,s.length()-1)+s.substr(0,n);
    }
};

TAT居然和别人写的一样
哈哈哈
python的直接切片也好好用看起来

剑指 Offer 19. 正则表达式匹配
请实现一个函数用来匹配包含’. ‘和’‘的正则表达式。模式中的字符’.‘表示任意一个字符，而’'表示它前面的字符可以出现任意次（含0次）。在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"abaca"匹配，但与"aa.a"和"ab*a"均不匹配。

好像是我做的第一题困难题T~T希望能做出来

这题的关键在于’. ‘和’*'欸
看题目倒是不难
应该有什么关键难处理的部分
好吧仔细想了一遍挺难的
只有一个思路，因为星号在字母的后面
所以我们从后往前匹配会更好些

看了一下题目
s 可能为空，且只包含从 a-z 的小写字母。
p 可能为空，且只包含从 a-z 的小写字母以及字符 . 和 ，无连续的 ''。
幸好s不是模式串
简单了很多
点号倒是不担心，遇到点号直接匹配就ok，要特殊处理的是点星
主要是星号，匹配多少个数这个是一个问题
比如匹配
baaaab
baa*b
一个想法？
先算两个字符串每个字符的差

还是看答案吧T~T

今天状态不是很好下午才继续看
来学习一下官方的解法
字符串的动态规划T~T我还是对这个不太会啊

答案具有唯一性，过程不唯一——>使用动态规划
动态规划的过程是研究状态转移emmm有从题解从得到别人思考的一些方式

这一步好妙啊
看题解写出来了
T~T太可怕了这题

class Solution {
public:
    bool isMatch(string s, string p) {
        int n=s.length();
        int m=p.length();
        vector<vector<int>> dp(n+5,vector<int>(m+5));//dp数组
        auto matchCh=[&](int i,int j)
        {
            if(i==0)
                return false;//第一行的时候也就是空串，直接false就ok
            if(p[j-1]=='.')//.可以随意匹配
                return true;
            else
                return s[i-1]==p[j-1];
        };
        dp[0][0]=1;//空串和空串匹配为真
        for(int i=0;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                if(p[j-1]!='*')//非星号
                    dp[i][j]=matchCh(i,j)&&dp[i-1][j-1];
                else//星号的情况
                        dp[i][j]=dp[i][j-2]|(matchCh(i,j-1)&&dp[i-1][j]);
            }
        }
        return dp[n][m];
    }
};

剑指 Offer 21. 调整数组顺序使奇数位于偶数前面
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有奇数在数组的前半部分，所有偶数在数组的后半部分。

写些水题缓解心情
双指针==写完耗费了一些时间

class Solution {
public:
    vector<int> exchange(vector<int>& nums) {
        int l,r,t;
        l=0;
        r=nums.size()-1;
        while(1)
        {
            while(l<r&&nums[l]&1)
                l++;
            while(l<r&&!(nums[r]&1))
                r--;
            if(l<r)
                swap(nums[l],nums[r]);
            else
                break;
        }
        return nums;
    }
};

剑指 Offer 22. 链表中倒数第k个节点
输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。
例如，一个链表有 6 个节点，从头节点开始，它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4 的节点。

不想遍历两边，想空间换时间

class Solution {
public:
    ListNode* getKthFromEnd(ListNode* head, int k) {
        int n=1;
        map<int,ListNode*>mp;
        while(head)
        {
            mp[n]=head;
            n++;
            head=head->next;
        }
        return mp[n-k];
    }
};

???其他人什么逆天写法
天啊这也可以用双指针太秀了
T~T

剑指 Offer 20. 表示数值的字符串
请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。
数值（按顺序）可以分成以下几个部分：
若干空格
一个 小数 或者 整数
（可选）一个 ‘e’ 或 ‘E’ ，后面跟着一个 整数
若干空格
小数（按顺序）可以分成以下几个部分：
（可选）一个符号字符（‘+’ 或 ‘-’）
下述格式之一：
至少一位数字，后面跟着一个点 ‘.’
至少一位数字，后面跟着一个点 ‘.’ ，后面再跟着至少一位数字
一个点 ‘.’ ，后面跟着至少一位数字
整数（按顺序）可以分成以下几个部分：
（可选）一个符号字符（‘+’ 或 ‘-’）
至少一位数字
部分数值列举如下：
[“+100”, “5e2”, “-123”, “3.1416”, “-1E-16”, “0123”]
部分非数值列举如下：
[“12e”, “1a3.14”, “1.2.3”, “±5”, “12e+5.4”]

有些复杂感觉大概是分几种类型讨论
又是字符串处理扎心，可别又是动态规划

思路
我们从上面总结出一些规则就ok
1.英文字母只出现e和E

太离谱了这题。。学习一下题解
自动机。。
看懂了明天写，现在写意义不太大

剑指 Offer 25. 合并两个排序的链表
输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode *head,*p;
        if(l1==NULL||l2==NULL)//弱链表为空
            return l1==NULL?l2:l1;
        if(l1->val < l2->val)
        {
            head=p=l1;
            l1=l1->next;
        }
        else
        {
            head=p=l2;
            l2=l2->next;
        }
        while(l1&&l2)
        {
            if(l1->val < l2->val)
            {
                p->next=l1;
                p=l1;
                l1=l1->next;
            }
            else
            {
                p->next=l2;
                p=l2;
                l2=l2->next;
            }
        }
        p->next=l1==NULL?l2:l1;
        return head;
    }
};

其实感觉有些重复T_T
原来可以定义一个虚拟的头节点
这样我就可以省略掉第一步了
递归方法真的简洁啊

剑指 Offer 26. 树的子结构
输入两棵二叉树A和B，判断B是不是A的子结构。(约定空树不是任意一个树的子结构)
B是A的子结构， 即 A中有出现和B相同的结构和节点值。

子结构==中序遍历和先序遍历相等么
嗯哼？需要将树稍稍转换一下么
好像不需要。。。
递归是真神啊

class Solution {
public:
    bool issame(TreeNode* A, TreeNode* B)
    {
        if(!B)//搜索完 这个条件必须要在下面那个条件之前判定
            return true;
        else if(!A)
            return false;
        else if(A->val==B->val)
            return issame(A->left,B->left)&&issame(A->right,B->right);
        else
            return false;
    }
    bool isSubStructure(TreeNode* A, TreeNode* B) {
        if(A==nullptr)
            return false;
        else if(B==nullptr)
            return false;
        else if(A->val==B->val&&issame(A,B))
            return true;
        else
            return isSubStructure(A->left,B)||isSubStructure(A->right,B);
    }
};