2013 Dhaka 区域赛

A.uva 12709 Falling ANTS

首先按照Ｈ排序，然后按照Ｌ＊Ｈ＊Ｗ排序　

 #include<iostream>
 #include<cstdio>
 #include <math.h>
 #include<algorithm>
 #include<string.h>
 #define maxn 100009
 #define inf 100000
 using namespace std;
 int main()
 {
         int n,a,b,c;
         while()
         {
                 int ans=,ans_h=;
                 scanf("%d",&n);
                 if(n==)break;
                 for(int i=;i<=n;i++)
                 {
                         scanf("%d%d%d",&a,&b,&c);
                         if(c>ans_h)ans_h=c,ans=a*b*c;
                         else if(c==ans_h && a*b*c>ans)ans=a*b*c;
                 }
                 printf("%d\n",ans);
         }
         return ;
 }

 D uva 12712 Pattern Locker

题目大意：一个Ｌ＊Ｌ的安卓密码锁，问最少按Ｍ个钮，最多按Ｎ个扭，一共有多少中不同的方式加锁，注意正常来说１　３　２，是不合法的，但在这里是合法的，但同一个按钮还是不能走两次

思路:排列组合一下就出来了，比如第一个样例：９＊８＊７＊６＋９＊８＊７＊６＊５＋９＊８＊７＊６＊５＊４＋９＊８＊７＊６＊５＊４＊３＋９＊８＊７＊６＊５＊４＊３＊２＋９＊８＊７＊６＊５＊４＊３＊２＊１

 #include<iostream>
 #include<cstdio>
 #include <math.h>
 #include<algorithm>
 #include<string.h>
 #define maxn 100009
 #define inf 100000
 #define MOD (10000000000007ll)
 using namespace std;
 int main()
 {
         int t,cas=;
         scanf("%d",&t);
         while(t--)
         {
                 long long a,b,c;
                 scanf("%lld%lld%lld",&a,&b,&c);
                 long long u=a*a,ans=;
                 for(int i=;i<=b;i++)ans=ans*(u-i+)%MOD;
                 long long temp=ans;
                 for(int i=b+;i<=c;i++)
                         temp=(temp*(u-i+))%MOD,ans=(ans+temp%MOD)%MOD;
                 printf("Case %d: %lld\n",++cas,ans);
         }
         return ;
 }

E uva 12713 Pearl Chains

题目大意：有三种类型的珍珠，每种类型的珍珠分别能够染色x,y,ｚ种颜色，1号类型珍珠加３号类型珍珠共Ａ个，２号类型珍珠和３号类型珍珠共Ｂ个，问有多少种摆珍珠的方案

思路：公式在比赛的时候就推出来了，枚举２号类型的珍珠个数即可　ΣＣ（ｉ,Ａ＋Ｂ－ｉ）＊Ｃ（Ａ－ｉ，Ａ＋Ｂ－２＊ｉ）＊ｘ^A-1*y^B-1*zⁱ,关键数字太大，还需要ｌｕｃａｓ定理

 #include<iostream>
 #include<cstdio>
 #include <math.h>
 #include<algorithm>
 #include<string.h>
 #include<queue>
 #define MOD 1000003
 #define maxn 1000000
 using namespace std;
 long long fac[MOD+],inv[MOD+],a,b,x,y,z;
 long long mpow(long long a,long long n){
         if(n==)return ;
         if(n==)return a%MOD;
         if(n&)return (a*mpow(a,n-))%MOD;
         else{
                 long long u=mpow(a,n>>);
                 return (u*u)%MOD;
         }
 }
 long long C(long long m,long long n)
 {
         if(m==)return ;
         return ((fac[n]*inv[m]%MOD)*inv[n-m])%MOD;
 }
 int main()
 {
         int t;
         fac[]=inv[]=;
         for(int i=;i<=MOD;i++)
         {
                 fac[i]=(fac[i-]*(long long)i)%MOD;
                 inv[i]=mpow(fac[i],MOD-);
                // cout << fac[i]<<" "<<inv[i]<<endl;
         }
         scanf("%d",&t);
         //printf("%lld\n",C(2,5));
         while (t--)
         {
                 long long ans=;
                 scanf("%lld%lld%lld%lld%lld",&a,&b,&x,&y,&z);
                 x%=MOD;y%=MOD;z%=MOD;
                 while(a||b)
                 {
                         long long u=a%MOD,v=b%MOD,min_x=min(u,v),ret=,temp=;
                         for(int i=;i<=min_x;i++)
                         {
                                 temp=(C(i,u+v-i)*C(u-i,u+v-i-i))%MOD;
                                 temp=(temp*mpow(x,u-i))%MOD;
                                 temp=(temp*mpow(y,v-i))%MOD;
                                 temp=(temp*mpow(z,i))%MOD;
                                 ret=(ret+temp)%MOD;
                         }
                         ans=(ans*ret)%MOD;
                         a/=MOD,b/=MOD;
                 }
                 printf("%lld\n",ans);
         }
         return ;
 }

