fast slow Archives - Huahua's Tech Road

花花酱 LeetCode 202. Happy Number

zxi — Mon, 06 Dec 2021 03:18:33 +0000

Write an algorithm to determine if a number n is happy.

A happy number is a number defined by the following process:

Starting with any positive integer, replace the number by the sum of the squares of its digits.
Repeat the process until the number equals 1 (where it will stay), or it loops endlessly in a cycle which does not include 1.
Those numbers for which this process ends in 1 are happy.

Return true if n is a happy number, and false if not.

Example 1:

Input: n = 19
Output: true
Explanation:
1² + 9² = 82
8² + 2² = 68
6² + 8² = 100
1² + 0² + 0² = 1

Example 2:

Input: n = 2
Output: false

Constraints:

1 <= n <= 2³¹ - 1

Solution: Simulation

We can use a hasthable to store all the number we generated so far.

Time complexity: O(L)
Space complexity: O(L)

C++

// Author: Huahua
class Solution {
public:
  bool isHappy(int n) {
    auto getNext = [](int x) -> int {
      int ans = 0;
      while (x) {
        ans += (x % 10) * (x % 10);
        x /= 10;
      }
      return ans;
    };
    
    unordered_set s;
    while (n != 1) {
      if (!s.insert(n).second) return false;
      n = getNext(n);
    }
    return true;
  }
};

Optimization: Space reduction

Since the number sequence always has a cycle, we can use slow / fast pointers to detect the cycle without using a hastable.

Time complexity: O(L)
Space complexity: O(1)

C++

// Author: Huahua
class Solution {
public:
  bool isHappy(int n) {
    auto getNext = [](int x) -> int {
      int ans = 0;
      while (x) {
        ans += (x % 10) * (x % 10);
        x /= 10;
      }
      return ans;
    };
    
    int slow = n;
    int fast = getNext(n);
    do {      
      slow = getNext(slow);
      fast = getNext(getNext(fast));
    } while (slow != fast);
    return slow == 1;
  }
};

The post 花花酱 LeetCode 202. Happy Number appeared first on Huahua's Tech Road.

花花酱 LeetCode 2095. Delete the Middle Node of a Linked List

zxi — Sun, 05 Dec 2021 06:24:18 +0000

You are given the head of a linked list. Delete the middle node, and return the head of the modified linked list.

The middle node of a linked list of size n is the ⌊n / 2⌋^th node from the start using 0-based indexing, where ⌊x⌋ denotes the largest integer less than or equal to x.

For n = 1, 2, 3, 4, and 5, the middle nodes are 0, 1, 1, 2, and 2, respectively.

Example 1:

Input: head = [1,3,4,7,1,2,6]
Output: [1,3,4,1,2,6]
Explanation:
The above figure represents the given linked list. The indices of the nodes are written below.
Since n = 7, node 3 with value 7 is the middle node, which is marked in red.
We return the new list after removing this node.

Example 2:

Input: head = [1,2,3,4]
Output: [1,2,4]
Explanation:
The above figure represents the given linked list.
For n = 4, node 2 with value 3 is the middle node, which is marked in red.

Example 3:

Input: head = [2,1]
Output: [2]
Explanation:
The above figure represents the given linked list.
For n = 2, node 1 with value 1 is the middle node, which is marked in red.
Node 0 with value 2 is the only node remaining after removing node 1.

Constraints:

The number of nodes in the list is in the range [1, 10⁵].
1 <= Node.val <= 10⁵

Solution: Fast / Slow pointers

Use fast / slow pointers to find the previous node of the middle one, then skip the middle one.

prev.next = prev.next.next

Time complexity: O(n)
Space complexity: O(1)

C++

class Solution {
public:
  ListNode* deleteMiddle(ListNode* head) {
    ListNode dummy(0, head);
    ListNode* prev = &dummy;
    ListNode* fast = head;
    // prev points to the previous node of the middle one.
    while (fast && fast->next) {
      prev = prev->next;
      fast = fast->next->next;
    }    
    prev->next = prev->next->next;
    return dummy.next;
  }
};

The post 花花酱 LeetCode 2095. Delete the Middle Node of a Linked List appeared first on Huahua's Tech Road.

花花酱 LeetCode 143. Reorder List

zxi — Mon, 29 Nov 2021 07:08:40 +0000

You are given the head of a singly linked-list. The list can be represented as:

L₀ → L₁ → … → L_{n - 1} → L_n

Reorder the list to be on the following form:

L₀ → L_n → L₁ → L_{n - 1} → L₂ → L_{n - 2} → …

You may not modify the values in the list’s nodes. Only nodes themselves may be changed.

Example 1:

Input: head = [1,2,3,4]
Output: [1,4,2,3]

Example 2:

Input: head = [1,2,3,4,5]
Output: [1,5,2,4,3]

Constraints:

The number of nodes in the list is in the range [1, 5 * 10⁴].
1 <= Node.val <= 1000

Solution: Three steps

Step 1: Find mid node that splits the list into two halves.
Step 2: Reverse the second half
Step 3: Merge two lists

Time complexity: O(n)
Space complexity: O(1)

