2018浙江省賽(ACM) The 15th Zhejiang Provincial Collegiate Programming Contest Sponsored by TuSimple

時間 2019-11-12

標籤浙江省 acm 15th zhejiang provincial collegiate programming contest sponsored tusimple 欄目應用數學简体版

原文原文鏈接

我是鐵牌選手c++

此次比賽很是得爆炸，能夠說體驗極差，是這輩子本身最腦殘的事情之一。spring

天時，地利，人和同樣沒有，並且本身早早地就想好了甩鍋的套路。api

按理說不開K就不會這麼慘了啊，並且本身也是毒，不知道段錯誤也能夠是MLE，並且個人內存就是卡了那麼一點點，在比賽緊張的狀態下人也變傻了吧。數組

此次的題目難度是兩邊到中間一次遞增的，可是我也不懂榜怎麼會那樣app

Peak

Time Limit: 1 Second Memory Limit: 65536 KB

A sequence of $integers is called a peak, if and only if there exists exactly one integer such that, and for all, and for all .$ ide

Given an integer sequence, please tell us if it's a peak or not.優化

Input

There are multiple test cases. The first line of the input contains an integer $, indicating the number of test cases. For each test case:$ ui

The first line contains an integer $(), indicating the length of the sequence.$ this

The second line contains $integers (), indicating the integer sequence.$ spa

It's guaranteed that the sum of $in all test cases won't exceed .$

Output

For each test case output one line. If the given integer sequence is a peak, output "Yes" (without quotes), otherwise output "No" (without quotes).

Sample Input

Sample Output

Yes
No
No
No
Yes
No
No

A就是判斷前一段遞增，後一段遞減。因此你找到最大值就行了

#include <bits/stdc++.h>
using namespace std;
const int N=1e5+5;
int n,a[N];
int la()
{
    int pos=0;
    for(int i=1;i<n;i++)
        if(a[pos]<a[i])pos=i;
    if(pos==0||pos==n-1)return 0;
    for(int i=1;i<=pos;i++)
        if(a[i-1]>=a[i])return 0;
    for(int i=pos+1;i<n;i++)
        if(a[i-1]<=a[i])return 0;
    return 1;
}
int main()
{
    int T;
    cin>>T;
    while(T--)
    {
        cin>>n;
        for(int i=0;i<n;i++)cin>>a[i];
        cout<<(la()?"Yes":"No")<<"\n";
    }
    return 0;
}

King of Karaoke

Time Limit: 1 Second Memory Limit: 65536 KB

It's Karaoke time! DreamGrid is performing the song Powder Snow in the game King of Karaoke. The song performed by DreamGrid can be considered as an integer sequence $, and the standard version of the song can be considered as another integer sequence . The score is the number of integers satisfying and .$

As a good tuner, DreamGrid can choose an integer $(can be positive, 0, or negative) as his tune and add to every element in . Can you help him maximize his score by choosing a proper tune?$

Input

There are multiple test cases. The first line of the input contains an integer $(about 100), indicating the number of test cases. For each test case:$

The first line contains one integer $(), indicating the length of the sequences and .$

The second line contains $integers (), indicating the song performed by DreamGrid.$

The third line contains $integers (), indicating the standard version of the song.$

It's guaranteed that at most 5 test cases have $.$

Output

For each test case output one line containing one integer, indicating the maximum possible score.

Sample Input

2
4
1 2 3 4
2 3 4 6
5
-5 -4 -3 -2 -1
5 4 3 2 1

Sample Output

3
1

Hint

For the first sample test case, DreamGrid can choose $and changes to .$

For the second sample test case, no matter which $DreamGrid chooses, he can only get at most 1 match.$

和上次的題目同樣，直接作差就行了

#include <bits/stdc++.h>
using namespace std;
const int N=1e5+5;
int a[N];
unordered_map<int,int>M;
int main()
{
    int T;
    cin>>T;
    while(T--)
    {
        M.clear();
        int n,ma=0;
        cin>>n;
        for(int i=0;i<n;i++)cin>>a[i];
        for(int i=0,x;i<n;i++)
            cin>>x,M[a[i]-x]++;
        for(auto X:M)ma=max(ma,X.second);
        cout<<ma<<"\n";
    }
    return 0;
}