F uva 12714 Two Points Revisited

题目大意：给你两个点，要你再求两点，使得与题目中给出的两点垂直，并且两点要在矩形框内，输出任意一种即可

思路：思路很多，ＣＰ和ｚｙｘ分别有自己的思路，其实就是个ｓｂ题，我的话先求出任意一条垂直的两点，然后将其平移到第一象限，然后再将其移到第一象限的左下角即可

 #include<iostream>
 #include<cstdio>
 #include <math.h>
 #include<algorithm>
 #include<string.h>
 #define maxn 100009
 #define inf 100000
 #define MOD (10000000000007ll)
 using namespace std;
 int main()
 {
         int t,cas=,x1,y1,x2,y2,x3,x4,y3,y4;
         scanf("%d",&t);
         while(t--)
         {
                 scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
                 x3=x1,y3=y1,x4=x1+y2-y1,y4=y1-(x2-x1);
                 if(x3<)x4-=x3,x3=;
                 if(y3<)y4-=y3,y3=;
                 if(x4<)x3-=x4,x4=;
                 if(y4<)y3-=y4,y4=;
                 int u=min(y4,y3);
                 y4-=u,y3-=u;
                 u=min(x4,x3);
                 x4-=u;x3-=u;
                 printf("Case %d: %d %d %d %d\n",++cas,x3,y3,x4,y4);
         }
         return ;
 }

H UVA 12716 GCD XOR

题目大意：有多少小于等于N的数对（A，B），满足GCD（A，B）=A XOR B 1<=B<=A<=N

思路：感觉能想出这题真心好不容易！！！关键要知道一个结论：设GCD（A，B）= C ，A-C=B

以上结论在打过N张表后被总结下来，其中ZYX在这道题几乎耗了3个多小时TUT，知道结论以后暴力即可！

然后照着结论推证明

A-B<=A XOR B<=A+B  (由于XOR可以理解成不带进位的加法，同样也可以理解成不带借位的减法)

∵A XOR B=GCD（A，B）

∴A-B<=GCD（A，B）<=A+B

同时由辗转相减法可得GCD（A，B）=GCD（A-B，B）<=A-B

即A-B<=GCD（A，B）<=A-B

QED.

 #include<iostream>
 #include<cstdio>
 #include <math.h>
 #include<algorithm>
 #include<string.h>
 #include<queue>
 #define maxn 30000000
 #define inf 100000
 #define MOD (10000000000007ll)
 using namespace std;
 int ans[maxn];
 int main()
 {
         for(int i=;i<=maxn;i++)
                 for(int j=;j*i<=maxn;j++)
                 {
                         int u=i*j,b=u-i;
                         if((b^u)==i)ans[u]++;
                 }
         for(int i=;i<=maxn;i++)ans[i]+=ans[i-];
         int t,n,cas=;
         scanf("%d",&t);
         while(t--)
         {
                 scanf("%d",&n);
                 printf("Case %d: %d\n",++cas,ans[n]);
         }
         return ;
 }

