【題目描述】

Insertion sort is a simple sorting algorithm that builds the final sorted array one item at an iteration.More precisely, insertion sort iterates, consuming one input element each repetition, and growing a sorted output list. At each iteration, insertion sort removes one element from the input data, finds the location it belongs within the sorted list, and inserts it there. It repeats until no input elements remain.This type of sorting is typically done in-place, by iterating up the array, growing the sorted array behind it. At each array-position, it checks the value there against the largest value in the sorted array (which happens to be next to it, in the previous array-position checked). If larger, it leaves the element in place and moves to the next. If smaller, it finds the correct position within the sorted array, shifts all the larger values up to make a space, and inserts into that correct position.The resulting array after k iterations has the property where the first k entries are sorted. In each iteration the first remaining entry of the input is removed, and inserted into the result at the correct position, thus extending the result.Knuth is an ACM-ICPC master and provides a modified pseudocode implementation about the insertion sort for you. His modified algorithm for an array of sortable items A (1-based array) can be expressed as:He notes that a permutation of 1 to n is almost sorted if the length of its longest increasing subsequence is at least (n?1).Given the parameter k, you are asked to count the number of distinct permutations of 1 to n meeting the condition that, after his modified insertion sort, each permutation would become an almost sorted permutation.Input
The input contains several test cases, and the first line contains a positive integer T indicating the number of test cases which is up to 5000.For each test case, the only line contains three integers n,k and q indicating the length of the permutations, the parameter in his implementation and a prime number required for the output respectively, where 1≤n,k≤50 and 108≤q≤109.Output
For each test case, output a line containing "Case #x: y" (without quotes), where x is the test case number starting from 1, and y is the remainder of the number of permutations which meet the requirement divided by q.Example
Input
4
4 1 998244353
4 2 998244353
4 3 998244353
4 4 998244353
Output
Case #1: 10
Case #2: 14
Case #3: 24
Case #4: 24
Note
In the first sample case, we can discover 10 permutations which meet the condition, and they are listed as follows:[1,2,3,4];
[1,2,4,3];
[1,3,2,4];
[1,3,4,2];
[1,4,2,3];
[2,1,3,4];
[2,3,1,4];
[2,3,4,1];
[3,1,2,4];
[4,1,2,3].

【題目分析】

這是一道打表題。自己以前對這種題很沒有經驗，因為不太習慣這種思維方式，雖然清楚找出來的規律肯定是有其深層含義的，但是直接找這種規律是很困難的，而且對于競賽而言也并不需要理解公式的來源，能夠解決問題就行，當然探求問題本質的習慣很好，但是對于競賽我們很多時候要不求甚解，大膽嘗試不去求證。不管黑貓白貓，能夠抓到老鼠就是好貓，可能在思維層次上兩個有優劣，但是從解決問題的角度都是一樣的，不能因為覺得這樣沒水平或者是沒有找到問題的本質就對這種有效解決問題的方式抵觸。只能怪自己的思維不允許自己一下看出問題的關鍵而只能通過這種方式幫助解決問題。

而且快速找到規律也是一種能力，不能過分糾結于細節，這是為了找到規律而不是為了探求為什么。

【AC代碼】

打表代碼

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<climits>
#include<cctype>
#include<queue>
#include<set>using namespace std;typedef long long ll;
const int INF=0x3f3f3f3f;
const int MAXN=30;int nn,k;
int a[MAXN];
int b[MAXN];
int dp[MAXN];int deal(int n)
{for(int i=1;i<=n;i++){dp[i]=1;}int ret=0;for(int i=1;i<=n;i++){for(int j=1;j<i;j++){if(b[j]<b[i] && dp[j]+1>dp[i]) dp[i]=dp[j]+1; }if(dp[i]>ret) ret=dp[i];}return ret;
}int main()
{nn=10;for(int n=1;n<=nn;n++){printf("[%d]\t",n);for(int i=1;i<=n;i++) a[i]=i;for(int k=1;k<=n;k++){int cnt=0;do{memcpy(b,a,sizeof(a));sort(b+1,b+1+k);if(deal(n)>=n-1) cnt++;}while(next_permutation(a+1,a+n+1));printf("%d\t",cnt);}printf("\n");}return 0;
}

AC代碼

#include<stdio.h>
int main()
{long long t,n,k,q,cot=0;scanf("%lld",&t);while(cot!=t){cot++;scanf("%lld%lld%lld",&n,&k,&q);if(k>n)k=n;long long ans=0,temp=1;for(long long i=1;i<=k;i++){temp*=i;temp%=q;}ans=temp;long long tz=k;for(long long i=k+1;i<=n;i++){ans+=temp*k;ans%=q;k+=2;}printf("Case #%lld: %lld\n",cot,ans);}return 0;
}