【Codeforces 1091D】New Year and the Permutation Concatenation

【链接】 我是链接,点我呀:)

【题意】

把1~n的n!种排列依次连接成一个长度为n*n!的序列。
让你在这个序列当中找长度为n的连续段,使得连续段中的数字的和为n*(n-1)/2
输出符合要求的连续段的个数

【题解】

也就是让你找到长度为n的连续段,然后里面1~n各出现一次
考虑相邻的两个排列
设他们有长度为i的相同前缀
例如
xxabcxxcba
会发现我们用第二个排列的前i个数字与第一个排列的后n-i个数字能够组成一个符合要求的连续段。
即"abcxx"
为什么?
假设我们放一个长度为n的窗口在"xxabc"的位置
我们往右挪动了一下
少了一个最左边的x,右边会新出来一个数字,它要为什么才行呢?
因为总和不能变,所以肯定和刚才少掉的数字要一样。
那么显然就只有在他们俩有相同的前缀的时候才能办到这样的事情。
所以我们枚举前缀的长度为i
这样的排列有A(n,i)个
对于这A(n,i)种排列,他们的后n-i个位置还有(n-i)!种
我们先假设我们已经固定了前i个数字,也就是说固定了要讨论的前缀的样子x
那么前缀为x的排列一共有(n-i)!种
显然这(n-i)!种肯定是连接在一起的(因为是按照字典序连接的)
假设(n-i)!等于3
那么就对应了
xabcxbacxcab
(只是举例)
那么就能够组成
"abcx","bacx"这两个符合要求的
也即在(n-i)!-1个交界处产生答案
记住我们是如何找答案的:
后一个排列的前i个数字与前一个排列的后n-i个数字组成一个符合要求的连续段。
(前一个排列的n-i个数字,在前缀x相同的情况下,都是不一样的,所以不会重复计数
(而我们又覆盖到了所有不同的前缀i,因此也没有重复计数
而前缀x有A(n,i)种
那么总共就有A(n,i)*((n-1)!-1)种连续段符合要求

【代码】

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

public class Main {

    static InputReader in;
    static PrintWriter out;

    public static void main(String[] args) throws IOException{
        //InputStream ins = new FileInputStream("E:\\rush.txt");
        InputStream ins = System.in;
        in = new InputReader(ins);
        out = new PrintWriter(System.out);
        //code start from here
        new Task().solve(in, out);
        out.close();
    }

    static int N = (int)1e6;
    static class Task{

    	/*
    	 * i = 1~n-1
    	 * A(n,i)*( (n-i)! - 1);
    	 * n!/(n-i)!
    	 */
        int n;
        long fac[] = new long[N+10];
        long rfac[] = new long[N+10];
        long MOD = (int)998244353;

        long _pow(long x,long y) {
        	long ans = 1;
        	while (y>0) {
        		if (y%2==1) {
        			ans = (ans * x)%MOD;
        		}
        		x = x*x%MOD;
        		y = y/2;
        	}
        	return ans;
        }

        public void solve(InputReader in,PrintWriter out) {
        	n = in.nextInt();
        	fac[0] = 1;
        	for (int i = 1;i <= N;i++)
        		fac[i] = (1l*fac[i-1]*i)%MOD;
        	rfac[N] = _pow(fac[N],MOD-2);
        	for (int i = N-1;i>=0;i--)
        		rfac[i] = 1l*rfac[i+1]*(i+1)%MOD;
        	long ans = 0;
        	for (int i = 1;i <= n-1;i++) {
        		long temp = fac[n]*rfac[n-i]%MOD*(fac[n-i]-1)%MOD;
        		if (temp<0) temp+=MOD;
        		ans = (ans + temp)%MOD;
        	}
        	ans = (ans + fac[n])%MOD;
        	out.println(ans);
        }
    }

    static class InputReader{
        public BufferedReader br;
        public StringTokenizer tokenizer;

        public InputReader(InputStream ins) {
            br = new BufferedReader(new InputStreamReader(ins));
            tokenizer = null;
        }

        public String next(){
            while (tokenizer==null || !tokenizer.hasMoreTokens()) {
                try {
                tokenizer = new StringTokenizer(br.readLine());
                }catch(IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }
    }
}