C++

// Author: Huahua
class Solution {
public:
  void reorderList(ListNode* head) {
    if (!head || !head->next) return;
    ListNode* slow = head;
    ListNode* fast = head;            

    while (fast->next && fast->next->next) {
      slow = slow->next;
      fast = fast->next->next;          
    }
    
    ListNode* h1 = head;
    ListNode* h2 = reverse(slow->next);
    slow->next = nullptr;

    while (h1 && h2) {
      ListNode* n1 = h1->next;
      ListNode* n2 = h2->next;
      h1->next = h2;
      h2->next = n1;
      h1 = n1;
      h2 = n2;
    }
  }
private:       
  // reverse a linked list
  // returns head of the linked list
  ListNode* reverse(ListNode* head) {
    if (!head || !head->next) return head;

    ListNode* prev = head;
    ListNode* cur = head->next;
    ListNode* next = cur;
    while (cur) {
      next = next->next;
      cur->next = prev;
      prev = cur;
      cur = next;
    }

    head->next = nullptr;
    return prev;
  }
};

The post 花花酱 LeetCode 143. Reorder List appeared first on Huahua's Tech Road.

花花酱 LeetCode 19. Remove Nth Node From End of List

zxi — Thu, 20 Sep 2018 06:54:23 +0000

Problem

Given a linked list, remove the n-th node from the end of list and return its head.

Example:

Given linked list: 1->2->3->4->5, and n = 2.

After removing the second node from the end, the linked list becomes 1->2->3->5.

Note:

Given n will always be valid.

Follow up:

Could you do this in one pass?

Solution 0: Cheating! store the nodes in an array

C++

// Author: Huahua
class Solution {
public:
  ListNode *removeNthFromEnd(ListNode *head, int n) {
    if (!head) return nullptr;
    vector nodes;
    ListNode *cur = head;
    while (cur) {
      nodes.push_back(cur);
      cur = cur->next;
    }
    if (n == nodes.size()) return head->next;
    ListNode* nodes_to_remove = nodes[nodes.size()-n];
    ListNode* parent = nodes[nodes.size() - n - 1];
    parent->next = nodes_to_remove->next;
    delete nodes_to_remove;
    return head;
  }
};

Solution 1: Two passes

Time complexity: O(L)

Space complexity: O(1)

C++

// Author: Huahua
class Solution {
public:
  ListNode* removeNthFromEnd(ListNode* head, int n) {
    int l = 0;
    ListNode* cur = head;
    while (cur) {
      ++l;
      cur = cur->next;
    }
    if (n == l) {
      ListNode* ans = head->next;
      delete head;
      return ans;
    }    
    l -= n;
    cur = head;
    while (--l) cur = cur->next;
    ListNode* node = cur->next;
    cur->next = node->next;
    delete node;
    return head;
  }
};

Solution 2: Fast/Slow Pointers + Dummy Head / Prev

Fast pointer moves n steps first, and then slow pointer starts moving.

When fast pointer reaches tail, slow pointer is n-th node from the end.

Time complexity: O(L)

Space complexity: O(1)

C++

// Author: Huahua
class Solution {
public:
  ListNode* removeNthFromEnd(ListNode* head, int n) {
    ListNode* fast = head;
    for (int i = 0; i < n; ++i) 
      fast = fast->next;
    ListNode dummy(0);
    dummy.next = head;
    ListNode* prev = &dummy;
    while (fast) {
      fast = fast->next;
      prev = prev->next;
    }
    ListNode* node = prev->next;
    prev->next = node->next;
    delete node;
    return dummy.next;
  }
};

Java

// Author: Huahua
class Solution {
  public ListNode removeNthFromEnd(ListNode head, int n) {
    ListNode dummy = new ListNode(0);
    dummy.next = head;
    ListNode fast = head;
    while (n-- > 0) fast = fast.next;
    ListNode prev = dummy;
    while (fast != null) {
      fast = fast.next;
      prev = prev.next;
    }
    prev.next = prev.next.next;
    return dummy.next;
  }
}

Python3

# Author: Huahua
class Solution:
  def removeNthFromEnd(self, head, n):
    dummy = ListNode(0)
    dummy.next = head
    fast, prev = head, dummy
    for _ in range(n): 
      fast = fast.next
    while fast:
      fast, prev = fast.next, prev.next
    prev.next = prev.next.next
    return dummy.next

The post 花花酱 LeetCode 19. Remove Nth Node From End of List appeared first on Huahua's Tech Road.

花花酱 LeetCode 141. Linked List Cycle

zxi — Fri, 24 Aug 2018 16:18:07 +0000

Problem

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

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

Solution1: HashTable

Time complexity: O(n)

Space complexity: O(n)

// Author: Huahua
// Running time: 16 ms
class Solution {
public:
  bool hasCycle(ListNode *head) {
    unordered_set seen;
    while (head) {
      if (seen.count(head)) return true;
      seen.insert(head);
      head = head->next;
    }
    return false;
  }
};

Solution2: Fast + Slow pointers

Time complexity: O(n)

Space complexity: O(1)

