2017 Multi-University Training Contest - 1

hdu 6033

 pragma comment(linker, "/STACK:102400000,102400000")
 #include <cstdio>
 #include <iostream>
 #include <cstdlib>
 #include <cstring>
 #include <algorithm>
 #include <cmath>
 #include <cctype>
 #include <map>
 #include <set>
 #include <queue>
 #include <bitset>
 #include <string>
 #include <complex>
 #define ll __int64
 #define mod 1000000007
 using namespace std;
 int  n;
 int main()
 {
     int t=;
     while(scanf("%d",&n)!=EOF){
     printf("Case #%d: %d\n",++t,(int)(n*(log()/log())));
     }
     return ;
 }

hdu 6034

 #pragma comment(linker, "/STACK:102400000,102400000")
 #include <cstdio>
 #include <iostream>
 #include <cstdlib>
 #include <cstring>
 #include <algorithm>
 #include <cmath>
 #include <cctype>
 #include <map>
 #include <set>
 #include <queue>
 #include <bitset>
 #include <string>
 #include <complex>
 #define ll long long
 #define mod 1000000007
 using namespace std;
 int n;
 char a[];
 map<char,int>mp;
 int num[][];
 int ans[];
 struct node
 {
     char what;
     int maxn;
 } N[];
 bool cmp(struct node aa,struct node bb)
 {
     if(aa.maxn>bb.maxn)
         return true;
     else
     {
         if(aa.maxn==bb.maxn)
         {
             for(int j=aa.maxn-; j>=; j--)
             {
                 if(num[aa.what-'a'][j]!=num[bb.what-'a'][j])
                     return num[aa.what-'a'][j]>num[bb.what-'a'][j];
             }
         }
     }
     return false;
 }
 int main()
 {
     int s=;
     while(scanf("%d",&n)!=EOF)
     {
         mp.clear();
         for(int i=; i<=; i++)
         {
             memset(num[i],,sizeof(num[i]));
             N[i].what=i+'a';
             N[i].maxn=;
             ans[i]=-;
         }
         for(int i=; i<=n; i++)
         {
             scanf("%s",a);
             int lena=strlen(a);
             if(lena>)
                 mp[a[]]=;
             for(int j=; j<lena; j++)
             {
                 num[a[j]-'a'][lena--j]+=;
                 N[a[j]-'a'].maxn=max(N[a[j]-'a'].maxn,lena--j+);
             }
         }
         for(int i=; i<=; i++)
         {
             ll be=;
             for(int j=; j<N[i].maxn; j++)
             {
                 ll ok=(be+num[i][j])%;
                 be=(be+num[i][j])/;
                 num[i][j]=ok;
             }
             int jishu=N[i].maxn;
             while(be>)
             {
                 num[i][jishu]=be%;
                 be/=;
                 jishu++;
             }
             N[i].maxn=jishu;
         }

         sort(N,N+,cmp);
         for(int i=; i>=; i--)
         {
             if(mp[N[i].what]==)
             {
                 ans[i]=;
                 break;
             }
         }
         int jishu=;
         for(int i=; i<=; i++)
         {
             if(ans[i]==-)
             {
                 ans[i]=jishu;
                 jishu--;
             }
         }
         ll re=;
         for(int i=; i<=; i++)
         {
             if(ans[i]!=)
             {
                 ll gg=;
                 for(int j=; j<N[i].maxn; j++)
                 {
                     re=(re+gg*(num[N[i].what-'a'][j]*ans[i])%mod)%mod;
                     gg*=;
                     gg%=mod;
                 }
             }

         }
         cout<<"Case #"<<++s<<": "<<re<<endl;
     }
     return ;
 }