Now Loading!!!

Time Limit: 1 Second Memory Limit: 131072 KB

DreamGrid has $integers . DreamGrid also has queries, and each time he would like to know the value of$

for a given number

, where, .

Input

There are multiple test cases. The first line of input is an integer $indicating the number of test cases. For each test case:$

The first line contains two integers $and () -- the number of integers and the number of queries.$

The second line contains $integers ().$

The third line contains $integers ().$

It is guaranteed that neither the sum of all $nor the sum of all exceeds .$

Output

For each test case, output an integer $, where is the answer for the -th query.$

Sample Input

2
3 2
100 1000 10000
100 10
4 5
2323 223 12312 3
1232 324 2 3 5

Sample Output

11366
45619

有一個向下取整還有向上取整，因此去枚舉分母作前綴和優化，卡MLE是真的騷

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=5e5+5,MD=1e9;
ll sum[32][N];
int main()
{
    int T;
    cin>>T;
    while(T--)
    {
        int n,m;
        cin>>n>>m;
        for(int i=1;i<=n;i++)
            cin>>sum[0][i];
        sort(sum[0]+1,sum[0]+n+1);
        for(int i=1;i<32;i++)
            for(int j=1;j<=n;j++)
            sum[i][j]=sum[0][j]/i+sum[i][j-1];
        ll ans=0;
        for(int i=0,p;i<m;i++)
        {
            cin>>p;
            ll ans1=1,ans2=0;
            for(int j=1;;j++)
            {
                int pos1=lower_bound(sum[0]+1,sum[0]+1+n,ans1+1)-sum[0],pos2=upper_bound(sum[0]+1,sum[0]+1+n,ans1*p)-sum[0]-1;
                if(pos1==n+1)break;
                if(pos1<=pos2)ans2=(ans2+sum[j][pos2]-sum[j][pos1-1])%MD;
                ans1=ans1*p;
            }
            ans=(ans+ans2*(i+1))%MD;
        }
        cout<<ans<<"\n";
    }
    return 0;
}

Magic Points

Time Limit: 1 Second Memory Limit: 65536 KB Special Judge

Given an integer $, we say a point on a 2D plane is a magic point, if and only if both and are integers, and exactly one of the following conditions is satisfied:$

$and;$
$and;$
$and;$
$and .$

It's easy to discover that there are $magic points in total. These magic points are numbered from to in counter-clockwise order starting from .$

DreamGrid can create $magic lines from these magic points. Each magic line passes through exactly two magic points but cannot be parallel to the line or (that is to say, the coordinate axes).$

The intersections of the magic lines are called dream points, and for some reason, DreamGrid would like to make as many dream points as possible. Can you tell him how to create these magic lines?

Input

There are multiple test cases. The first line of input contains an integer $(about 100), indicating the number of test cases. For each test case, there is only one integer ().$

Output

For each case output $integers in one line separated by one space, indicating that in your answer, point and point is connected by a line for all .$

If there are multiple answers, you can print any of them.

Sample Input

Sample Output

0 2 1 3
1 4 2 5 3 6
0 6 1 9 3 8 4 10

Hint

The sample test cases are shown as follow:

4n-4個點讓你構造直線並且相交點最多，先考慮讓他們同方向的，也就是斜率相同的，可是不必定能夠構造出來

可是首先要明確的就是按照邊走，i連上n+i

最後一條線剛開始直接把對角線的點相連。可是這樣有可能會交於同一點，因此是要找最後一點相連還有他的斜率

n==5也是特殊的，太菜了，哎。不過比賽時這個題目仍是能夠開的