// Author: Huahua
// Running time: 8 ms
class Solution {
public:
  bool hasCycle(ListNode *head) {
    auto slow = head;
    auto fast = head;
    while (fast) {
      if (!fast->next) return false;
      fast = fast->next->next;
      slow = slow->next;
      if (fast == slow) return true;
    }
    return false;
  }
};

The post 花花酱 LeetCode 141. Linked List Cycle appeared first on Huahua's Tech Road.

花花酱 LeetCode 148. Sort List

zxi — Fri, 27 Jul 2018 04:57:00 +0000

Problem

Sort a linked list in O(n log n) time using constant space complexity.

Example 1:

Input: 4->2->1->3
Output: 1->2->3->4

Example 2:

Input: -1->5->3->4->0
Output: -1->0->3->4->5

Solution: Merge Sort

Top-down (recursion)

Time complexity: O(nlogn)

Space complexity: O(logn)

C++

// Author: Huahua
// Running time: 32 ms
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
  ListNode* sortList(ListNode* head) {
    // 0 or 1 element, we are done.
    if (!head || !head->next) return head;
    ListNode* slow = head;
    ListNode* fast = head->next;    
    while (fast && fast->next) {
      fast = fast->next->next;
      slow = slow->next;
    }
    ListNode* mid = slow->next;    
    slow->next = nullptr; // Break the list.
    return merge(sortList(head), sortList(mid));
  }
private:
  ListNode* merge(ListNode* l1, ListNode* l2) {
    ListNode dummy(0);
    ListNode* tail = &dummy;
    while (l1 && l2) {
      if (l1->val > l2->val) swap(l1, l2);
      tail->next = l1;
      l1 = l1->next;
      tail = tail->next;
    }
    tail->next = l1 ? l1 : l2;    
    return dummy.next;
  }
};

Java

// Author: Huahua
// Running time: 6 ms
class Solution {
  public ListNode sortList(ListNode head) {
    if (head == null || head.next == null) return head;
    ListNode slow = head;
    ListNode fast = head.next;
    while (fast != null && fast.next != null) {
      fast = fast.next.next;
      slow = slow.next;
    }
    ListNode mid = slow.next;
    slow.next = null;
    return merge(sortList(head), sortList(mid));
  }
  
  private ListNode merge(ListNode l1, ListNode l2) {
    ListNode dummy = new ListNode(0);
    ListNode tail = dummy;
    while (l1 != null && l2 != null) {
      if (l1.val > l2.val) {
        ListNode tmp = l1;
        l1 = l2;
        l2 = tmp;
      }
      tail.next = l1;
      l1 = l1.next;
      tail = tail.next;
    }
    tail.next = (l1 != null) ? l1 : l2;
    return dummy.next;
  }
}

Python3

# Author: Huahua, 232 ms
class Solution:
  def sortList(self, head):
    def merge(l1, l2):
      dummy = ListNode(0)
      tail = dummy
      while l1 and l2:
        if l1.val > l2.val: l1, l2 = l2, l1
        tail.next = l1
        l1 = l1.next
        tail = tail.next
      tail.next = l1 if l1 else l2
      return dummy.next
    
    if not head or not head.next: return head
    slow = head
    fast = head.next
    while fast and fast.next:
      fast = fast.next.next
      slow = slow.next
    mid = slow.next
    slow.next = None
    return merge(self.sortList(head), self.sortList(mid))

bottom up

Time complexity: O(nlogn)

Space complexity: O(1)

// Author: Huahua
// Running time: 32 ms
class Solution {
public:
  ListNode* sortList(ListNode* head) {
    // 0 or 1 element, we are done.
    if (!head || !head->next) return head;
    
    int len = 1;
    ListNode* cur = head;
    while (cur = cur->next) ++len;
    
    ListNode dummy(0);
    dummy.next = head;
    ListNode* l;
    ListNode* r;
    ListNode* tail;
    for (int n = 1; n < len; n <<= 1) {      
      cur = dummy.next; // partial sorted head
      tail = &dummy;
      while (cur) {
        l = cur;
        r = split(l, n);
        cur = split(r, n);
        auto merged = merge(l, r);
        tail->next = merged.first;
        tail = merged.second;
      }
    }      
    return dummy.next;
  }
private:
  // Splits the list into two parts, first n element and the rest.
  // Returns the head of the rest.
  ListNode* split(ListNode* head, int n) {    
    while (--n && head)
      head = head->next;
    ListNode* rest = head ? head->next : nullptr;
    if (head) head->next = nullptr;
    return rest;
  }
  
  // Merges two lists, returns the head and tail of the merged list.
  pair merge(ListNode* l1, ListNode* l2) {
    ListNode dummy(0);
    ListNode* tail = &dummy;
    while (l1 && l2) {
      if (l1->val > l2->val) swap(l1, l2);
      tail->next = l1;
      l1 = l1->next;
      tail = tail->next;
    }
    tail->next = l1 ? l1 : l2;
    while (tail->next) tail = tail->next;
    return {dummy.next, tail};
  }
};

The post 花花酱 LeetCode 148. Sort List appeared first on Huahua's Tech Road.