Leetcode on ZRJ | 学习笔记

Remove Duplicates from Sorted Array

Thu, 28 Feb 2019 10:12:46 +0800

又是好久没有刷题 https://leetcode.com/problems/remove-duplicates-from-sorted-array/

26. Remove Duplicates from Sorted Array

Given a sorted array nums, remove the duplicates in-place such that each element appear only once and return the new length.

Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.

一开始想劈叉了，以为是每个重复出现的值可能会重复不定次数

int removeDuplicates(int* nums, int numsSize) {
    if (numsSize == 0) return 0;
    int index = 0;
    for (int i = 1; i < numsSize; i++) {
        if (nums[index] != nums[i]) {
            index++;
            nums[index] = nums[i];
        }
    }
    return index + 1;
}

leetcode Hamming Distance

Tue, 30 May 2017 10:37:37 +0800

https://leetcode.com/problems/hamming-distance/

盲敲，一遍过，:)

class Solution {
public:
    int hammingDistance(int x, int y) {
        int res = x ^ y;
        int cnt = 0;
        while (res) {
            if (res % 2) {
                cnt++;
            }
            res /= 2;
        }
        return cnt;
    }
};

Single Number II

Tue, 28 Oct 2014 21:17:08 +0800

https://oj.leetcode.com/problems/single-number-ii/，承前，http://zrj.me/archives/1344，这个题目是每个数字出现三次，要求找出只出现一次的数字：

Given an array of integers, every element appears three times except for one. Find that single one.

Note: Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?

这个很显然，之前的那种异或就不能奏效了，想了想，心思在 3 这个特点上打起了主意。

想法是这样的，假设那些出现 3 次的数为 X1, X2, X3 …，那个特殊的只出现一次的为 Y，那么有

sum = 3(X1 + X2 + X3 + …) + Y

然后，我们可以拿着 sum，遍历数组，尝试用 sum 分别去减每一个数，如果减完发现能 % 3 == 0，那么就说明刚刚减去的那个是 Y

但是，这个简单的思路其实有很多问题：

如果 Y 本身刚好也 % 3 == 0 怎么办
就算 Y % 3 != 0，如果 X 其中的一个 Xn % 3 == Y % 3，那么上述的思路也要歇菜

其实第一个问题还可以修修补补，如果我们发现加出来的 sum % 3 == 0，那么就说明 Y % 3 == 0，这样的话，可以给每个数都 + 1，就转换成了能处理的情况，但是第二个问题就没办法了，怎么都绕不过去，所以这个思路，最终是失败的。

想了很久想不到解法，最后还是看了答案，答案在这里，https://github.com/soulmachine/leetcode，思路是这样的：

在我们处理出现两次的问题的时候，其实相当于是用了一个记录器，然后把每个数都往这个记录器里面装，一个数第一次进去的时候，会把记录器对应的位置 1，第二次再进去，会把记录器的对应位置再加 1，而刚好二进制，加两次就归零了，所以，最后就能得到那个只出现一次的。

那么，可以想到，如果我们的记录器是三进制的，就可以达到跟先前二进制的时候类似的效果来处理出现三次的数字了。

代码如下

class Solution {
public:
    int singleNumber(int A[], int n) {
        int one(0), two(0), three(0);
        for (int i = 0; i < n; i++) {
            two |= (one & A[i]);
            one ^= A[i];
            three = ~(one & two);
            one &= three;
            two &= three;
        }
        return one;
    }
};

2014-11-21 09:47:10 udpate

如果觉得上述的位运算技巧性过强，理解不了的话，其实可以这样换个方法来搞：我们准备 32 个 int 整形，每个整形记录了某一位上，出现 1 的累计次数，例如，我们遇到一个 3，就在 a[0] 和 a[1] 都 ++ 而如果遇到一个 4，就在 a[2] 上累加 1，这样，在全部的数字遍历一次之后，我们就可以把这个 a 数组的值都 % 3，得到的，就是剩下的值了，这个方法跟上述的模拟三进制是本质一样的，但是好理解很多，缺点是写起来会比较长。

这个思路尚未经过实际代码验证。

Single Number

Fri, 24 Oct 2014 11:34:23 +0800

