<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[fffffer的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/fffffer</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; fffffer]]></copyright><item><title><![CDATA[剑指offer-把数字翻译为字符串（leetcode）]]></title><link>https://blog.youkuaiyun.com/fffffer/article/details/106986248</link><guid>https://blog.youkuaiyun.com/fffffer/article/details/106986248</guid><author>fffffer</author><pubDate>Sat, 27 Jun 2020 18:37:19 +0800</pubDate><description><![CDATA[这道题可以看作是动态规划类的题目，类似于跳台阶的题目。

例如：12258

状态转移方程：dp[i] = dp[i+1] + dp[i+2]


class Solution {
public:
    int translateNum(int num) {
        string str = to_string(num);
        vector&lt;int&gt; nums(str.length());
        int count = 0;
        int length ]]></description><category></category></item><item><title><![CDATA[剑指offer-数字序列中的某一位（leetcode）]]></title><link>https://blog.youkuaiyun.com/fffffer/article/details/106984855</link><guid>https://blog.youkuaiyun.com/fffffer/article/details/106984855</guid><author>fffffer</author><pubDate>Sat, 27 Jun 2020 18:32:30 +0800</pubDate><description><![CDATA[又是一道找规律的题目，头大得很。

为了方便10 - n 位的规律，我们默认n &gt;= 10，其他情况只要renturn n; 就可以了。


]]></description><category></category></item><item><title><![CDATA[剑指offer-数组中出现次数最多的数字]]></title><link>https://blog.youkuaiyun.com/fffffer/article/details/106921312</link><guid>https://blog.youkuaiyun.com/fffffer/article/details/106921312</guid><author>fffffer</author><pubDate>Tue, 23 Jun 2020 13:19:37 +0800</pubDate><description><![CDATA[常规算法不就说了，这次看到大佬的题解，特地记录以下。

解法名称为：摩尔投票法

假设出现次数最多的数字为 x，当nums[i] == x 时，votes += 1，否则 votes -= 1

由此我们可以知道，遍历完数组后，votes &gt; 0

因此若数组中前m个数的和为0，那么后(n-m)个数的和仍大于0，出现次数最多的数字仍为 x


class Solution {
public:
    int majorityElement(vector&lt;int&gt;&amp; nums) {
]]></description><category></category></item><item><title><![CDATA[剑指offer-剪绳子（leetcode）]]></title><link>https://blog.youkuaiyun.com/fffffer/article/details/106845701</link><guid>https://blog.youkuaiyun.com/fffffer/article/details/106845701</guid><author>fffffer</author><pubDate>Thu, 18 Jun 2020 23:43:51 +0800</pubDate><description><![CDATA[这是一道动态规划的题目，如果看不出出来的话，可以模拟该题的过程。

状态转移方程：dp[i] = max( dp[i] * dp[i-j], i * (j-i) )

但是我们可以通过进一步观察当 n &gt; 4 的时候，（i-j）&lt; dp[i-j]，同时在分割绳子的时候作为被分割出来的绳子长度 &lt;= 3 的时候不应该进一步分割，而是选择不分割。

所以当 n &gt; 3 的时候，状态转移方程为dp[i] = max( dp[i], dp[i]*dp[i-j] );

说的可能有点绕，建议.]]></description><category></category></item><item><title><![CDATA[剑指offer-机器人的运动范围（leetcode）]]></title><link>https://blog.youkuaiyun.com/fffffer/article/details/106843252</link><guid>https://blog.youkuaiyun.com/fffffer/article/details/106843252</guid><author>fffffer</author><pubDate>Thu, 18 Jun 2020 21:06:42 +0800</pubDate><description><![CDATA[这道题目可以使用回溯的方法来做，但是想来想去应该有更加简洁的算法，即如下想法：

因为机器人的可达路径总是由左至右或者由上至下的方式到达，也就是说，一个地点是否可达，不仅取决于自身坐标是否符合要求，而且其左边或者上边的地点也要可达，从而可以得到以下结论：visit[i][j] = visit[i-1][j] | visit[i][j-1]; 但是在具体写代码的时候要注意到边界问题。


