Bloomberg面经准备: Josephus problem

Given a circular single linked list.Write a program that deletes every kth node until only one node is left. 
After kth node is deleted, start the procedure from (k+1)th node. 
e.g.list is 1->2->3->4->5->1 
k=3 
1. You are at 1, delete 3. 
List is: 1->2->4->5->1 
2. You are at 4, delete 1 
List is: 2->4->5->2 
3. You are at 2,delete 5 
List is: 2->4->2 
4. You are at 2, delete 2 
List is: 4 
Return 4. 

How efficient you can do it?

 Solution 1: Math

Let  f(n,k) denote the position of the survivor. After the  kth person is killed, we're left with a circle of  n-1, and we start the next count with the person whose number in the original problem was (k mod n)+1. The position of the survivor in the remaining circle would be f(n-1,k), if we start counting at 1; shifting this to account for the fact that we're starting at (k mod n)+1 yields the recurrence

f(n, k) = ((f(n-1, k) + k - 1) mod n) + 1, 

f(1, k) = 1

这样理解：

新数组len = n-1， 其中1th num在原数组的位置是  (k mod n)+1, 也就是 (1 + (k-1))mod n+ 1

2nd num 在原数组位置是 （2 + （k-1））mod n + 1

3rd num 在原数组位置是 （3 + （k-1））mod n + 1

After the first person (kth from begining) is killed, n-1 persons are left. So we call josephus(n – 1, k) to get the position with n-1 persons. But the position returned by josephus(n – 1, k) will consider the position starting from k%n + 1. So, we must make adjustments to the position returned by josephus(n – 1, k).

Following is simple recursive implementation of the Josephus problem. The implementation simply follows the recursive structure mentioned above.

Time Complexity, O(N), DP

#include <stdio.h>
 
int josephus(int n, int k)
{
  if (n == 1)
    return 1;
  else
    /* The position returned by josephus(n - 1, k) is adjusted because the
       recursive call josephus(n - 1, k) considers the original position 
       k%n + 1 as position 1 */
    return (josephus(n - 1, k) + k-1) % n + 1;
}
 
// Driver Program to test above function
int main()
{
  int n = 14;
  int k = 2;
  printf("The chosen place is %d", josephus(n, k));
  return 0;
}

Solution 2: Simulate the process

Singly LinkedList

先扫一遍，确定有环，并且找到head上一跳节点，然后loop直到head.next == head

package bloomberg;

public class Josephus {
    public class ListNode {
        ListNode next;
        int val;
        public ListNode(int val) {
            this.val = val;
            this.next = null;
        }
    }
    
    public int survive(ListNode head, int k) {
        if (head == null) return -1;
        ListNode prev = head;
        while (prev!=null && prev.next!=head) {
            prev = prev.next;
        }
        if (prev == null) return -1; //not a loop
        //now prev is the previous node of head
        int count = 1;
        while (head.next != head) {
            if (count == k) {
                prev.next = head.next;
                head = head.next;
                count = 1;
            }
            else {
                head = head.next;
                prev = prev.next;
                count++;
            }
        }
        return head.val;
    }
    
    public static void main(String[] args) {
        Josephus sol = new Josephus();
        ListNode node1 = sol.new ListNode(1);
        ListNode node2 = sol.new ListNode(2);
        ListNode node3 = sol.new ListNode(3);
        ListNode node4 = sol.new ListNode(4);
        ListNode node5 = sol.new ListNode(5);
        ListNode node6 = sol.new ListNode(6);
        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
        node4.next = node5;
        node5.next = node6;
        node6.next = node1;
        int res = sol.survive(node1, 2);
        System.out.println(res);
    }
}

Doubly LinkedList

可以一边loop一边确定是不是有环，while loop结束条件是 head.next != null && head.next != head, 如果出现head.next == null说明无环， 如果

head.next == head说明仅剩一个元素，正常结束