hdu 6035

 #pragma comment(linker, "/STACK:102400000,102400000")
 #include <cstdio>
 #include <iostream>
 #include <cstdlib>
 #include <cstring>
 #include <algorithm>
 #include <cmath>
 #include <cctype>
 #include <map>
 #include <set>
 #include <queue>
 #include <bitset>
 #include <string>
 #include <complex>
 #define ll long long
 #define mod 1000000007
 using namespace std;
 ll n;
 ll pre[];
 ll used[];
 ll siz[];
 ll sum[];
 ll col[];
 ll gg[];
 struct node
 {
     ll to;;
     ll pre;
 } N[];
 ll nedge=;
 ll ans=;
 void init()
 {
     for(int i=; i<=n; i++){
         pre[i]=;
         used[i]=;
         gg[i]=;
         sum[i]=;
         siz[i]=;
         col[i]=;
     }
     nedge=;
 }
 void add(ll st,ll ed)
 {
     nedge++;
     N[nedge].to=ed;
     N[nedge].pre=pre[st];
     pre[st]=nedge;
 }
 void dfs(ll root)
 {
     used[root]=;
     siz[root]=;
     ll be=sum[col[root]];
     ll ad=;
     for(int i=pre[root]; i; i=N[i].pre)
     {
         if(used[N[i].to]==)
         {
             dfs(N[i].to);
             siz[root]+=siz[N[i].to];
             ll sonu=sum[col[root]]-be;
             ll tmp=siz[N[i].to]-sonu;
             ad+=sonu;
             ans=ans-tmp*(tmp-)/;
             be=sum[col[root]];
         }

     }
      sum[col[root]]+=(siz[root]-ad);
 }
 int main()
 {
     //freopen("input.txt","r",stdin);
     //freopen("output.txt","w",stdout);
     int t=;
     while(scanf("%lld",&n)!=EOF)
     {
         init();
         ll jishu=;
         for(int i=; i<=n; i++){
             scanf("%lld",&col[i]);
             if(gg[col[i]]==){
                 jishu++;
                 gg[col[i]]=;
             }
             }
         ll a,b;
         for(int i=; i<n; i++)
         {
             scanf("%lld %lld",&a,&b);
             add(a,b);
             add(b,a);
         }
         ans=jishu*(n*(n-)/);
         dfs();
         for(int i=;i<=n;i++){
             if(sum[i]!=){
                ll res=n-sum[i];
                ans=ans-(res-)*res/;
             }
         }
         printf("Case #%d: %lld\n",++t,ans);
     }
 return ;
 }

hdu 6038

 #pragma comment(linker, "/STACK:102400000,102400000")
 #include <cstdio>
 #include <iostream>
 #include <cstdlib>
 #include <cstring>
 #include <algorithm>
 #include <cmath>
 #include <cctype>
 #include <map>
 #include <set>
 #include <queue>
 #include <bitset>
 #include <string>
 #include <complex>
 #define ll long long
 #define mod 1000000007
 using namespace std;
 int n,m;
 int a[];
 int b[];
 vector<int> aa;
 vector<int> bb;
 map<int,int>mp;
 int main()
 {
     int t=;
     while(scanf("%d %d",&n,&m)!=EOF)
     {
         aa.clear();
         bb.clear();
         mp.clear();
         for(int i=; i<n; i++)
             scanf("%d",&a[i]);
         for(int j=; j<m; j++)
             scanf("%d",&b[j]);
         for(int i=;i<n;i++)
         {
             if(mp[i]==)
             {
                 int now=;
                 mp[i]=;
                 int s=i;
                 while(mp[a[s]]==){
                     now++;
                     mp[a[s]]=;
                     s=a[s];
                 }
                 aa.push_back(now);
             }
         }
         mp.clear();
          for(int i=;i<m;i++)
         {
             if(mp[i]==)
             {
                 int now=;
                 mp[i]=;
                 int s=i;
                 while(mp[b[s]]==){
                     now++;
                     mp[b[s]]=;
                     s=b[s];
                 }
                 bb.push_back(now);
             }
         }
         ll ans=;
         for(int i=;i<aa.size();i++){
              ll temp=;
             for(int j=;j<bb.size();j++){

                 if(aa[i]%bb[j]==)
                   temp+=bb[j];
             }
              ans=(ans*temp)%mod;
         }
         printf("Case #%d: %lld\n",++t,ans);
     }
     return ;
 }

hdu 6043

 #pragma comment(linker, "/STACK:102400000,102400000")
 #include <cstdio>
 #include <iostream>
 #include <cstdlib>
 #include <cstring>
 #include <algorithm>
 #include <cmath>
 #include <cctype>
 #include <map>
 #include <set>
 #include <queue>
 #include <bitset>
 #include <string>
 #include <complex>
 #define ll long long
 #define mod 1000000007
 using namespace std;
 ll n,k;
 int main()
 {
     int t=;
    while(scanf("%lld %lld",&n,&k)!=EOF){
      if(k<=n)
          printf("Case #%d: %lld\n",++t,k);
      else
     {
        ll now;
        ll which;
        now=(k-n)/(n-);
        which=(k-n)%(n-);
        if(now%==)
        {
            if(which==)
             printf("Case #%d: %lld\n",++t,n);
            else
             printf("Case #%d: %lld\n",++t,which);
        }
        else
        {
            if(which==)
             printf("Case #%d: %lld\n",++t,n-);
            else
             printf("Case #%d: %lld\n",++t,which);
        }
     }
    }
     return ;
 }