约瑟夫环图文详解

想了解更多数据结构以及算法题,可以关注微信公众号“数据结构和算法”,每天一题为你精彩解答。也可以扫描下面的二维码关注
在这里插入图片描述
问题来源:

据说著名犹太历史学家 Josephus有过以下的故事:在罗马人占领乔塔帕特后,39 个犹太人与Josephus及他的朋友躲到一个洞中,39个犹太人决定宁愿死也不要被敌人抓到,于是决定了一个自杀方式,41个人排成一个圆圈,由第1个人开始报数,每报数到第3人该人就必须自杀,然后再由下一个重新报数,直到所有人都自杀身亡为止。然而Josephus 和他的朋友并不想遵从。首先从一个人开始,越过k-2个人(因为第一个人已经被越过),并杀掉第k个人。接着,再越过k-1个人,并杀掉第k个人。这个过程沿着圆圈一直进行,直到最终只剩下一个人留下,这个人就可以继续活着。问题是,给定了和,一开始要站在什么地方才能避免被处决?Josephus要他的朋友先假装遵从,他将朋友与自己安排在第16个与第31个位置,于是逃过了这场死亡游戏。

一,留下K-1个

41数字太大了,我们就以7为例,来画个图看一下

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
我们再来看下代码

1,数组的实现

 public static Integer[] solution(int count, int k) {
     Integer live[] = new Integer[Math.min(count, k - 1)];
     if (count < k) {
         int index = 0;
         while (index < count) {
             live[index++] = index;
         }
         return live;
     }
    List<Integer> mList = new ArrayList<>(count);
    for (int i = 0; i < count; i++) {
        mList.add(i + 1);
    }

    int point = 0;
    int number = 0;
    while (mList.size() >= k) {
        number++;
        if (point >= mList.size()) {
            point = 0;
        }
        if (number % k == 0) {
            mList.remove(point);
            continue;
        }
        point++;
    }
    return mList.toArray(live);
}

1, 3-9行表示如果k大于count就直接把所有人的编号都返回即可,不再删除了。

2, 11-13行生成从1到count的所有值(包含1和count)

3, 16行number统计数量,在第22-25行如果统计的数量是k的倍数就把他移除。其实我们也可以在22行成立的时候让number重新归0。这里使用的是对k求余也是可以的。

4, 我们就用上面已知的两组数据测试一下,当count等于41的时候结果是16和31,当count等于7的时候结果是1和4

    Util.printObjectArrays(solution(41, 3));
    System.out.println("---------------------");
    Util.printObjectArrays(solution(7, 3));

运行结果是

        16
        31
        ---------------------
        1
        4

结果完全正确。

数组的删除会导致后面的元素都会往前移,频繁的删除效率肯定不是很高,其实我们还可以使用链表。因为链表的删除不需要移动后面的元素,效率还是比较高的。如果不使用链表,我们还可以把数组中删除的元素用一个负数来填充,这样也是可以的。我们来看下

2,数组实现的另一种方式

/**
  * @param count 总人数
  * @param k     每隔几个人杀掉
  * @return
  */
 public static Integer[] solution(int count, int k) {
     Integer live[] = new Integer[Math.min(count, k - 1)];
     if (count < k) {
         int index = 0;
        while (index < count) {
            live[index++] = index;
        }
        return live;
    }
    List<Integer> mList = new ArrayList<>(count);
    for (int i = 0; i < count; i++) {
        mList.add(i + 1);
    }

    int point = 0;
    int number = 0;
    int total = count - k + 1;//记录总共删除的个数
    while (true) {
        if (total <= 0)
            break;
        if (point >= mList.size()) {
            point = 0;
        }
        if (mList.get(point) < 0) {
            point++;
            continue;
        }
        number++;
        if (number % k == 0) {
            mList.set(point, -1);//如果是第k个,就把他变为负数
            total--;
            continue;
        }
        point++;
    }
    int index = 0;
    for (int i = 0; i < mList.size(); i++) {
        if (mList.get(i) > 0)
            live[index++] = mList.get(i);
    }
    return live;
}

第35行该删除的我们没有删除,直接把他变为-1。在29行统计的时候如果为负数表示已经被删除了,就直接跳过,执行下一轮循环。第42-45行把最后没有被删除的放到数组live中。

3,链表实现