#include <bits/stdc++.h>
using namespace std;
const int N=1e5+5;
int ans[N];
int main()
{
    int T;
    cin>>T;
    while(T--)
    {
        int n;
        cin>>n;
        if(n==2)cout<<"0 2 1 3\n";
        else if(n==3)cout<<"1 4 2 5 3 6\n";
        else if(n==4)cout<<"0 6 1 9 3 8 4 10\n";
        else if(n==5)cout<<"0 5 1 6 2 7 3 8 11 13\n";
        else
        {
            for(int i=0;i<n-1;i++)cout<<i<<" "<<n+i<<" ";
            cout<<n*4-5<<" "<<n+n<<"\n";
        }
    }
    return 0;
}

CONTINUE...?

Time Limit: 1 Second Memory Limit: 65536 KB Special Judge

DreamGrid has $classmates numbered from to . Some of them are boys and the others are girls. Each classmate has some gems, and more specifically, the -th classmate has gems.$

DreamGrid would like to divide the classmates into four groups $,, and such that:$

Each classmate belongs to exactly one group.
Both $and consist only of girls. Both and consist only of boys.$
The total number of gems in $and is equal to the total number of gems in and .$

Your task is to help DreamGrid group his classmates so that the above conditions are satisfied. Note that you are allowed to leave some groups empty.

Input

There are multiple test cases. The first line of input is an integer $indicating the number of test cases. For each test case:$

The first line contains an integer $() -- the number of classmates.$

The second line contains a string $() consisting of 0 and 1. Let be the -th character in the string . If, the -th classmate is a boy; If, the -th classmate is a girl.$

It is guaranteed that the sum of all $does not exceed .$

Output

For each test case, output a string consists only of {1, 2, 3, 4}. The $-th character in the string denotes the group which the -th classmate belongs to. If there are multiple valid answers, you can print any of them; If there is no valid answer, output "-1" (without quotes) instead.$

Sample Input

Sample Output

這個就是湊數的題目，能夠湊出來的，貪心選擇或者找其中的一段區間都是能夠的

#include <bits/stdc++.h>
using namespace std;
const int N=1e5+5;
int ans[N];
int main()
{
    int T;
    cin>>T;
    while(T--)
    {
        int n;
        cin>>n;
        string s;
        cin>>s;
        long long sum=n*1LL*(n+1)/2;
        if(sum%2)cout<<"-1\n";
        else
        {
            sum/=2;
            for(int i=n-1;i>=0;i--)
            {
                if(sum>i)
                    sum-=(i+1),ans[i]=(s[i]=='1')?3:1;
                else ans[i]=(s[i]=='1')?4:2;
            }
            for(int i=0;i<n;i++)cout<<ans[i];
            cout<<"\n";
        }
    }
    return 0;
}

Doki Doki Literature Club

Time Limit: 1 Second Memory Limit: 65536 KB

Doki Doki Literature Club! is a visual novel developed by Team Salvato. The protagonist is invited by his childhood friend, Sayori, to join their high school's literature club. The protagonist then meets the other members of the club: Natsuki, Yuri, and the club president Monika. The protagonist starts to participate in the club's activities such as writing and sharing poetry, and grows close to the four girls. What a lovely story!

A very important feature of the game is its poetry writing mechanism. The player is given a list of various words to select from that will make up his poem. Each girl in the Literature Club has different word preferences, and will be very happy if the player's poem is full of her favorite words.

The poem writing mini-game (from wikipedia)

BaoBao is a big fan of the game and likes Sayori the most, so he decides to write a poem to please Sayori. A poem of $words is nothing more than a sequence of strings, and the happiness of Sayori after reading the poem is calculated by the formula$

where

is the happiness and is Sayori's preference to the word .

Given a list of $words and Sayori's preference to each word, please help BaoBao select words from the list and finish the poem with these words to maximize the happiness of Sayori.$

Please note that each word can be used at most once!

Input

There are multiple test cases. The first line of input contains an integer $(about 100), indicating the number of test cases. For each test case:$

The first line contains two integers $and (), indicating the number of words and the length of the poem.$

For the following $lines, the -th line contains a string consisting of lowercased English letters () and an integer (), indicating the -th word and Sayori's preference to this word. It's guaranteed that for all .$

Output

