复习系列1-约瑟夫环 (Ver. I - A)

约瑟夫环 (Ver. I - A)

这题出了点玄学问题，一直时间超限50%；后来尝试了优化的输入输出，然并卵，估计问题出在某个情况下的死循环或者原算法本身的时间复杂度过高。（感觉因为算法效率过低的可能性不大，但是确实A不过）；

此外，记录下优化后的输入输出的用法。

//1-3补充，找老师要了后台，发现确实是算法效率低了，之前的代码在删除head指向的元素的时候，需要遍历所有元素，让head重新指向head 的前一个元素（循环链表，也就是原本的最后一个元素，如果数据是每次都删除head，那么算法时间复杂度就会很高）

//补充的后台数据，输出就不用看了，看看跑完要花多少时间，基本要好几秒的就肯定是算法效率问题
876217 1 123456
123456 4 1
1 1 1
10 10 10

import java.io.*; // 需要添加该包
/*
定义输入输出
*/
public static void main(String[] args) throws IOException{//此处需要抛出IOE异常
    StreamTokenizer in = new StreamTokenizer(
            new BufferedReader(new InputStreamReader(System.in)));
    PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        while (in.nextToken()!=StreamTokenizer.TT_EOF){//判断是否有下一个输入
        //输入
            n = (int) in.nval;
            in.nextToken();//每接受一次需要再刷新一次缓冲
            k = (int) in.nval;
            in.nextToken();
            s = (int) in.nval;
        //输出
            out.print(node.data+" ");
            out.println();
            out.flush();//没有flush将不会输出

题目描述

N个人坐成一个圆环（编号为1 - N），从第S个人开始报数，数到K的人出列，后面的人重新从1开始报数。问最后剩下的人的编号。

例如：N = 3，K = 2，S = 1。2号先出列，然后是1号，最后剩下的是3号。

要求使用循环链表实现。

输入

测试数据有多组，

每组包括3个数N、K、S，表示有N个人，从第S个人开始，数到K出列。(1 <= N <= 10^6，1 <= K <= 10,  1 <= S <= N)

输出

出列的人的编号

样例输入

13 3 1

3 2 1

样例输出

3 6 9 12 2 7 11 4 10 5 1 8 13

2 1 3

Solution：

import java.io.*;
import java.util.*;

/**
 * @author: Liu Canbin
 * @date: 2019/1/3
 */

public class Main {
    static Node head;
    static Scanner scanner = new Scanner(System.in);
//    static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
//    static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
    public static void main(String[] args) {

        Node temp;
        int n,k,s;
//        while (in.nextToken()!=StreamTokenizer.TT_EOF){
//            n = (int) in.nval;
//            in.nextToken();
//            k = (int) in.nval;
//            in.nextToken();
//            s = (int) in.nval;
        while (scanner.hasNextInt()){
             n = scanner.nextInt();
             k = scanner.nextInt();
             s = scanner.nextInt();
            head = new Node(1);
            head.next = head;
            temp = head;
            for (int i = 2; i <=n ; i++) {
                Node node = new Node(i);
                node.next =head;
                temp.next = node;
                temp = temp.next;
            }
            for (int i = 0; i <s-1 ; i++) {
                temp = temp.next;
            }
            for (int i = 0; i <n ; i++) {
                for (int j = 1; j < k; j++) {
                    temp = temp.next;
                }
                Node node;
                node = temp.next;
                temp.next = node.next;
//                out.print(node.data+" ");
                System.out.print(node.data+" ");
            }
//            out.println();
//            out.flush();
            System.out.println();
        }
    }
}

class Node{
    int data;
    Node next;
    Node(int data){
        this.data =data;
        next = null;
    }
}