来看这个题，https://oj.leetcode.com/problems/single-number/：

Given an array of integers, every element appears twice except for one. Find that single one.

Note: Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?

第一反应就是异或，唯一需要确认的就是异或运算是否支持交换律，通过这里，http://longzxr.blog.sohu.com/190676432.html，确认了支持，那么答案就很简单了：

class Solution {
public:
    int singleNumber(int A[], int n) {
        int r = 0;
        for (int i = 0; i < n; i++) {
            r ^= A[i];
        }
        return r;
    }
};

历史评论

Single Number II | ZRJ (2014-10-28 21:24:00):

[…] https://oj.leetcode.com/problems/single-number-ii/，承前，http://zrj.me/archives/1344，这个题目是每个数字出现三次，要求找出只出现一次的数字： […]

Linked List Cycle

Mon, 20 Oct 2014 16:24:57 +0800

所谓拳不离手曲不离口，算法和基础不能丢。

话说三藏师徒四人辞别女儿国，再上西行路，今天来到。。。啊呸，扯远了。。

今天来看这个，https://oj.leetcode.com/problems/linked-list-cycle/，题目是这么说的

Given a linked list, determine if it has a cycle in it.

Follow up: Can you solve it without using extra space?

这题原本是简单，他页面上提供了一个在线的编辑器，带语法高亮和自动补全，我三分钟直接在线写完，一次性提交就编译通过同时 Accepted，想想上次刷 OJ 还是很久之前了，如今依然没有手生，还是很开心的，土豪解法如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
 #include <set>
class Solution {
public:
    bool hasCycle(ListNode *head) {
        ListNode* curr = head;
        while (curr) {
            if (viewed.find(curr) != viewed.end()) {
                return true;
            }
            viewed.insert(curr);
            curr = curr->next;
        }
        return false;
    }
    std::set<ListNode*> viewed;
};

类和函数是他给好的，我们要做的就是在类里面填空而已。

可以看到，这个解法不论是在时间还是空间上，都是土豪，何止土豪，那是相当土豪。不过，实际项目中，其实这么写是可以的，稳定，不出错，可维护性高。

不过，原题里还有这么一句，Can you solve it without using extra space?，这个很明显就是见功夫的地方了，要抠时间和空间，时间上是没啥可压缩了，至少也要遍历一次，空间上嘛，他要求没有额外空间，怎么搞呢，想了想，想起来之前看书的时候看到这个题，当时说的是，用两个指针，一个每次走一步，一个每次走两步，如果这两个指针遇上了，那么就说明有环，具体写起来，可以这么写：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */

class Solution {
public:
    bool hasCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while (1) {
            if (slow) {
                slow = slow->next;
            }
            if (fast) {
                fast = fast->next;
                if (fast) {
                    fast = fast->next;
                }
            }
            if (fast == NULL && slow == NULL) {
                return false;
            }
            if (slow == fast) {
                return true;
            }
        }
    }
};

又是一次 Accepted，我都怀疑是不是用例太弱了。。

需要注意的是，如果把最后的两个 if 判断对调位置，变成这样

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */

class Solution {
public:
    bool hasCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while (1) {
            if (slow) {
                slow = slow->next;
            }
            if (fast) {
                fast = fast->next;
                if (fast) {
                    fast = fast->next;
                }
            }
            if (slow == fast) {
                return true;
            }
            if (fast == NULL && slow == NULL) {
                return false;
            }
        }
    }
};

那就会导致 WA，具体为什么可以想想，不难想出来。

不过，这个题目还有一个变式，要求找出环的入口节点，题目在这里，https://oj.leetcode.com/problems/linked-list-cycle-ii/，这个题的解法很是有技巧，分析思路可以看到这里，http://blog.reetsee.com/archives/187

我们设链表的无环的部分长度为L1，即有L1个节点，注意，这个L1是包括环的入口节点的。然后让环的长度是L2，这个L2也是包括环的入口节点。这个时候，p1和p2的交点如图所示，交点距离环的入口节点为a（从入口节点沿着行走方向走到交点），即在环的入口节点后面的第a个节点，就是交点，我用红色标记出a。