For each test case output one line containing an integer $and strings separated by one space, indicating the maximum possible happiness and the corresponding poem. If there are multiple poems which can achieve the maximum happiness, print the lexicographically smallest one.$

Please, DO NOT output extra spaces at the end of each line, or your answer may be considered incorrect!

A sequence of $strings is lexicographically smaller than another sequence of strings, if there exists a () such that for all and is lexicographically smaller than .$

A string $is lexicographically smaller than another string, if there exists a () such that for all and, or for all and .$

Sample Input

4
10 8
hello 0
world 0
behind 0
far 1
be 2
spring 10
can 15
comes 20
winter 25
if 200
5 5
collegiate 0
programming -5
zhejiang 10
provincial 5
contest -45
3 2
bcda 1
bcd 1
bbbbb 1
3 2
a 1
aa 1
aaa 1

Sample Output

2018 if winter comes can spring be far behind
15 zhejiang provincial collegiate programming contest
3 bbbbb bcd
3 a aa

僅僅是個sort，讀懂題意就能夠作了

#include <bits/stdc++.h>
using namespace std;
const int N=1e5+5;
struct T
{
    string s;
    int va;
}a[105];
int cmp(T a,T b)
{
    return a.va>b.va||a.va==b.va&&a.s<b.s;
}
int main()
{
    int T;
    cin>>T;
    while(T--)
    {
        int n,m;
        cin>>n>>m;
        for(int i=0;i<n;i++)cin>>a[i].s>>a[i].va;
        sort(a,a+n,cmp);
        long long sum=0;
        for(int i=0;i<m;i++)
            sum+=(m-i)*1LL*a[i].va;
        cout<<sum;
        for(int i=0;i<m;i++)cout<<" "<<a[i].s;
        cout<<"\n";
    }
    return 0;
}

Lucky 7

Time Limit: 1 Second Memory Limit: 65536 KB

BaoBao has just found a positive integer sequence $of length from his left pocket and another positive integer from his right pocket. As number 7 is BaoBao's favorite number, he considers a positive integer lucky if is divisible by 7. He now wants to select an integer from the sequence such that is lucky. Please tell him if it is possible.$

Input

There are multiple test cases. The first line of the input is an integer $(about 100), indicating the number of test cases. For each test case:$

The first line contains two integers $and (), indicating the length of the sequence and the positive integer in BaoBao's right pocket.$

The second line contains $positive integers (), indicating the sequence.$

Output

For each test case output one line. If there exists an integer $such that and is lucky, output "Yes" (without quotes), otherwise output "No" (without quotes).$

Sample Input

Sample Output

No
Yes
Yes
Yes

Hint

For the first sample test case, as 4 + 7 = 11, 5 + 7 = 12 and 6 + 7 = 13 are all not divisible by 7, the answer is "No".

For the second sample test case, BaoBao can select a 7 from the sequence to get 7 + 7 = 14. As 14 is divisible by 7, the answer is "Yes".

For the third sample test case, BaoBao can select a 5 from the sequence to get 5 + 2 = 7. As 7 is divisible by 7, the answer is "Yes".

For the fourth sample test case, BaoBao can select a 100 from the sequence to get 100 + 26 = 126. As 126 is divisible by 7, the answer is "Yes".

加上一個數是否是7的倍數，直接作

#include <bits/stdc++.h>
using namespace std;
int main()
{
    int T;
    cin>>T;
    while(T--)
    {
        int n,b;
        cin>>n>>b;
        int f=0;
        for(int i=0,x;i<n;i++)
        {
            cin>>x;
            if((x+b)%7==0)f=1;
        }
        cout<<(f?"Yes":"No")<<"\n";
    }
    return 0;
}

Mahjong Sorting

Time Limit: 1 Second Memory Limit: 65536 KB

DreamGrid has just found a set of Mahjong with $suited tiles and a White Dragon tile in his pocket. Each suited tile has a suit (Character, Bamboo or Dot) and a rank (ranging from 1 to), and there is exactly one tile of each rank and suit combination.$

Character tiles whose rank ranges from 1 to 9

