HDU 6038

Function

Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others)
Total Submission(s): 1034    Accepted Submission(s): 464

Problem Description

You are given a permutation a from 0 to n−1 and a permutation b from 0 to m−1.

Define that the domain of function f is the set of integers from 0 to n−1, and the range of it is the set of integers from 0 to m−1.

Please calculate the quantity of different functions f satisfying that f(i)=bf(ai) for each i from 0 to n−1.

Two functions are different if and only if there exists at least one integer from 0 to n−1 mapped into different integers in these two functions.

The answer may be too large, so please output it in modulo 109+7.

Input

The input contains multiple test cases.

For each case:

The first line contains two numbers n, m. (1≤n≤100000,1≤m≤100000)

The second line contains n numbers, ranged from 0 to n−1, the i-th number of which represents ai−1.

The third line contains m numbers, ranged from 0 to m−1, the i-th number of which represents bi−1.

It is guaranteed that ∑n≤106, ∑m≤106.

Output

For each test case, output "Case #x: y" in one line (without quotes), where x indicates the case number starting from 1 and y denotes the answer of corresponding case.

Sample Input

3 2

1 0 2

0 1

3 4

2 0 1

0 2 3 1

Sample Output

Case #1: 4

Case #2: 4

Source

2017 Multi-University Training Contest - Team 1

题意:

长度为n的数列a[0...n-1]和长度为m的数列b[0...m-1],求有多少个这样的函数f使得 f(i)=bf(ai),i属于[0,n-1];

代码:

//可以看出f在定义域[0,n-1]中是循环的,f的每个循环节中只要有一个f的值确定了那么其他的f的值也就确定了(
//因为每相邻的两个f都相关),所以先找出a数列的所有的循环节然后在b中找f可以对应的值(同样是循环节),只有b
//的某个循环节是a的某个循环节的因子时这两个循环节才能匹配,统计能匹配的个数,结果相乘。
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
typedef long long ll;
const int maxn=100009;
const ll mod=1e9+7;
int n,m,a[maxn],b[maxn];
int num1[maxn],num2[maxn];//num1[i]表示a数列第i个循环节的大小,num2[i]表示b数列长度为i的循环节的个数
int main()
{
    int cas=0;
    while(scanf("%d%d",&n,&m)==2){
        for(int i=0;i<n;i++) scanf("%d",&a[i]);
        for(int i=0;i<m;i++) scanf("%d",&b[i]);
        memset(num2,0,sizeof(num2));
        memset(num1,0,sizeof(num1));

        int tot=0;
        for(int i=0;i<n;i++){
            if(a[i]==-1) continue;
            int ii=i;
            tot++;
            while(a[ii]!=-1){
                num1[tot]++;
                int t=ii;
                ii=a[ii];
                a[t]=-1;
            }
        }
        for(int i=0;i<m;i++){
            if(b[i]==-1) continue;
            int ii=i,len=0;
            while(b[ii]!=-1){
                len++;
                int t=ii;
                ii=b[ii];
                b[t]=-1;
            }
            num2[len]++;
        }
        ll sum=1;
        for(int i=1;i<=tot;i++){
            ll cnt=0;
            for(int j=1;j<=num1[i];j++){
                if(num1[i]%j==0){
                    cnt+=num2[j]*j;
                    cnt%=mod;
                }
            }
            sum*=cnt;
            sum%=mod;
        }
        printf("Case #%d: %lld\n",++cas,sum);
    }
    return 0;
}
时间: 2024-11-06 12:26:09

HDU 6038的相关文章

HDU 6038 Function(思维+寻找循环节)

http://acm.hdu.edu.cn/showproblem.php?pid=6038 题意:给出两个序列,一个是0~n-1的排列a,另一个是0~m-1的排列b,现在求满足的f的个数. 思路: 先看一下样例吧: 对于这组数来说,假如我们先指定了f(0)对应的在b中的值,那么根据第2个式子,就可以得出f(1),根据f(1)就又可以得出f(2),最后根据f(2)就可以检验f(0)的值是否正确. 这也就是说,对于a中的一个循环节,只要确定了其中一个数所映射的值,那么其它数就都被相应的确定了. 所