然后我们来考察一下L1，L2，a，以及n（n是走过的步数，不是走过的节点数，p1一步一个节点，p2一步两个节点）的关系。

忘记说一点了，我们可以明确的是，p1在进入环后，走了不到一圈就在交点处和p2重合，為什麼肯定没有走完一圈？因为p1在进入环的时候，p2和p1之间的距离（沿着行走方向）至多为 L2-1，不可能超过L2-1，因为环的大小也才只有L2 。p2追赶p1，最多只需要走L2-1步，因为每走一步，p1和p2的相对距离减小1，那么p1最多只走了L2-1步，就是最多只经过了L2-1个节点，不可能走完一圈。

现在可以列公式了：

L1+a=n #1 //n是p1走过的节点数 L1+k*L2+a=2*n #2 //2*n这个是p2走过的节点数，其中的k表示p2可能在环里面走了k圈，k>=1 由#2式减去#1式，有：

k*L2 = n #3 同时由#1和#3得到：

L1+a = k*L2 #4 接着由#4就得到了如下式：

L1 = k*L2 – a = (k-1)*L2 + (L-a) 得到这条式子就拨得云开见月明啊有木有，因为(L-a)表示的是交点与环入口的距离（从交点沿着行走方向到环入口），然后(k-1)是>=0的，因为p2在环中至少绕了一圈，这样我们就发现：L1的长度 = 环长度的整数倍 + 交点与环入口的距离

也就是说，p1再走L1步就可以达到环的入口。问题是L1不是已知的，没关系，在表头设置一个p3指针，p3每步前进一个节点。让p1和p3同时走，每次走1步，等p3和p1重合了，就是到了环口的位置了。Problem solved~

很自然的，写出下面的代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode *fast(head), *slow(head), *p1(head);
        while (1) {
            if (slow) {
                slow = slow->next;
            }
            if (fast) {
                fast = fast->next;
                if (fast) {
                    fast = fast->next;
                }
            }
            if (fast == NULL && slow == NULL) {
                return NULL;
            }
            if (slow == fast) {
                while (1) {
                    slow = slow->next;
                    p1 = p1->next;
                    if (p1 == slow) {
                        return p1;
                    }
                }
            }
        }
    }
};

但是这样是 WA 的，OJ 很仁慈的把错误说出来了

Input: {1,2}, tail connects to node index 0 Output: tail connects to node index 1 Expected: tail connects to node index 0

也就是说，考虑这种情况：整个链表只有两个节点，并且这两个节点构成一个环，那么上述代码就出错了，打个补丁：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode *fast(head), *slow(head), *p1(head);
        while (1) {
            if (slow) {
                slow = slow->next;
            }
            if (fast) {
                fast = fast->next;
                if (fast) {
                    fast = fast->next;
                }
            }
            if (fast == NULL && slow == NULL) {
                return NULL;
            }
            if (slow == fast) {
                if (slow == head) {
                    return head;
                }
                while (1) {
                    slow = slow->next;
                    p1 = p1->next;
                    if (p1 == slow) {
                        return p1;
                    }
                }
            }
        }
    }
};

得以 Accepted，而其实，上述的代码，是可以进一步改的，注意到我们外面的那个循环，为了保守起见，是等慢指针遍历到尾，才退出的，其实根本没必要，只要快指针遇到 NULL 了，就可以撤了，如下

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode *fast(head), *slow(head);
        while (fast && fast->next) {
            slow = slow->next;
            fast = fast->next->next;
            if (slow == fast) {
                ListNode *p(head);
                while (p != slow) {
                    slow = slow->next;
                    p = p->next;
                }
                return p;
            }
        }
        return NULL;
    }
};

-——————————-

2014-11-21 09:43:45 update

另外的一个思路是，每次前进一个节点，就把这个节点的 next 指针指向 head，这样，如果发现在某个节点被处理之前，就已经指向 head，那么就可以知道有环了，而且这个方法还可以天然的找出环的入口，不需要额外空间，缺点是破坏链表，一次处理之后，链表就被破坏的面目全非了。

这个思路尚未经过实际代码验证。

历史评论

wanax (2015-01-20 14:38:47):

真有闲情逸致….