class Solution {
public:
    int movingCount(int m, int n, i.]]></description><category></category></item><item><title><![CDATA[剑指offer-旋转数组的最小数字（leetcode）]]></title><link>https://blog.youkuaiyun.com/fffffer/article/details/106819447</link><guid>https://blog.youkuaiyun.com/fffffer/article/details/106819447</guid><author>fffffer</author><pubDate>Wed, 17 Jun 2020 22:10:47 +0800</pubDate><description><![CDATA[这道题目用到了二分查找的思想。

nums[middle] &gt;nums[end] ：可以确定最小数字在（middle+1，end）这个区间

nums[middle] &lt; nums[end] ：可以确定最小数字在（start, middle）这个区间

nums[middle] == nums[end] ：这个情况比较特殊，不能确定最小数字在左边区间还是右边区间。举一个特殊例子：

                        1，0，1，1...]]></description><category></category></item><item><title><![CDATA[剑指offer-青蛙跳台阶（leetcode）]]></title><link>https://blog.youkuaiyun.com/fffffer/article/details/106812926</link><guid>https://blog.youkuaiyun.com/fffffer/article/details/106812926</guid><author>fffffer</author><pubDate>Wed, 17 Jun 2020 16:52:40 +0800</pubDate><description><![CDATA[因为小青蛙一次只能跳1/2个台阶，因此如果要跳到第n个台阶，只能从n-1或者n-2台阶跳上去。典型的斐波那契数列，只不过第0项也为1，只有这点区别。


class Solution {
public:
    int numWays(int n) {
        if(n &lt; 2){
            return 1;
        }

        int fib_N = 0,fib_O = 1,fib_T = 1;
        for(int i = 2;i &lt;= n]]></description><category></category></item><item><title><![CDATA[剑指offer-用两个栈实现队列（leetcode）]]></title><link>https://blog.youkuaiyun.com/fffffer/article/details/106807076</link><guid>https://blog.youkuaiyun.com/fffffer/article/details/106807076</guid><author>fffffer</author><pubDate>Wed, 17 Jun 2020 14:44:28 +0800</pubDate><description><![CDATA[这道题目的思路很简单：将输入的数据压入s1中，再将s1中的数据压入s2中，这样s2的出栈顺序就和队列的出队顺序一致。

但是在判断出栈的时候要先判断s2是否为空，再判断s1是否为空。

若两者都为空，则输出-1

若s2不为空，则返回栈顶元素

若s2为空 &amp;&amp; s1不为空，将s1中的元素压入s2中，再返回s2的栈顶元素


class CQueue {
    stack&lt;int&gt; s1;
    stack&lt;int&gt; s2;
public:
    CQueue(]]></description><category></category></item><item><title><![CDATA[剑指offer-二维数组中的查找（leetcode）]]></title><link>https://blog.youkuaiyun.com/fffffer/article/details/106788032</link><guid>https://blog.youkuaiyun.com/fffffer/article/details/106788032</guid><author>fffffer</author><pubDate>Tue, 16 Jun 2020 15:26:21 +0800</pubDate><description><![CDATA[这道题的解法核心就是：从右上角不断搜索。

若 matrix[row][col]==target 则return true；

若 matrix[row][col] &gt;target，则向该数字的左方继续搜索，即col--;

若matrix[row][col] &lt;target，则向该数字的下方继续搜索，即row++；

这样子做的原因是数组的每行每列都是有序的，这样子可以很容易的缩小查找范围。当然也可以使用二分法继续加快速的。


class Solution {
public:
 ...]]></description><category></category></item><item><title><![CDATA[剑指offer-数组中重复的数字（leetcode）]]></title><link>https://blog.youkuaiyun.com/fffffer/article/details/106765109</link><guid>https://blog.youkuaiyun.com/fffffer/article/details/106765109</guid><author>fffffer</author><pubDate>Mon, 15 Jun 2020 16:31:47 +0800</pubDate><description><![CDATA[题目描述：

找出数组中重复的数字。
在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。

简单来说就是找到并返回数组中任意一个重复的数字。