Bamboo tiles whose rank ranges from 1 to 9

Dot tiles whose rank ranges from 1 to 9

White Dragon tile

As DreamGrid is bored, he decides to play with these tiles. He first selects one of the $suited tiles as the "lucky tile", then he picks tiles from the set of tiles and sorts these tiles with the following rules:$

The "lucky tile", if contained in the $tiles, must be placed in the leftmost position.$
For two tiles $and such that neither of them is the "lucky tile", if$
- $is a Character tile and is a Bamboo tile, or$
- $is a Character tile and is a Dot tile, or$
- $is a Bamboo tile and is a Dot tile, or$
- $and have the same suit and the rank of is smaller than the rank of,$
then $must be placed to the left of .$

White Dragon tile is a special tile. If it's contained in the $tiles, it's considered as the original (not-lucky) version of the lucky tile during the sorting. For example, consider the following sorted tiles, where "3 Character" is selected as the lucky tile. White Dragon tile, in this case, is considered to be the original not-lucky version of "3 Character" and should be placed between "2 Character" and "4 Character".$

As DreamGrid is quite forgetful, he immediately forgets what the lucky tile is after the sorting! Given $sorted tiles, please tell DreamGrid the number of possible lucky tiles.$

Input

There are multiple test cases. The first line of the input contains an integer $, indicating the number of test cases. For each test case:$

The first line contains two integers $and (,), indicating the number of sorted tiles and the maximum rank of suited tiles.$

For the next $lines, the -th line describes the -th sorted tile counting from left to right. The line begins with a capital letter (), indicating the suit of the -th tile:$

If $, then an integer () follows, indicating that it's a Character tile with rank;$
If $, then an integer () follows, indicating that it's a Bamboo tile with rank;$
If $, then an integer () follows, indicating that it's a Dot tile with rank;$
If $, then it's a White Drangon tile.$

It's guaranteed that there exists at least one possible lucky tile, and the sum of $in all test cases doesn't exceed .$

Output

For each test case output one line containing one integer, indicating the number of possible lucky tiles.

Sample Input

4
3 9
C 2
W
C 4
6 9
C 2
C 7
W
B 3
B 4
D 2
3 100
C 2
W
C 9
3 9
C 1
B 2
D 3

Sample Output

Hint

For the first sample, "2 Character" and "3 Character" are possible lucky tiles.

For the second sample, "8 Character", "9 Character", "1 Bamboo" and "2 Bamboo" are possible lucky tiles.

本身菜作不出來，要把全部的狀況都分析到，我太菜了，這個題不想再作了

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+5;
int a[N],n,m;
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int f=0,ans;
        scanf("%d%d",&n,&m);
        a[n+1]=3*m+1;
        for(int i=1; i<=n; i++)
        {
            getchar();
            char c=getchar();
            if(c!='W')
            {
                scanf("%d",&a[i]);
                if(c=='B')a[i]+=m;
                if(c=='D')a[i]+=2*m;
            }
            else f=i;
        }
        if(n==1)ans=3*m;
        else
        {
            if(f==0)
                if(a[1]>a[2])ans=1;
                else ans=3*m-n+1;
            else
            {
                if(f==1)ans=a[2]-1;
                else
                {
                    if(a[1]>a[2]&&f!=2)ans=1;
                    else ans=a[f+1]-a[f-1]-(f!=2);
                }
            }
        }
        cout<<ans<<"\n";
    }
    return 0;
}

Sequence Swapping

Time Limit: 1 Second Memory Limit: 65536 KB

BaoBao has just found a strange sequence {< $, >, <, >,, <, >} of length in his pocket. As you can see, each element <, > in the sequence is an ordered pair, where the first element in the pair is the left parenthesis '(' or the right parenthesis ')', and the second element in the pair is an integer.$

As BaoBao is bored, he decides to play with the sequence. At the beginning, BaoBao's score is set to 0. Each time BaoBao can select an integer $, swap the -th element and the -th element in the sequence, and increase his score by, if and only if,'(' and')'.$