I UVA 12717 Fiasco

题目大意:前面给了一坨眼睛都快看出血的代码，其实是prim，所以它做的应该是求出以s为根的最小生成树，而要最小生成树上的边正好等于最短路树

思路:这题的话DFS序和BFS序应该都行，一开始看样例构造了个BFS序就过了，证明的话以DFS序为例子，假设现在正在遍历非树边，那它的序号一定比所有的树边大，并且当前构成环，由MST回路性质可得该边肯定不是MST上的边，很明显该边也肯定不是最短路树上的边

 #include<iostream>
 #include<cstdio>
 #include <math.h>
 #include<algorithm>
 #include<string.h>
 #include<queue>
 #define maxn 250000
 #define inf 100000
 #define MOD (10000000000007ll)
 using namespace std;
 int cnt=;
 int head[maxn],next[maxn],point[maxn],now=;
 int ans[maxn],n,m,source,x[maxn],y[maxn],v[maxn];
 bool visit[maxn],visit1[maxn];
 void add(int x,int y,int v)
 {
         next[++now]=head[x];
         head[x]=now;
         point[now]=y;
 }
 void bfs(int s)
 {
         queue<int>q;
         q.push(s);
         visit[s]=;
         while(!q.empty())
         {
                 s=q.front();
                 q.pop();
                 for(int i=head[s];i;i=next[i])if(!visit1[i])
                 {
                         visit1[i]=visit1[i^]=;
                         int u=point[i];
                         ans[i>>]=++cnt;
                         if(!visit[u])q.push(u),visit[u]=;
                 }
         }
 }
 int main()
 {
         int t,cas=;
         scanf("%d",&t);
         while(t--)
         {
                 now=; cnt=;
                 memset(visit,,sizeof(visit));
                 memset(visit1,,sizeof(visit1));
                 memset(head,,sizeof(head));
                 scanf("%d%d%d",&n,&m,&source);
                 printf("Case %d:\n",++cas);
                 for(int i=;i<=m;i++)
                 {
                         scanf("%d%d%d",&x[i],&y[i],&v[i]);
                         add(x[i],y[i],v[i]);
                         add(y[i],x[i],v[i]);
                 }
                 bfs(source);
                 //printf("%d\n",cnt);
                 for(int i=;i<=m;i++)
                 {
                         printf("%d %d %d\n",x[i],y[i],ans[i]);
                 }
         }
         return ;
 }

J  uva 12718 Dromicpalin Substrings

题目大意：一个字符串，有多少连续的子串可以重排成回文串

思路：显然能够重排成回文串的字符串奇数个字符的个数小于等于1,然后O（n^2）扫一遍就行

 #include<iostream>
 #include<cstdio>
 #include <math.h>
 #include<algorithm>
 #include<string.h>
 #define maxn 100009
 #define inf 100000
 #define MOD (10000000000007ll)
 using namespace std;
 char ch[maxn];
 int visit[];
 int main()
 {
         int t,cas=;
         scanf("%d",&t);
         while(t--)
         {
                 int ans=,odd;
                 scanf("%s",ch+);
                 int len=strlen(ch+);
                 for(int i=;i<=len;i++)
                 {
                         memset(visit,,sizeof(visit));
                         for(int j=i;j>=;j--)
                         {
                                 if(i==j)
                                 {
                                         visit[ch[i]-'a']=;
                                         odd=;
                                         ans++;
                                 }
                                 else
                                 {
                                         visit[ch[j]-'a']=visit[ch[j]-'a']+;
                                         if(visit[ch[j]-'a']&)odd++;
                                         else odd--;
                                         if(odd<=)ans++;
                                 }
                         }
                 }
                 printf("Case %d: %d\n",++cas,ans);
         }
         return ;
 }