一般来说链表的断开要比数组的删除效率要高一些,因为数组删除某个元素之后,它后面的元素都还要往前移。使用链表会更简单一些,我们可以把它想象为一圈人大家都手牵着手,然后再一个个报数,当报到k的时候就自动退出,退出的时候左右两边人的手要牵到一块重新构成一个新的环,代码很简单,我们看下

 public static Integer[] solution(int count, int k) {
     Integer live[] = new Integer[Math.min(count, k - 1)];
     if (count < k) {
         int index = 0;
         while (index < count) {
             live[index++] = index;
         }
         return live;
     }
    LinkedList<Integer> mList = new LinkedList<>();
    for (int i = 0; i < count; i++) {
        mList.addLast(i + 1);
    }

    int point = 0;
    int number = 0;
    while (mList.size() >= k) {
        number++;
        if (point >= mList.size()) {
            point = 0;
        }
        if (number % k == 0) {
            mList.remove(point);
            continue;
        }
        point++;
    }
    return mList.toArray(live);
}

队列实现:

除了上面说的数组和链表以外,我们还可以使用队列。这个实现起来也非常简单。我们把所有的元素全部入队,然后再一个个出队,出队的时候记录出队的个数,如果不是第k个就让他重新入队,如果是第k个就不用了入队了,然后下一个出队的再重新从1开始计算。我们还是以7来画个图看一下。

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
我们先来看一下代码,队列就是用之前写的3,常见数据结构-队列中的双端队列。

/**
  * @param count 总人数
  * @param k     每隔几个人杀掉
  * @return
  */
 public static Integer[] solution(int count, int k) {
     Integer live[] = new Integer[Math.min(count, k - 1)];
     if (count < k) {
         int index = 0;
        while (index < count) {
            live[index++] = index;
        }
        return live;
    }
    MyQueue<Integer> queue = new MyQueue<>(count + 1);
    for (int i = 0; i < count; i++) {
        queue.addLast(i + 1);
    }

    int number = 1;
    while (queue.size() >= k) {
        Integer item = queue.removeFirst();
        if (number % k == 0) {
            number = 1;
            continue;
        }
        queue.addLast(item);
        number++;
    }
    int index = 0;
    while (!queue.isEmpty()) {
        live[index++] = queue.removeFirst();
    }
    return live;
}

二,只留下一个

上面我们讲的是每到第K个删除,如果count大于等于k的话,最终会留下k-1个。但对这题还有另一个版本,就是无论多少个,最后只留下1个,就是说如果数量小于k个的时候我们继续循环删除,直到留下最后一个的为止。原理和上面非常类似,只不过当删除到最后小于K个的时候我们还要继续循环即可。图就不再画了,我们就用最后双端队列这种实现来改一下。

1,双端队列解决

public static Integer solution(int count, int k) {
     MyQueue<Integer> queue = new MyQueue<>(count + 1);
     for (int i = 0; i < count; i++) {
         queue.addLast(i + 1);
     }
     int number = 1;
     while (queue.size() > 1) {
         Integer item = queue.removeFirst();
         if (number % k == 0) {
            number = 1;
            continue;
        }
        queue.addLast(item);
        number++;
    }
    return queue.removeFirst();
}

2,递归解决

我们用f(n,k)表示有n个人,第k个出列,最后列出的人的编号。

那么f(n-1,k)就表示有n-1个人,第k个出列,最后列出的人的编号。

所以我们可以找到递归的公式f(n,k)=f(n-1,k)+k;也就是说n-1个人组成的环相对于n个人组成的环相当于顺时针旋转了k个单位。因为是环形的,当超出环的大小的时候我们要对它求余,所以为了防止越界问题我们要这样写f(n,k)=(f(n-1,k)+k)%n。

当f(1,k)的时候就表示剩下最后一个元素了,我们直接返回即可。

我们来看下代码

public static int solution(int n, int k) {
    return helper(n, k) + 1;
}

public static int helper(int n, int m) {
    if (n == 1)
        return 0;
    return (helper(n - 1, m) + m) % n;
}

因为人的编号是从1开始的,所以这里要加1。当然我们还可以再来改一下,这样就不用在加1,就可以直接返回了。

public static int solution(int n, int k) {
    if (n == 1)
        return n;
    return (solution(n - 1, k) + k - 1) % n + 1;
}

3,非递归写法

看明白了上面的递归的思路,我们还可以把它改为非递归的写法

public static int solution(int n, int k) {
    int m = 0;
    for (int i = 2; i <= n; i++) {
        m = (m + k) % i;
    }
    return m + 1;
}

他的原理是这样的,从前往后推,如果当n=i的时候,最终留下的是m,那么当n=i+1的时候,最终留下的就是m+k,考虑到m+k可能大于环的长度,所以要对m+k进行求余,结果就是(m+k)%i,一直循环到i等于n就是最终结果。

总结:

这题只要是学过编程的大多数应该都听过,无论是使用数组,链表,还是队列都很容易解决,具有一定的代表性,希望大家能够熟练掌握。

展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 编程工作室 设计师: CSDN官方博客
应支付0元
点击重新获取
扫码支付

支付成功即可阅读