BaoBao is allowed to perform the swapping any number of times (including zero times). What's the maximum possible score BaoBao can get?

Input

There are multiple test cases. The first line of the input contains an integer $, indicating the number of test cases. For each test case:$

The first line contains an integer $(), indicating the length of the sequence.$

The second line contains a string $() consisting of '(' and ')'. The -th character in the string indicates, of which the meaning is described above.$

The third line contains $integers (). Their meanings are described above.$

It's guaranteed that the sum of $of all test cases will not exceed .$

Output

For each test case output one line containing one integer, indicating the maximum possible score BaoBao can get.

Sample Input

4
6
)())()
1 3 5 -1 3 2
6
)())()
1 3 5 -100 3 2
3
())
1 -1 -1
3
())
-1 -1 -1

Sample Output

Hint

For the first sample test case, the optimal strategy is to select $in order.$

For the second sample test case, the optimal strategy is to select $in order.$

這個dp就是去找(，找到它最右能夠到達的位置

而後你能夠找一個這個)前一個）,保證他也最優

#include<bits/stdc++.h>
using namespace std;
const int N=1005;
typedef long long ll;
char s[N];
ll v[N],dp[N][N],sum[N],F[N],nxt[N];
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int n,f=0,tot=1;
        scanf("%d%s",&n,s+1);
        for(int i=1; i<=n; i++)scanf("%lld",&v[i]);
        for(int i=n; i>0; i--)if(s[i]=='(')F[tot++]=i;
        for(int i=1; i<=n; i++) sum[i]=sum[i-1]+(s[i]==')'?v[i]:0);
        memset(nxt,0,sizeof(nxt));
        for(int i=1; i<=n; i++)
            if(s[i]==')')
            {
                if(f) nxt[f]=i;
                f=i;
            }
        for(int i=1; i<=n; i++) dp[i][0]=-(1LL<<60);
        ll ans=0;
        for(int i=1; i<tot; i++)
        {
            for(int j=F[i]+1; j<=n; j++)
                if(s[j]==')') dp[i][j]=v[F[i]]*(sum[j]-sum[F[i]])+dp[i-1][j];
            for(int j=n; j>=F[i]; j--)
                if(s[j]==')') dp[i][j]=max(dp[i][nxt[j]],dp[i][j]);
            for(int j=F[i]-1; j>=1; j--)
                if(s[j]==')') dp[i][j]=max(dp[i-1][j],dp[i][nxt[j]]);
            for(int j=1; j<=n; j++) if(s[j]==')')ans=max(ans,dp[i][j]);
        }
        printf("%lld\n",ans);
    }
    return 0;
}

使用滾動數組優化

#include<bits/stdc++.h>
using namespace std;
const int N=1005;
typedef long long ll;
char s[N];
ll v[N],dp[2][N],sum[N],F[N],nxt[N];
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int n,f=0,tot=1,cur=0;
        scanf("%d%s",&n,s+1);
        for(int i=1; i<=n; i++)scanf("%lld",&v[i]);
        for(int i=n; i>0; i--)if(s[i]=='(')F[tot++]=i;
        for(int i=1; i<=n; i++) sum[i]=sum[i-1]+(s[i]==')'?v[i]:0);
        memset(nxt,0,sizeof(nxt));
        for(int i=1; i<=n; i++)
            if(s[i]==')')
            {
                if(f) nxt[f]=i;
                f=i;
            }
        for(int i=1; i<=n; i++) dp[1][i]=dp[0][i]=0;
        dp[0][0]=dp[1][0]=-(1LL<<60);
        ll ans=0;
        for(int i=1; i<tot; i++)
        {
            for(int j=F[i]+1; j<=n; j++)
                if(s[j]==')') dp[cur][j]=v[F[i]]*(sum[j]-sum[F[i]])+dp[cur^1][j];
            for(int j=n; j>=F[i]; j--)
                if(s[j]==')') dp[cur][j]=max(dp[cur][nxt[j]],dp[cur][j]);
            for(int j=F[i]-1; j>=1; j--)
                if(s[j]==')') dp[cur][j]=max(dp[cur^1][j],dp[cur][nxt[j]]);
            for(int j=1; j<=n; j++) if(s[j]==')')ans=max(ans,dp[cur][j]);
            cur^=1;
        }
        printf("%lld\n",ans);
    }
    return 0;

