标签：
此文章可以使用目录功能哟↑(点击上方[+])
有点智商捉急,第一题卡了好久,看来不服老,不服笨是不行的了...以下是本人目前的题解,有什么疑问欢迎提出
链接→2016"百度之星" - 初赛（Astar Round2A）
Problem 1001 All XAccept: 0 Submit: 0
Time Limit: 2000/1000 mSec(Java/Others) Memory Limit : 65536 KB
Problem DescriptionF(x,m) 代表一个全是由数字x组成的m位数字。请计算，以下式子是否成立：
F(x,m) mod k ≡ c
Input Output对于每组数据，输出两行： 第一行输出："Case #i:"。i代表第i组测试数据。 第二行输出“Yes” 或者 “No”，代表四个数字，是否能够满足题目中给的公式。
Sample Input Sample Output
Problem Idea解题思路:此题求的是m个数字x组成的m位数对k取模是否等于c,从m的大小可以看出此题想利用同余定理1位1位计算是解决不了了,这样我们就得换种思路,首先,我们提取一个x,那剩下的就是m个1,如下:
这个数要mod k ,那这个数应该怎么表示呢?
就这样转化了,然后10^m可以通过快速幂解决,但是很明显,除以9操作怎么办,除法取模,余数是会改变的,逆元?但是9和k不一定互质,且k也不一定是质数,所以扩展欧几里得和费马小定理都不能用了,束手无策
好吧,这里提供一种小方法
就这样经过几步转化,我求d不需要进行除法取模了,那我上面的问题不就解决了?对的
在这里,我要提一点更优化的操作(虽然此题优化效果不是太明显)
首先我们知道欧拉定理
φ(k)为欧拉函数,表示k以内与k互质的数的个数
而我们在求解10^m的时候就可以借用欧拉定理降幂
不好意思,上面的欧拉定理降幂误导了大家,欧拉定理成立是有条件的,即a与k需要互质,本题10与k不一定互质
只能说题目数据才水,本人考虑不周,不过去掉欧拉定理这部分,代码还是对的,降幂这点小优化没有还可以靠快速幂弥补,不要紧
题目链接→HDU 5690 All X
Source Code
/*Sherlock and Watson and Adler*/
#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<queue>
#include<stack>
#include<math.h>
#include<vector>
#include<map>
#include<set>
#include<cmath>
#include<complex>
#include<string>
#include<algorithm>
#include<iostream>
#define exp 1e-10
using namespace std;
const int N = 100005;
const int M = 40;
const int inf = 100000000;
//const int mod = 2009;
__int64 Quick_Mod(__int64 a, __int64 b, __int64 mod)
{
__int64 res = 1,term = a % mod;
while(b)
{
if(b & 1) res = (res * term) % mod;
term = (term * term) % mod;
b >>= 1;
}
return res;
}
/*__int64 euler(__int64 n)
{
__int64 ans=1;
__int64 i;
for(i=2;i*i<=n;i++)
{
if(n%i==0)
{
n/=i;
ans*=i-1;
while(n%i==0)
{
n/=i;
ans*=i;
}
}
}
if(n>1)
ans*=n-1;
return ans;
}*/
int main()
{
int t,p=1,i;
__int64 m,ans,x,c,k;
scanf("%d",&t);
while(t--)
{
scanf("%I64d%I64d%I64d%I64d",&x,&m,&k,&c);
k*=9;
//m%=euler(k);
ans=(Quick_Mod(10,m,k)+k-1)%k;
ans/=9;
k/=9;
ans=(ans*x)%k;
//printf("%I64d\n",ans);
printf("Case #%d:\n",p++);
if(ans==c)
puts("Yes");
else
puts("No");
}
return 0;
}
Problem 1005 BD StringAccept: 0 Submit: 0
Time Limit: 2000/1000 mSec(Java/Others) Memory Limit : 65536 KB
Problem Description众所周知，度度熊喜欢的字符只有两个：B和D。
今天，它发明了一种用B和D组成字符串的规则：
S(1)=B
S(2)=BBD
S(3)=BBDBBDD
…
S(n)=S(n-1)+B+reverse(flip(S(n-1))
其中，reverse(s)指将字符串翻转，比如reverse(BBD)=DBB，flip(s)指将字符串中的B替换为D，D替换为B，比如flip(BBD)=DDB。
虽然度度熊平常只用它的电脑玩连连看，这丝毫不妨碍这台机器无与伦比的运算速度，目前它已经算出了S(
Input
) 。
Output对于每组数据，输出S(
Sample Input Sample Output
Problem Idea解题思路:从字符串规则可以看出以下几点
①S(n)的串长度为
②S(n)中B的个数为
③
由上述几点可知,此题并没有表面上那么吓人
要求区间[l,r]内B的个数,我们可以转化为求[1,r]-[1,l-1]
而求区间[1,x]内B的个数,又可以如上述第②条所说,拆成3段,递归求解
比如x=12时,S=BBDBBDDBBBDD……
拆成3段如下:
右边4个是多余的,但是因为右边是由reverse+flip得到的,求右边4个中B的个数可以转化成求4-([1,7]中B的个数-[1,3]中B的个数)
而[1,3]中的个数又是得递归求解的
这题递归讲得比较绕,要是小伙伴没明白的,可以留下评论,我会及时回复的
题目链接→HDU 5694 BD String
Source Code
/*Sherlock and Watson and Adler*/
#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<queue>
#include<stack>
#include<math.h>
#include<vector>
#include<map>
#include<set>
#include<cmath>
#include<complex>
#include<string>
#include<algorithm>
#include<iostream>
#define exp 1e-10
using namespace std;
const int N = 100005;
const int M = 40;
const int inf = 100000000;
const int mod = 2009;
__int64 dfs(__int64 x)
{
if(!x)
return 0;
__int64 m=0,ans,res;
while(m<x)
m=m*2+1;
m=(m-1)/2;
ans=(m+1)/2;
res=x-m-1;
return ans+1+res-(ans-dfs(m-res));
}
int main()
{
int t;
__int64 l,r;
scanf("%d",&t);
while(t--)
{
scanf("%I64d%I64d",&l,&r);
printf("%I64d\n",dfs(r)-dfs(l-1));
}
return 0;
}
Problem 1006 Gym ClassAccept: 0 Submit: 0
Time Limit: 6000/1000 mSec(Java/Others) Memory Limit : 65536 KB
Problem Description众所周知，度度熊喜欢各类体育活动。
今天，它终于当上了梦寐以求的体育课老师。第一次课上，它发现一个有趣的事情。在上课之前，所有同学要排成一列， 假设最开始每个人有一个唯一的ID，从1到N，在排好队之后，每个同学会找出包括自己在内的前方所有同学的最小ID，作为自己评价这堂课的分数。麻烦的是，有一些同学不希望某个（些）同学排在他（她）前面，在满足这个前提的情况下，新晋体育课老师——度度熊，希望最后的排队结果可以使得所有同学的评价分数和最大。
Input Output对于每组数据，输出最大分数 。
Sample Input Sample Output Problem Idea解题思路:众所周知,为了使每个人给的评分尽可能高,在没有条件的情况下,必定是ID高的排前面来得最优
但是度度熊没有那么善良
ID为B的同学不能排在A前面,好吧,怎么做呢?
对于这种调度问题,我们不妨用拓扑排序来求解
假设B不能排在A前面,那么我就在AB之间画一条从A指向B的边,那么我们可以得到一幅有向图
我们要按ID从大往小排,同时要考虑当前这位同学是否有特殊要求
上面有向图中,凡入度为0的结点,表示没有同学不希望该同学排在它的前面,故该同学可以按照ID从大往小排
所以此题的做法是,每次将入度为0的结点放入优先队列中,选取ID最大的结点先排,然后将该ID的同学讨厌的所有同学入度-1,若入度变为0同样要放入优先队列判断ID先后,这里建图可以邻接表实现,也可以利用一些vector
题目链接→HDU 5695 Gym Class
Source Code
/*Sherlock and Watson and Adler*/
#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<queue>
#include<stack>
#include<math.h>
#include<vector>
#include<map>
#include<set>
#include<cmath>
#include<complex>
#include<string>
#include<algorithm>
#include<iostream>
#define exp 1e-10
using namespace std;
const int N = 100005;
const int M = 40;
const int inf = 100000000;
const int mod = 2009;
struct cmp2
{
bool operator ()(int &a,int &b)
{
return a<b;//最大值优先
}
};
int n, m;
int indegree[N];
priority_queue<int,vector<int>,cmp2> q;//最大值优先
vector<int> v[N];
int main()
{
int t,i,a,b,p,Min;
__int64 ans;
scanf("%d",&t);
while(t--)
{
ans=0;
Min=inf;
memset(indegree,0,sizeof(indegree));
for(i=1;i<=n;i++)
v[i].clear();
while(!q.empty())
q.pop();
scanf("%d%d",&n,&m);
for(i=0;i<m;i++)
{
scanf("%d%d",&a,&b);
indegree[b]++;
v[a].push_back(b);
}
for(i=1;i<=n;i++)
if(!indegree[i])
q.push(i);
while(!q.empty())
{
p=q.top();
q.pop();
Min=min(p,Min);
ans+=Min;
for(i=0;i<v[p].size();i++)
{
indegree[v[p][i]]--;
if(!indegree[v[p][i]])
q.push(v[p][i]);
}
}
printf("%I64d\n",ans);
}
return 0;
}
菜鸟成长记
2016"百度之星" - 初赛（Astar Round2A）解题报告
标签：
原文地址：http://blog.csdn.net/queuelovestack/article/details/51471639