HDU 6034 6038

6034:给每个字母26进制的贪心.例如一个字母 c = 7*26^89 + 6*26^50.... 这个字符串有10^5长度.普通的大整数会超时,这里要稀疏这个大数一个pair<int,int> 型即可 (89,7),计算好每一个字母的贡献值,排序. 前导0的处理是,如果要用到0了,说明所有字母都出现了,那么从后往前,如果一个数他贡献值最小而且可以为0,那他就是0: 6038:

HDU 6203 ping ping ping [LCA,贪心,DFS序,BIT(树状数组)]

题目链接:[http://acm.hdu.edu.cn/showproblem.php?pid=6203] 题意 :给出一棵树,如果(a,b)路径上有坏点,那么(a,b)之间不联通,给出一些不联通的点对,然后判断最少有多少个坏点. 题解 :求每个点对的LCA,然后根据LCA的深度排序.从LCA最深的点对开始,如果a或者b点已经有点被标记了,那么continue,否者标记(a,b)LCA的子树每个顶点加1. #include<Bits/stdc++.h> using namespace std;

HDU 5542 The Battle of Chibi dp+树状数组

题目:http://acm.hdu.edu.cn/showproblem.php?pid=5542 题意:给你n个数,求其中上升子序列长度为m的个数 可以考虑用dp[i][j]表示以a[i]结尾的长度为j的上升子序列有多少 裸的dp是o(n2m) 所以需要优化 我们可以发现dp的第3维是找比它小的数,那么就可以用树状数组来找 这样就可以降低复杂度 #include<iostream> #include<cstdio> #include<cstring> #include

hdu 1207 汉诺塔II (DP+递推)

汉诺塔II Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)Total Submission(s): 4529    Accepted Submission(s): 2231 Problem Description 经典的汉诺塔问题经常作为一个递归的经典例题存在.可能有人并不知道汉诺塔问题的典故.汉诺塔来源于印度传说的一个故事,上帝创造世界时作了三根金刚石柱子,在一根柱子上从下往

[hdu 2102]bfs+注意INF

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=2102 感觉这个题非常水,结果一直WA,最后发现居然是0x3f3f3f3f不够大导致的--把INF改成INF+INF就过了. #include<bits/stdc++.h> using namespace std; bool vis[2][15][15]; char s[2][15][15]; const int INF=0x3f3f3f3f; const int fx[]={0,0,1,-1};

HDU 3555 Bomb (数位DP)

数位dp,主要用来解决统计满足某类特殊关系或有某些特点的区间内的数的个数,它是按位来进行计数统计的,可以保存子状态,速度较快.数位dp做多了后,套路基本上都差不多,关键把要保存的状态给抽象出来,保存下来. 简介: 顾名思义,所谓的数位DP就是按照数字的个,十,百,千--位数进行的DP.数位DP的题目有着非常明显的性质: 询问[l,r]的区间内,有多少的数字满足某个性质 做法根据前缀和的思想,求出[0,l-1]和[0,r]中满足性质的数的个数,然后相减即可. 算法核心: 关于数位DP,貌似写法还是

HDU 5917 Instability ramsey定理

http://acm.hdu.edu.cn/showproblem.php?pid=5917 即世界上任意6个人中,总有3个人相互认识,或互相皆不认识. 所以子集 >= 6的一定是合法的. 然后总的子集数目是2^n,减去不合法的,暴力枚举即可. 选了1个肯定不合法,2个也是,3个的话C(n, 3)枚举判断,C(n, 4), C(n, 5) #include <bits/stdc++.h> #define IOS ios::sync_with_stdio(false) using name

hdu 6166 Senior Pan

地址:http://acm.split.hdu.edu.cn/showproblem.php?pid=6166 题目: Senior Pan Time Limit: 12000/6000 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others)Total Submission(s): 245    Accepted Submission(s): 71 Problem Description Senior Pan fails i