There are n swords of different weights W_i and n heros of power P_i.

Your task is to find out how many ways the heros can carry the swords so that each hero carries exactly one sword.

Here are some rules:

(1) Every sword is carried by one hero and a hero cannot carry a sword whose weight is larger than his power.

(2) Two ways will be considered different if at least one hero carries a different sword.

The first line of the input gives the number of test cases T(1 ≤ T ≤ 50).

Each case starts with a line containing an integer n (1 ≤ n ≤ 10⁵)denoting the number of heros and swords.

The next line contains n space separated distinct integers denoting the weight of swords.

The next line contains n space separated distinct integers denoting the power for the heros.

The weights and the powers lie in the range [1, 10⁹].

For each case, output one line containing "Case #x: " followed by the number of ways those heros can carry the swords.

This number can be very big. So print the result modulo 1000 000 007.

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

Case #1: 1
Case #2: 0
Case #3: 4

KIDx: I like Java much more than C++, because I can use BigInteger in Java. :)

However, KIDx has to use C++ language to do a project...

KIDx can only use three integer types in C++:

1) short occupies 2 bytes and allows you to store numbers from-32768 to 32767

2) int occupies 4 bytes and allows you to store numbers from -2147483648 to 2147483647

3) long long occupies 8 bytes and allows you to store numbers from-9223372036854775808 to 9223372036854775807

For all the types given above the boundary values are included in the value range.

From this list, KIDx wants you to choose the smallest type that can store a positive integern.

There are multiple cases.

Each case contains a positive integer n.

It consists of at least one digit and at most 30 digits.

In addition, it doesn‘t contain any leading zeros.

For each line, print the first type from the list "short, int, long long", that can store the natural numbern.

If no one can store the number, just print "It is too big!".

102
50000

short
int

Suppose there are a polynomial which has n nonzero terms, please print the integration polynomial of the given polynomial.

The polynomial will be given in the following way, and you should print the result in the same way:

k[1] e[1] k[2] e[2] ... k[n] e[n]

where k[i] and e[i] respectively represent the coefficients and exponents of nonzero terms, and satisfiese[1] < e[2] < ... < e[n].

Note:

• Suppose that the constant term of the integration polynomial is 0.
• If one coefficient of the integration polynomial is an integer, print it directly.
• If one coefficient of the integration polynomial is not an integer, please print it by using fractiona/b which satisfies that a is coprime to b.

There are multiple cases.

For each case, the first line contains one integer n, representing the number of nonzero terms.

The second line contains 2*n integers, representing k[1], e[1], k[2], e[2], ..., k[n], e[n]。

1 ≤ n ≤ 1000

-1000 ≤ k[i] ≤ 1000, k[i] != 0, 1 ≤ i ≤ n

0 ≤ e[i] ≤ 1000, 1 ≤ i ≤ n

Print the integration polynomial in one line with the same format as the input.

Notice that no extra space is allowed at the end of each line.

3
1 0 3 2 2 4

1 1 1 3 2/5 5

f(x) = 1 + 3x² + 2x⁴

After integrating we get: ∫f(x)dx = x + x³ + (2/5)x⁵

^AC代码:

/*
* this code is made by eagle
* Problem: 1204
* Verdict: Accepted
* Submission Date: 2014-09-06 21:24:26
* Time: 16MS
* Memory: 1684KB
*/
#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <cmath>
 
using namespace std;
const int M = 1100;
const int mod = 1000000007;
int a[M],b[M];
 
int gcd(int a, int b)
{
    return b == 0 ? a : gcd(b, a % b);
}
 
int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        for(int i = 0; i < n; i++)
        {
            scanf("%d %d",a + i,b + i);
            b[i]++;
        }
        for(int i = 0; i < n; i++)
        {
            int tp = a[i] / b[i] * b[i];
            if(tp == a[i]) printf("%d %d",a[i] / b[i],b[i]);
            else
            {
                tp = gcd(abs(a[i]),abs(b[i]));
                printf("%d/%d %d",a[i] / tp,b[i] / tp, b[i]);
            }
            if(i == n - 1) puts("");
            else printf(" ");
        }
    }
    return 0;
}