一共有三种思路可以解决这个问题：

（1）把数组进行排序，遍历数组进行查找。

（2）开辟一个额外的数组，进行比对。

（3）在原数组上进行原地交换，把数组中的元素交换到其对应下表上。由于每个数字最多交换2次就可以到达他的位置，因此]]></description><category></category></item><item><title><![CDATA[转载：数据库--视图的基本概念以及作用]]></title><link>https://blog.youkuaiyun.com/fffffer/article/details/105297797</link><guid>https://blog.youkuaiyun.com/fffffer/article/details/105297797</guid><author>fffffer</author><pubDate>Fri, 03 Apr 2020 17:37:41 +0800</pubDate><description><![CDATA[转载来源：https://blog.youkuaiyun.com/buhuikanjian/article/details/53105416

视图（子查询）：是从一个或多个表导出的虚拟的表，其内容由查询定义。具有普通表的结构，但是不实现数据存储。
对视图的修改：单表视图一般用于查询和修改，会改变基本表的数据，
多表视图一般用于查询，不会改变基本表的数据。
--创建视图--create or replace ...]]></description><category></category></item><item><title><![CDATA[leetcode 46. 全排列]]></title><link>https://blog.youkuaiyun.com/fffffer/article/details/104655546</link><guid>https://blog.youkuaiyun.com/fffffer/article/details/104655546</guid><author>fffffer</author><pubDate>Wed, 04 Mar 2020 16:12:35 +0800</pubDate><description><![CDATA[dfs 的应用

这道题我们依旧可以通过使用 dfs 的思想，也就是回溯的方法来做。举个例子：1，2，3的全排列为

[1,2,3],[1,3,2]

[2,1,3],[2,3,1]

[3,1,2],[3,2,1]

通过观察我们可以看出，以 1 开头的全排列实际上就是，[ 1,[2,3] 的全排列 ] ===&gt; [1,2,3]、[1,2,3]，通过这种方法我们可以很容易想到以 1 开头...]]></description><category></category></item><item><title><![CDATA[leetcode 40. 组合总和 II]]></title><link>https://blog.youkuaiyun.com/fffffer/article/details/104653855</link><guid>https://blog.youkuaiyun.com/fffffer/article/details/104653855</guid><author>fffffer</author><pubDate>Wed, 04 Mar 2020 15:02:52 +0800</pubDate><description><![CDATA[这两天偷懒了，没有写题解=.=

dfs 模板题

虽说是模板题，还是要理解具体思想。因为题目中说到，每个元素不能重复利用，并且 candidates 可能有重复元素，所以我们要先把 candidates 进行排序。接下来就是深搜的过程了，由于每次搜索都是建立在上次搜索的结果之上，如果candidates[i] + sum &lt;=target 那么就进行下一次搜索，并且把 candidate...]]></description><category></category></item><item><title><![CDATA[leetcode 61. 旋转链表]]></title><link>https://blog.youkuaiyun.com/fffffer/article/details/104579180</link><guid>https://blog.youkuaiyun.com/fffffer/article/details/104579180</guid><author>fffffer</author><pubDate>Sat, 29 Feb 2020 18:31:13 +0800</pubDate><description><![CDATA[链表的应用

乍一看这道题很麻烦，不过当我们仔细观察后可以发现，不论 k取何值，旋转的次数实际为 k % len ，len 为链表的长度。因此这道题的任务就是找到倒数第 k 个数据，使倒数第 k-1 个数据的next 指向 NULL，最后使链表最后一个数据的next指向head。