Magic 12 Months

Time Limit: 1 Second Memory Limit: 65536 KB

It's New Year's Eve, and it's also the best time of the year to play the card game Magic 12 Months to pray for good luck of the coming year. BaoBao has just found a deck of standard 52 playing cards (without Jokers) in his pocket and decides to play the game. The rules are as follows:

Setup
1. Remove the four 'K's from the 52 cards.
2. Shuffle the remaining 48 cards and divide them face down into 12 piles (4 cards per pile) with equal probability.
Gameplay
1. Let $.$
2. Flip the card on the top of the $-th pile, check its rank, and discard the card.$
3. If $is a number, let; If, let; If, let; If, let .$
4. If the $-th pile is empty, the game ends; Otherwise go back to step 2.2.$

When the game ends, having all the 4 cards of rank $flipped and discarded indicates that the -th month in the coming year is a lucky month.$

BaoBao is in the middle of the game and has discarded $cards. He wants to know the probability that the -th month of the coming year is a lucky month for all when the game ends. Given these cards, please help him calculate the answer.$

Input

There are multiple test cases. The first line of input contains an integer $(about 100) -- the number of test cases. For each test case:$

The first and only line contains an integer $() -- the number of flipped cards, followed by the rank of the cards () separated by a space in the order they are flipped. It's guaranteed that the input describes a valid and possible situation of the game.$

Output

For each test case output one line containing 12 numbers separated by a space, where the $-th number indicates the probability that the -th month of the coming year is a lucky month.$

You should output a probability in its simplest fraction form $where and are coprime. Specifically, if the probability equals 0, you should output 0; If the probability equals 1, you should output 1.$

Please, DO NOT output extra spaces at the end of each line, or your answer may be considered incorrect!

Sample Input

3
30 9 Q 10 J Q 10 J 10 J J 8 5 7 6 5 7 6 7 6 6 3 A 2 4 A 2 4 2 4 4
0
7 2 A 3 A 4 A A

Sample Output

1 2/3 2/5 1 1/2 1 2/3 2/5 2/5 2/3 1 1/2
1 1/2 1/2 1/2 1/2 1/2 1/2 1/2 1/2 1/2 1/2 1/2
1 0 0 0 0 0 0 0 0 0 0 0

想到了和第一堆有關，可是還沒推出來

#include<bits/stdc++.h>
using namespace std;
#define dbg(x) cout<<#x<<" = "<< (x)<< endl
typedef long long ll;
ll C(int n,int m)
{
    if(m>n)return 0;
    ll ans=1;
    for(int i=n-m+1; i<=n; i++)ans*=i;
    for(int i=2; i<=m; i++)ans/=i;
    return ans;
}
int a[15];
int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        for(int i=1; i<=12; i++)a[i]=4;
        int n;
        cin>>n;
        string s;
        for(int i=0,x; i<n; i++)
        {
            cin>>s;
            if(s=="10")x=10;
            else if(s=="A")x=1;
            else if(s=="J")x=11;
            else if(s=="Q")x=12;
            else x=s[0]-48;
            a[x]--;
        }
        cout<<1;
        for(int i=2; i<=12; i++)
        {
            //dbg(a[i]);
            if(!a[i])cout<<" 1";
            else if(!a[1])cout<<" 0";
            else
            {
                int m=48-n;
                ll B=C(m,a[1])*C(m-a[1],a[i]),A=0;
                for(int j=a[1]; j<=m; j++)A+=C(j-1,a[1]-1)*C(j-a[1],a[i]);
                ll d=__gcd(A,B);
                if(!A)cout<<" 0";
                else if(A==B)cout<<" 1";
                else cout<<" "<<A/d<<"/"<<B/d;
            }
        }
        cout<<"\n";
    }
    return 0;
}

相關標籤/搜索