ACM-ICPC北京赛区(2017)网络赛2【后缀数组+Java//不会】

#1579 : Reverse Suffix Array

时间限制:1000ms

单点时限:1000ms

内存限制:256MB

描述

There is a strong data structure called "Suffix Array" which can effectively solve string problems.

Let S=s1s2...sn be a string and let S[i,j] denote the substring of S ranging from i to j. The suffix array A of S is now defined to be an array of integers providing the starting positions of suffixes of S in lexicographical order. This means, an entry A[i] is the starting position of the i-th smallest suffix in S and thus for all 1 < i ≤ n:  S[A[i-1], n] < S[A[i], n].

For example: the suffix array of “banana” is [6, 4, 2, 1, 5, 3].

Here comes another problem called "Reverse Suffix Array".

Given a suffix array, you need to figure out how many lower case strings are there whose suffix array is the same as the given suffix array.

输入

First line contains a positive number T which means the number of test cases.

For each test cases, first line contains a positive number N, the second line contains N integer(s) which indicates the suffix array A.

1 ≤ T ≤ 10, 1 ≤ N ≤ 100,000

1 ≤ A[i] ≤ N (i = 1...N)

输出

For each test case, output one line contains the answer. If no qualified string exists, output 0.

样例输入

1
5
4 3 2 5 1

样例输出

98280
【题意】：已知后缀数组，求原串的可能情况数。
【分析】：java，26^3 dp，http://blog.csdn.net/skywalkert/article/details/51731556（在 cdoj 上也有一个类似
【代码】：

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.math.BigInteger;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Task2 solver = new Task2();
        int testCount = Integer.parseInt(in.next());
        for (int i = ; i <= testCount; i++)
            solver.solve(i, in, out);
        out.close();
    }

    static class Task2 {
        BigInteger C(int n, int m) {
            BigInteger ans = BigInteger.valueOf();
            for (int i = ; i <= m; i++) {
                ans = ans.multiply(BigInteger.valueOf(n - i + ));
            }
            for (int i = ; i <= m; i++) {
                ans = ans.divide(BigInteger.valueOf(i));
            }
            return ans;
        }

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.nextInt();
            int[] a = new int[n + ];
            int[] b = new int[n + ];
            for (int i = ; i <= n; i++) {
                a[i] = in.nextInt();
                b[a[i]] = i;
            }
            ArrayList<Integer> arr = new ArrayList<>();
            int now = ;
            for (int i = ; i <= n; i++) {
                if (a[i - ] != n && (a[i] == n || b[a[i - ] + ] > b[a[i] + ])) {
                    arr.add(now);
                    now = ;
                } else {
                    now++;
                }
            }
            arr.add(now);
            if (arr.size() > ) {
                out.println();
            } else {
                int sz = arr.size();
                BigInteger[][] dp = new BigInteger[sz + ][];
                for (int i = ; i <= sz; i++) {
                    for (int j = ; j <= ; j++) {
                        dp[i][j] = BigInteger.valueOf();
                    }
                }
                dp[][] = BigInteger.valueOf();
                for (int i = ; i < sz; i++) {
                    for (int j = ; j < ; j++) {
                        for (int k = ; j + k <= ; k++) {
                            dp[i + ][j + k] = dp[i + ][j + k].add(dp[i][j].multiply(C(arr.get(i) + k - , k - )));
                        }
                    }
                }
                // out.println(dp[sz][26]);
                BigInteger ans = BigInteger.valueOf();
                for (int i = ; i <= ; i++) {
                    ans = ans.add(dp[sz][i]);
                }
                out.println(ans);
            }
        }

    }

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

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), );
            tokenizer = null;
        }

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

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

    }
}

809ms