/**
 * Definition for singly-linked list.
 * struct List...]]></description><category></category></item><item><title><![CDATA[leetcode 19. 删除链表的倒数第N个节点]]></title><link>https://blog.youkuaiyun.com/fffffer/article/details/104577668</link><guid>https://blog.youkuaiyun.com/fffffer/article/details/104577668</guid><author>fffffer</author><pubDate>Sat, 29 Feb 2020 17:16:23 +0800</pubDate><description><![CDATA[依旧是链表的应用

最开始看到这道题的时候，想法很暴力，遍历一遍得到长度，然后再遍历一遍删除指定元素。后来看来大佬的题解发现可以使用双指针的方法，只需要一次遍历就可以删除指定节点。

需要注意的一点是，虽然题目中已经说明 n 是有效数字，但是依旧有可能出现 fast 指针为空的情况，即删除第一个元素的时候。这个时候只需要返回 head-&gt;next 就可以了，之后就可以愉快的写代码了！


/...]]></description><category></category></item><item><title><![CDATA[leetcode 2. 两数相加]]></title><link>https://blog.youkuaiyun.com/fffffer/article/details/104577059</link><guid>https://blog.youkuaiyun.com/fffffer/article/details/104577059</guid><author>fffffer</author><pubDate>Sat, 29 Feb 2020 16:47:52 +0800</pubDate><description><![CDATA[链表的应用

题目的思路很简单，通过建立一条新的链表用来存放两数相加的结果。


/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* addTwoNumbers(struct ...]]></description><category></category></item><item><title><![CDATA[leetcode 64. 最小路径和]]></title><link>https://blog.youkuaiyun.com/fffffer/article/details/104561591</link><guid>https://blog.youkuaiyun.com/fffffer/article/details/104561591</guid><author>fffffer</author><pubDate>Fri, 28 Feb 2020 18:31:57 +0800</pubDate><description><![CDATA[经典的动态规划题目

因为只能通过向下或者向右走，不需要考虑对角等因素，而且要求的是最小路径和。因此，可以很容易得到状态转移方程

grid[i][j]+=grid[i-1][j]&lt;grid[i][j-1]?grid[i-1][j]:grid[i][j-1]; 在该题中我没有重新申请一个二位数组来存放路径和，而是直接在原数组上面做修改。得到状态转移方程后，只需要做好数组初始化...]]></description><category></category></item><item><title><![CDATA[leetcode 70. 爬楼梯]]></title><link>https://blog.youkuaiyun.com/fffffer/article/details/104561189</link><guid>https://blog.youkuaiyun.com/fffffer/article/details/104561189</guid><author>fffffer</author><pubDate>Fri, 28 Feb 2020 18:09:24 +0800</pubDate><description><![CDATA[感觉动态规划的前几道题有点水~_~

申请一个一维数组dp，dp[i] 表示走到 i+1 层有多少种方式。一次只可以走一步或者两步，由此可以得到状态转移方程    dp[i]=dp[i-1]+dp[i-2]; 再做好数组初始化就可以很容易得到答案。


int climbStairs(int n){
    if(n &lt; 3){
        return n;
    }...]]></description><category></category></item><item><title><![CDATA[leetcode 62.不同路径]]></title><link>https://blog.youkuaiyun.com/fffffer/article/details/104560416</link><guid>https://blog.youkuaiyun.com/fffffer/article/details/104560416</guid><author>fffffer</author><pubDate>Fri, 28 Feb 2020 17:30:26 +0800</pubDate><description><![CDATA[经典的动态规划题目。

因为机器人只能向右或者向下走，那么dp[i][j] =dp[i-1][j] +dp[i][j-1]，dp[i][j]表示从起点到达 path[i][j] 的总路径和。状态转移方程就是dp[i][j] =dp[i-1][j] +dp[i][j-1]。


int uniquePaths(int m, int n){
    int dp[n][m];
    mems...]]></description><category></category></item><item><title><![CDATA[leetcode 53.最大子序和]]></title><link>https://blog.youkuaiyun.com/fffffer/article/details/104559726</link><guid>https://blog.youkuaiyun.com/fffffer/article/details/104559726</guid><author>fffffer</author><pubDate>Fri, 28 Feb 2020 17:00:13 +0800</pubDate><description><![CDATA[在遍历数组的时候，关键在于找到最大子序和的第一个数字。若当前访问的数字大于sum，那么必须要更新sum，即nums[i] &gt; sum 的时候，更新sum，sum的含义为子序列nums[x...i]的和。最后更新ans。


int maxSubArray(int* nums, int numsSize){
    int ans = nums[0];
    int sum = nums[0...]]></description><category></category></item></channel></rss>